alchemy_cms 5.3.7 → 6.0.0.b1

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

@@ -3,27 +3,31 @@
 module Alchemy
   module Admin
     class ElementsController < Alchemy::Admin::BaseController
-      before_action :load_element, only: [:update, :trash, :fold, :publish]
+      before_action :load_element, only: [:update, :destroy, :fold, :publish]
       authorize_resource class: Alchemy::Element
 
       def index
-        @page = Page.find(params[:page_id])
-        @elements = @page.all_elements.not_nested.unfixed.not_trashed.includes(*element_includes)
-        @fixed_elements = @page.all_elements.fixed.not_trashed.includes(*element_includes)
+        @page_version = PageVersion.find(params[:page_version_id])
+        @page = @page_version.page
+        elements = @page_version.elements.order(:position).includes(*element_includes)
+        @elements = elements.not_nested.unfixed
+        @fixed_elements = elements.not_nested.fixed
       end
 
       def new
-        @page = Page.find(params[:page_id])
+        @page_version = PageVersion.find(params[:page_version_id])
+        @page = @page_version.page
         @parent_element = Element.find_by(id: params[:parent_element_id])
         @elements = @page.available_elements_within_current_scope(@parent_element)
-        @element = @page.elements.build
+        @element = @page_version.elements.build
         @clipboard = get_clipboard("elements")
         @clipboard_items = Element.all_from_clipboard_for_page(@clipboard, @page)
       end
 
       # Creates a element as discribed in config/alchemy/elements.yml on page via AJAX.
       def create
-        @page = Page.find(params[:element][:page_id])
+        @page_version = PageVersion.find(params[:element][:page_version_id])
+        @page = @page_version.page
         Element.transaction do
           if @paste_from_clipboard = params[:paste_from_clipboard].present?
             @element = paste_element_from_clipboard
@@ -38,7 +42,7 @@ module Alchemy
         if @element.valid?
           render :create
         else
-          @element.page = @page
+          @element.page_version = @page_version
           @elements = @page.available_element_definitions
           @clipboard = get_clipboard("elements")
           @clipboard_items = Element.all_from_clipboard_for_page(@clipboard, @page)
@@ -51,40 +55,38 @@ module Alchemy
       # And update all contents in the elements by calling update_contents.
       #
       def update
-        if @element.update_contents(contents_params)
-          @page = @element.page
-          @element_validated = @element.update(element_params)
+        @page = @element.page
+
+        if element_params.key?(:ingredients_attributes)
+          update_element_with_ingredients
         else
-          @element_validated = false
-          @notice = Alchemy.t("Validation failed")
-          @error_message = "<h2>#{@notice}</h2><p>#{Alchemy.t(:content_validations_headline)}</p>".html_safe
+          update_element_with_contents
         end
       end
 
-      def publish
-        @element.update(public: !@element.public?)
+      def destroy
+        @element.destroy
+        @notice = Alchemy.t("Successfully deleted element") % { element: @element.display_name }
       end
 
-      # Trashes the Element instead of deleting it.
-      def trash
-        @page = @element.page
-        @element.trash!
+      def publish
+        @element.update(public: !@element.public?)
       end
 
       def order
-        @trashed_element_ids = Element.trashed.where(id: params[:element_ids]).pluck(:id)
         @parent_element = Element.find_by(id: params[:parent_element_id])
         Element.transaction do
-          params.fetch(:element_ids, []).each_with_index do |element_id, idx|
-            # Ensure to set page_id and parent_element_id to the current
-            # because of trashed elements could still have old values
-            Element.where(id: element_id).update_all(
-              page_id: params[:page_id],
+          params.fetch(:element_ids, []).each.with_index(1) do |element_id, position|
+            # We need to set the parent_element_id, because we might have dragged the
+            # element over from another nestable element
+            Element.find_by(id: element_id).update_columns(
               parent_element_id: params[:parent_element_id],
-              position: idx + 1,
+              position: position,
             )
           end
-          @parent_element.try!(:touch)
+          # Need to manually touch the parent because Rails does not do it
+          # with the update_columns above
+          @parent_element&.touch
         end
       end
 
@@ -102,6 +104,7 @@ module Alchemy
             contents: {
               essence: :ingredient_association,
             },
+            ingredients: :related_object,
           },
           :tags,
           {
@@ -110,6 +113,7 @@ module Alchemy
                 contents: {
                   essence: :ingredient_association,
                 },
+                ingredients: :related_object,
               },
               :tags,
             ],
@@ -132,7 +136,7 @@ module Alchemy
         @source_element = Element.find(element_from_clipboard["id"])
         element = Element.copy(@source_element, {
           parent_element_id: create_element_params[:parent_element_id],
-          page_id: @page.id,
+          page_version_id: @page_version.id,
         })
         if element_from_clipboard["action"] == "cut"
           @cut_element_id = @source_element.id
@@ -147,15 +151,35 @@ module Alchemy
       end
 
       def element_params
