maglevcms 2.0.0 → 3.0.0.beta1

data/app/controllers/maglev/editor/base_controller.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class BaseController < ::Maglev::ApplicationController
+      layout 'maglev/editor/application'
+
+      default_form_builder Maglev::Form::FormBuilder
+
+      include Maglev::AuthenticationConcern
+      include Maglev::UserInterfaceLocaleConcern
+      include Maglev::ContentLocaleConcern
+      include Maglev::ServicesConcern
+      include Maglev::FlashI18nConcern
+      include Maglev::Editor::ErrorsConcern
+
+      before_action :fetch_maglev_site
+      before_action :fetch_maglev_page
+      before_action :set_content_locale
+
+      helper Maglev::ApplicationHelper
+      helper_method :maglev_site, :maglev_theme,
+                    :current_maglev_page, :current_maglev_sections, :current_maglev_page_urls,
+                    :maglev_editing_route_context, :maglev_disable_turbo_cache?,
+                    :maglev_page_live_url, :maglev_page_preview_url
+
+      private
+
+      def fetch_maglev_site
+        maglev_site # simply force the fetching of the current site
+      end
+
+      def fetch_maglev_page
+        current_maglev_page
+      end
+
+      def fetch_maglev_sections
+        current_maglev_sections
+      end
+
+      def maglev_site
+        @maglev_site ||= services.fetch_site.call
+      end
+
+      def maglev_page_resources
+        ::Maglev::Page
+      end
+
+      def current_maglev_page
+        @current_maglev_page ||= maglev_page_resources.find_by(id: params[:page_id])
+      end
+
+      def maglev_home_page
+        @maglev_home_page ||= maglev_page_resources.home.first
+      end
+
+      def current_maglev_sections
+        @current_maglev_sections ||= Maglev::Content::SectionContent.build_many(
+          theme: maglev_theme,
+          content: services.get_page_sections.call(page: current_maglev_page, locale: content_locale)
+        )
+      end
+
+      def current_maglev_page_urls
+        {
+          path: maglev_services.get_page_fullpath.call(page: current_maglev_page, preview_mode: false,
+                                                       locale: content_locale),
+          preview: maglev_page_preview_url(current_maglev_page),
+          live: maglev_page_live_url(current_maglev_page)
+        }
+      end
+
+      def maglev_page_live_url(page)
+        maglev_services.get_page_fullpath.call(page: page, preview_mode: false, locale: content_locale)
+      end
+
+      def maglev_page_preview_url(page)
+        maglev_services.get_page_fullpath.call(page: page, preview_mode: true, locale: content_locale)
+      end
+
+      def maglev_theme
+        @maglev_theme ||= maglev_services.fetch_theme.call
+      end
+
+      def maglev_editing_route_context(page: nil, locale: nil)
+        {
+          locale: locale || ::Maglev::I18n.current_locale,
+          page_id: page || current_maglev_page
+        }.compact_blank
+      end
+
+      def maglev_disable_turbo_cache
+        @maglev_disable_turbo_cache = true
+      end
+
+      def maglev_disable_turbo_cache?
+        !!@maglev_disable_turbo_cache
+      end
+
+      def ensure_turbo_frame_request
+        return if turbo_frame_request?
+
+        redirect_to editor_root_path
+      end
+
+      def redirect_to_real_root
+        redirect_to editor_real_root_path(maglev_editing_route_context)
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/combobox/collection_items_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    module Combobox
+      class CollectionItemsController < Maglev::Editor::BaseController
+        def index
+          @items = services.fetch_collection_items.call(
+            collection_id: params[:collection_id],
+            keyword: params[:query]
+          )
+          response.set_header('X-Select-Options-Size', @items.size)
+        end
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/combobox/pages_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    module Combobox
+      class PagesController < Maglev::Editor::BaseController
+        def index
+          @pages = services.search_pages.call(
+            q: params[:query],
+            content_locale: content_locale,
+            default_locale: default_content_locale,
+            with_static_pages: true,
+            index_first: true
+          )
+          response.set_header('X-Select-Options-Size', @pages.size)
+        end
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/home_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class HomeController < Maglev::Editor::BaseController
+      include Maglev::BackActionConcern
+
+      before_action :redirect_to_maglev_home_page, only: :index
+
+      def index; end
+
+      def destroy
+        call_back_action
+      end
+
+      private
+
+      def redirect_to_maglev_home_page
+        return if params[:page_id].present?
+
+        redirect_to editor_real_root_path(maglev_editing_route_context(page: maglev_home_page))
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/icons_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class IconsController < Maglev::Editor::BaseController
+      before_action :ensure_turbo_frame_request, only: [:index]
+
+      helper_method :query_params
+
+      layout false
+
+      def index
+        @icons = maglev_theme.icons
+        @icons = @icons.find_all { |icon| icon.include?(params[:query]) } if params[:query].present?
+      end
+
+      private
+
+      def query_params
+        { query: params[:query], source: params[:source] }
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/links_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class LinksController < Maglev::Editor::BaseController
+      before_action :ensure_turbo_frame_request, only: [:edit]
+      before_action :set_link
+      before_action :set_page
+      before_action :set_sections
+
+      layout false
+
+      helper_method :input_id
+
+      def edit; end
+
+      def update
+        # some inputs are displayed based on the value of other inputs
+        return unless params[:refresh] == '1' || !@link.valid?
+
+        flash.now[:alert] = flash_t(:error) unless @link.valid?
+        render :edit, status: :unprocessable_content
+      end
+
+      private
+
+      def set_link
+        @link = Maglev::Content::EditorLink.new(link_params)
+      end
+
+      def set_page
+        @page = maglev_page_resources.find_by(id: @link.link_id) ||
+                services.fetch_static_pages.call.find { |page| page.id == @link.link_id }
+      end
+
+      def set_sections
+        return unless @page
+
+        @sections = services.get_page_section_names.call(page: @page)
+      end
+
+      def link_params
+        params.require(:link).permit(:link_label, :link_type, :link_id, :url_href, :email, :href, :section_id,
+                                     :open_new_window)
+      end
+
+      def input_id
+        params[:input_name].parameterize.underscore
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/page_clone_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class PageCloneController < Maglev::Editor::BaseController
+      def create
+        @source_page = maglev_page_resources.find(params[:page_id])
+        @page = clone_page(@source_page)
+        redirect_to edit_editor_page_path(@page, maglev_editing_route_context(page: @page)), notice: flash_t(:success),
+                                                                                             status: :see_other
+      end
+
+      private
+
+      def clone_page(page)
+        services.clone_page.call(page: page)
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/pages_controller.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class PagesController < Maglev::Editor::BaseController
+      before_action :set_page, only: %i[edit update destroy]
+      before_action :maglev_disable_turbo_cache, only: %i[edit update new create]
+
+      helper_method :query_params
+
+      def index
+        @pages = services.search_pages.call(q: params[:q], content_locale: content_locale,
+                                            default_locale: default_content_locale,
+                                            with_static_pages: false,
+                                            index_first: true)
+      end
+
+      def new
+        @page = maglev_page_resources.build
+      end
+
+      def edit
+        # we need to store the active tab in the flash
+        # because we can't pass the anchor to the redirect
+        @active_tab = flash[:active_tab]
+      end
+
+      def create
+        @page = maglev_services.create_page.call(attributes: page_params)
+        if @page.persisted?
+          redirect_to editor_real_root_path(maglev_editing_route_context(page: @page)), status: :see_other
+        else
+          flash.now[:alert] = flash_t(:error)
+          render :new, status: :unprocessable_content
+        end
+      end
+
+      def update
+        if @page.update(page_params)
+          flash[:active_tab] = params[:active_tab]
+          redirect_to edit_editor_page_path(@page, **query_params, **maglev_editing_route_context),
+                      notice: flash_t(:success), status: :see_other
+        else
+          flash.now[:alert] = flash_t(:error)
+          render :edit, status: :unprocessable_content
+        end
+      end
+
+      def destroy
+        @page.destroy!
+        redirect_to editor_pages_path(**query_params, **maglev_editing_route_context(page: maglev_home_page)),
+                    notice: flash_t(:success), status: :see_other
+      end
+
+      private
+
+      def set_page
+        @page = maglev_page_resources.find(params[:id])
+      end
+
+      def page_params
+        params.require(:page).permit(:title, :path,
+                                     :seo_title, :meta_description,
+                                     :og_title, :og_description, :og_image_url,
+                                     :visible, :lock_version)
+      end
+
+      def query_params(from_list: false)
+        { q: params[:q], from_list: params[:from_list] || from_list }.compact_blank
+      end
+
+      def build_page_resource
+        maglev_page_resources.build(page_params)
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/publication_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class PublicationController < Maglev::Editor::BaseController
+      def create
+        services.publish.call(
+          site: maglev_site,
+          page: current_maglev_page
+        )
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/section_blocks_controller.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class SectionBlocksController < Maglev::Editor::BaseController
+      helper Maglev::Editor::SettingsHelper
+
+      before_action :set_section
+      before_action :set_section_block, only: %i[edit update destroy]
+
+      def index
+        @blocks = @section.blocks
+      end
+
+      def show
+        redirect_to edit_editor_section_block_path(params[:section_id], params[:id], maglev_editing_route_context)
+      end
+
+      def create
+        services.add_section_block.call(
+          page: current_maglev_page,
+          section_id: @section.id,
+          block_type: params[:block_type],
+          parent_id: params[:parent_id],
+          lock_version: params[:lock_version]
+        )
+        redirect_to_section_blocks_path
+      end
+
+      def edit; end
+
+      def update
+        update_section_block
+        refresh_lock_version
+        flash.now[:notice] = flash_t(:success)
+      end
+
+      def sort
+        services.sort_section_blocks.call(
+          page: current_maglev_page,
+          section_id: @section.id,
+          block_ids: params[:item_ids],
+          parent_id: params[:parent_id],
+          lock_version: params[:lock_version]
+        )
+        redirect_to_section_blocks_path
+      end
+
+      def destroy
+        services.delete_section_block.call(
+          page: current_maglev_page,
+          section_id: params[:section_id],
+          block_id: params[:id]
+        )
+        redirect_to_section_blocks_path
+      end
+
+      private
+
+      def set_section
+        @section = current_maglev_sections.find { |section| section.id == params[:section_id] }
+        raise ActiveRecord::StaleObjectError unless @section
+      end
+
+      def set_section_block
+        @section_block = @section.blocks.find(params[:id])
+        raise ActiveRecord::StaleObjectError unless @section_block
+      end
+
+      def update_section_block
+        services.update_section_block.call(
+          page: current_maglev_page,
+          section_id: @section.id,
+          block_id: @section_block.id,
+          content: params[:section_block].to_unsafe_h,
+          lock_version: params[:lock_version]
+        )
+      end
+
+      def refresh_lock_version
+        source = @section.site_scoped? ? maglev_site : current_maglev_page
+        @section_block.lock_version = source.find_section_block_by_id(
+          @section.id,
+          @section_block.id
+        )['lock_version']
+      end
+
+      def redirect_to_section_blocks_path(success: true)
+        flash = case success
+                when true then { notice: flash_t(:success) }
+                when false then { alert: flash_t(:error) }
+                else {}
+                end
+
+        path = editor_section_blocks_path(@section.id, **maglev_editing_route_context)
+
+        redirect_to path, status: :see_other, **flash
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/sections_controller.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class SectionsController < Maglev::Editor::BaseController
+      helper Maglev::Editor::SettingsHelper
+
+      before_action :set_section, only: %i[edit update]
+
+      def show
+        redirect_to edit_editor_section_path(params[:id], maglev_editing_route_context)
+      end
+
+      def new
+        @grouped_sections = maglev_theme.sections.available_for(current_maglev_sections).grouped_by_category
+        @position = (params[:position] || -1).to_i
+      end
+
+      def create
+        @section = services.add_section.call(
+          page: current_maglev_page,
+          section_type: params[:section_type],
+          position: params[:position].to_i
+        )
+        redirect_to edit_editor_section_path(@section[:id], maglev_editing_route_context),
+                    flash: newly_added_section_to_flash,
+                    notice: flash_t(:success),
+                    status: :see_other
+      end
+
+      def edit
+        newly_added_section_to_headers
+      end
+
+      def update
+        update_section
+        refresh_lock_version
+        flash.now[:notice] = flash_t(:success)
+      end
+
+      def sort
+        current_maglev_page.reorder_sections(params[:item_ids], params[:lock_version])
+        if current_maglev_page.save
+          redirect_to_sections_path
+        else
+          render_index_with_error
+        end
+      end
+
+      def destroy
+        services.delete_section.call(page: current_maglev_page, section_id: params[:id])
+        redirect_to_sections_path
+      end
+
+      private
+
+      def set_section
+        @section = current_maglev_sections.find { |section| section.id == params[:id] }
+        raise ActiveRecord::StaleObjectError unless @section
+      end
+
+      def update_section
+        services.update_section.call(
+          page: current_maglev_page,
+          section_id: @section.id,
+          content: params[:section].to_unsafe_h,
+          lock_version: params[:lock_version]
+        )
+      end
+
+      def render_index_with_error
+        flash.now[:alert] = flash_t(:error)
+        render 'index', status: :unprocessable_content
+      end
+
+      def newly_added_section_to_flash
+        # use flash because we can't pass directly the information to the redirect
+        { section_id: @section[:id], position: current_maglev_page.position_of_section(@section[:id]) }
+      end
+
+      def newly_added_section_to_headers
+        headers['X-Section-Id'] = flash[:section_id]
+        headers['X-Section-Position'] = flash[:position]
+      end
+
+      def refresh_lock_version
+        source = @section.site_scoped? ? maglev_site : current_maglev_page
+        @section.lock_version = source.find_section_by_id(@section.id)['lock_version']
+      end
+
+      def redirect_to_sections_path
+        redirect_to editor_sections_path(maglev_editing_route_context), notice: flash_t(:success), status: :see_other
+      end
+    end
+  end
+end