-        if @element.taggable?
-          params.fetch(:element, {}).permit(:tag_list)
+        params.fetch(:element, {}).permit(:tag_list, ingredients_attributes: {})
+      end
+
+      def create_element_params
+        params.require(:element).permit(:name, :page_version_id, :parent_element_id)
+      end
+
+      def update_element_with_ingredients
+        if @element.update(element_params)
+          @element_validated = true
         else
-          params.fetch(:element, {})
+          element_update_error
+          @error_messages = @element.ingredient_error_messages
         end
       end
 
-      def create_element_params
-        params.require(:element).permit(:name, :page_id, :parent_element_id)
+      def update_element_with_contents
+        if @element.update_contents(contents_params)
+          @element_validated = @element.update(element_params)
+        else
+          element_update_error
+          @error_messages = @element.essence_error_messages
+        end
+      end
+
+      def element_update_error
+        @element_validated = false
+        @notice = Alchemy.t("Validation failed")
+        @error_message = "<h2>#{@notice}</h2><p>#{Alchemy.t(:content_validations_headline)}</p>".html_safe
       end
     end
   end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    class EssenceAudiosController < Alchemy::Admin::BaseController
+      authorize_resource class: Alchemy::EssenceAudio
+      before_action :load_essence
+
+      def update
+        @essence_audio.update(essence_audio_params)
+      end
+
+      private
+
+      def load_essence
+        @essence_audio = EssenceAudio.find(params[:id])
+      end
+
+      def essence_audio_params
+        params.require(:essence_audio).permit(
+          :autoplay,
+          :controls,
+          :loop,
+          :muted,
+          :attachment_id
+        )
+      end
+    end
+  end
+end

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

@@ -17,20 +17,6 @@ module Alchemy
         @essence_file.update(essence_file_params)
       end
 
-      # Assigns file, but does not saves it.
-      #
-      # When the user saves the element the content gets updated as well.
-      #
-      def assign
-        @content = Content.find_by(id: params[:content_id])
-        @attachment = Attachment.find_by(id: params[:attachment_id])
-        @content.essence.attachment = @attachment
-
-        # We need to update timestamp here because we don't save yet,
-        # but the cache needs to be get invalid.
-        @content.touch
-      end
-
       private
 
       def essence_file_params

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

@@ -3,11 +3,12 @@
 module Alchemy
   module Admin
     class EssencePicturesController < Alchemy::Admin::BaseController
-      FLOAT_REGEX = /\A\d+(\.\d+)?\z/
+      include CropAction
+
       authorize_resource class: Alchemy::EssencePicture
 
-      before_action :load_essence_picture, only: [:edit, :crop, :update]
-      before_action :load_content, only: [:edit, :update, :assign]
+      before_action :load_essence_picture, only: [:edit, :update]
+      before_action :load_content, only: [:edit, :update]
 
       helper "alchemy/admin/contents"
       helper "alchemy/admin/essences"
@@ -16,94 +17,22 @@ module Alchemy
       def edit
       end
 
-      def crop
-        if @picture = @essence_picture.picture
-          @content = @essence_picture.content
-          @min_size = sizes_from_essence_or_params
-          @ratio = ratio_from_size_or_settings
-          infer_width_or_height_from_ratio
-
-          @default_box = @essence_picture.default_mask(@min_size)
-          @initial_box = @essence_picture.cropping_mask || @default_box
-        else
-          @no_image_notice = Alchemy.t(:no_image_for_cropper_found)
-        end
-      end
-
       def update
         @essence_picture.update(essence_picture_params)
       end
 
-      # Assigns picture, but does not save it.
-      #
-      # When the user saves the element the content gets updated as well.
-      #
-      def assign
-        @picture = Picture.find_by(id: params[:picture_id])
-        @content.essence.picture = @picture
-        @element = @content.element
-
-        # We need to update timestamp here because we don't save yet,
-        # but the cache needs to be get invalid.
-        @content.touch
-      end
-
-      def destroy
-        @content = Content.find_by(id: params[:id])
-        @element = @content.element
-        @content_id = @content.id
-        @content.destroy
-        @essence_pictures = @element.contents.essence_pictures
-      end
-
       private
 
       def load_essence_picture
         @essence_picture = EssencePicture.find(params[:id])
       end
 
-      def load_content
-        @content = Content.find(params[:content_id])
+      def load_croppable_resource
+        @croppable_resource = EssencePicture.find(params[:id])
       end
 
-      # Gets the minimum size of the image to be rendered.
-      #
-      # The +render_size+ attribute has preference over the contents +size+ setting.
-      #
-      def sizes_from_essence_or_params
-        if @essence_picture.render_size?
-          @essence_picture.sizes_from_string(@essence_picture.render_size)
-        elsif @essence_picture.content.settings[:size]
-          @essence_picture.sizes_from_string(@essence_picture.content.settings[:size])
-        else
-          { width: 0, height: 0 }
-        end
-      end
-
-      # Infers the aspect ratio from size or contents settings. If you don't want a fixed
-      # aspect ratio, don't specify a size or only width or height.
-      #
-      def ratio_from_size_or_settings
-        if @min_size.value?(0) && @essence_picture.content.settings[:fixed_ratio].to_s =~ FLOAT_REGEX
-          @essence_picture.content.settings[:fixed_ratio].to_f
-        elsif !@min_size[:width].zero? && !@min_size[:height].zero?
-          @min_size[:width].to_f / @min_size[:height]
-        else
-          false
-        end
-      end
-
-      # Infers the minimum width or height
-      # if the aspect ratio and one dimension is specified.
-      #
-      def infer_width_or_height_from_ratio
-        return unless @ratio
-
-        if @min_size[:height].zero?
-          @min_size[:height] = (@min_size[:width] / @ratio).to_i
-        else
-          @min_size[:width] = (@min_size[:height] * @ratio).to_i
-        end
+      def load_content
+        @content = Content.find(params[:content_id])
       end
 
       def essence_picture_params

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

@@ -7,7 +7,7 @@ module Alchemy
 
       helper "alchemy/pages"
 
-      before_action :load_resource, except: [:index, :flush, :new, :order, :create, :copy_language_tree, :link]
+      before_action :load_resource, except: [:index, :flush, :new, :order, :create, :copy_language_tree, :link, :sort]
 
       authorize_resource class: Alchemy::Page, except: [:index, :tree]
 
@@ -21,7 +21,7 @@ module Alchemy
         except: [:show]
 
       before_action :set_root_page,
-        only: [:index, :show, :order]
+        only: [:index, :show, :sort, :order]
 
       before_action :run_on_page_layout_callbacks,
         if: :run_on_page_layout_callbacks?,
@@ -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])
 
@@ -118,7 +120,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
@@ -128,7 +129,6 @@ module Alchemy
       def update
         # stores old page_layout value, because unfurtunally rails @page.changes does not work here.
         @old_page_layout = @page.page_layout
-        @old_parent_id = @page.parent_id
         if @page.update(page_params)
           @notice = Alchemy.t("Page saved", name: @page.name)
           @while_page_edit = request.referer.include?("edit")
@@ -137,7 +137,7 @@ module Alchemy
             @tree = serialized_page_tree
           end
         else
-          render :configure
+          configure
         end
       end
 
@@ -173,7 +173,9 @@ module Alchemy
       def fold
         # @page is fetched via before filter
         @page.fold!(current_alchemy_user.id, !@page.folded?(current_alchemy_user.id))
-        render json: serialized_page_tree
+        respond_to do |format|
+          format.js
+        end
       end
 
       # Leaves the page editing mode and unlocks the page for other users
@@ -190,24 +192,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
@@ -218,6 +208,10 @@ module Alchemy
         redirect_to admin_pages_path
       end
 
+      def sort
+        @sorting = true
+      end
+
       # Receives a JSON object representing a language tree to be ordered
       # and updates all pages in that language structure to their correct indexes
       def order
@@ -398,12 +392,14 @@ 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,
-        )
+        PageTreeSerializer.new(@page, ability: current_ability,
+                                      user: current_alchemy_user,
+                                      full: params[:full] == "true")
       end
 
       def load_languages_and_layouts

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

@@ -9,12 +9,16 @@ 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(
@@ -32,10 +36,21 @@ module Alchemy
       def show
         @previous = @picture.previous(params)
         @next = @picture.next(params)
-        @assignments = @picture.essence_pictures.joins(content: {element: :page})
+        @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
@@ -125,8 +140,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 +173,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/api/elements_controller.rb

@@ -9,18 +9,21 @@ module Alchemy
     # If you want to only load a specific type of element pass ?named=an_element_name
     #
     def index
-      @elements = Element.not_nested
+      if params[:page_id].present?
+        @page = Page.find(params[:page_id])
+        @elements = @page.elements.not_nested
+      else
+        @elements = Element.not_nested.joins(:page_version).merge(PageVersion.published)
+      end
+
       # 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)
       end
-      if params[:page_id].present?
-        @elements = @elements.where(page_id: params[:page_id])
-      end
       if params[:named].present?
         @elements = @elements.named(params[:named])
       end
-      @elements = @elements.includes(*element_includes)
+      @elements = @elements.includes(*element_includes).order(:position)
 
       render json: @elements, adapter: :json, root: "elements"
     end
@@ -43,6 +46,7 @@ module Alchemy
               contents: {
                 essence: :ingredient_association,
               },
+              ingredients: :related_object,
             },
             :tags,
           ],
@@ -51,6 +55,7 @@ module Alchemy
           contents: {
             essence: :ingredient_association,
           },
+          ingredients: :related_object,
         },
         :tags,
       ]

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

@@ -8,7 +8,6 @@ module Alchemy
     def index
       @nodes = Node.all
       @nodes = @nodes.includes(:parent)
-      @nodes = @nodes.where(language_id: params[:language_id]) if params[:language_id]
       @nodes = @nodes.ransack(params[:filter]).result
 
       if params[:page]