data/app/controllers/maglev/editor/style_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Editor
+    class StyleController < Maglev::Editor::BaseController
+      helper Maglev::Editor::SettingsHelper
+
+      before_action :set_style
+
+      def edit; end
+
+      def update
+        maglev_services.persist_style.call(new_style: style_params, lock_version: params[:lock_version])
+
+        redirect_to edit_editor_style_path(maglev_editing_route_context),
+                    notice: flash_t(:success),
+                    status: :see_other
+      end
+
+      private
+
+      def set_style
+        @style = maglev_services.fetch_style.call
+      end
+
+      def style_params
+        params.require(:style).permit!
+      end
+    end
+  end
+end

data/app/controllers/maglev/page_preview_controller.rb

@@ -32,17 +32,13 @@ module Maglev
     def fetch_maglev_page_sections
       return super if action_name == 'index'
 
-      super(JSON.parse(params[:page_sections]))
+      super(section_id: params[:section_id])
     end
 
     def maglev_rendering_mode
       params[:rendering_mode] || super
     end
 
-    def use_engine_vite?
-      false
-    end
-
     def extract_content_locale(&block)
       _, locale = maglev_services.extract_locale.call(params: params, locales: maglev_site.locale_prefixes)
       ::I18n.with_locale(locale, &block)

data/app/controllers/maglev/published_page_preview_controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Maglev
+  class PublishedPagePreviewController < ApplicationController
+    include Maglev::RenderingConcern
+    include Maglev::ContentLocaleConcern
+
+    before_action :fetch_maglev_site
+    around_action :extract_content_locale
+
+    rescue_from Maglev::Errors::UnpublishedPage, with: :content_not_found!
+
+    helper Maglev::PagePreviewHelper
+
+    def index
+      render_maglev_page
+    end
+
+    private
+
+    def fetch_maglev_site
+      super.tap do |site|
+        raise ActiveRecord::RecordNotFound if site.nil?
+
+        maglev_services.context.site = site
+      end
+    end
+
+    def fetch_maglev_page_sections
+      maglev_services.get_published_page_sections.call(page: fetch_maglev_page, locale: content_locale)
+    end
+
+    def maglev_rendering_mode
+      :live
+    end
+
+    def extract_content_locale(&block)
+      _, locale = maglev_services.extract_locale.call(params: params, locales: maglev_site.locale_prefixes)
+      ::I18n.with_locale(locale, &block)
+    end
+
+    def fallback_to_default_locale
+      false
+    end
+
+    def content_not_found!
+      raise ActionController::RoutingError, 'Not Found'
+    end
+  end
+end

data/app/controllers/maglev/sitemap_controller.rb

@@ -21,7 +21,7 @@ module Maglev
     end
 
     def fetch_pages
-      Maglev::Page.all.visible
+      Maglev::Page.all.visible.order(created: :asc)
     end
 
     def verify_request_format!