camaleon_cms 2.9.2 → 2.9.4

data/app/controllers/camaleon_cms/camaleon_controller.rb

@@ -5,21 +5,24 @@ module CamaleonCms
     add_flash_types :notice
     add_flash_types :info
 
+    # Controller-context helper surface (ct, cama_t, cama_cache_fetch, ...): plugin hook
+    # functions run on the controller and actions like FrontendController#search call these.
     include CamaleonCms::CamaleonHelper
-    include CamaleonCms::SessionHelper
-    include CamaleonCms::SiteHelper
-    include CamaleonCms::HtmlHelper
-    include CamaleonCms::UserRolesHelper
-    include CamaleonCms::ShortCodeHelper
-    include CamaleonCms::PluginsHelper
-    include CamaleonCms::ThemeHelper
-    include CamaleonCms::HooksHelper
-    include CamaleonCms::ContentHelper
-    include CamaleonCms::CaptchaHelper
-    include CamaleonCms::UploaderHelper
-    include CamaleonCms::EmailHelper
+    include CamaleonCms::SessionRuntimeConcern
+    include CamaleonCms::RequestContextConcern
+    include CamaleonCms::HookLifecycleConcern
+    include CamaleonCms::RuntimeShortcodeThemeConcern
+    include CamaleonCms::RuntimeHtmlContentConcern
+    include CamaleonCms::RuntimeAdminMenuConcern
+    include CamaleonCms::RuntimeCaptchaImageConcern
+    include CamaleonCms::RuntimeUploaderConcern
     include Mobu::DetectMobile
+    delegate :tag, :content_tag, :safe_join, :image_tag, :link_to, :sanitize, to: :helpers
 
+    # Preserve backwards-compatible plugin helper inclusion: any helper module a
+    # plugin declares in its config.json is mixed in here so plugins can call
+    # those methods from controllers (not only from views). Documented in
+    # `docs/ai/plans/helper-concern-architecture-refactor.md`.
     PluginRoutes.all_helpers.each { |h| include h.constantize }
 
     before_action :cama_site_check_existence, except: [:captcha]
@@ -35,13 +38,24 @@ module CamaleonCms
 
     # show page error
     def render_error(status = 404, exception = nil, message = '')
-      Rails.logger.debug "Camaleon CMS - 404 url: #{begin
-        request.original_url
-      rescue StandardError
-        nil
-      end} ==> message: #{exception.message if exception.present?} ==> #{params[:error_msg]} ==> #{caller.inspect}"
-      @message = "#{message} #{params[:error_msg] || (exception.present? ? "#{exception.message}<br><br>#{caller.inspect}" : '')}"
-      @message = '' if Rails.env == 'production'
+      error_msg = params[:error_msg]
+      Rails.logger.debug do
+        original_url = begin
+          request.original_url
+        rescue StandardError
+          nil
+        end
+        'Camaleon CMS - 404 url: ' \
+          "#{original_url} ==> message: #{exception&.message} ==> #{error_msg} ==> #{caller.inspect}"
+      end
+
+      @message = if Rails.env.production?
+                   ''
+                 else
+                   "#{message} " \
+                     "#{error_msg || (exception.present? ? "#{exception.message}<br><br>#{caller.inspect}" : '')}"
+                 end
+
       respond_to do |format|
         format.html { render "camaleon_cms/#{status}", status: status }
         format.any { head status }
@@ -69,18 +83,9 @@ module CamaleonCms
       # initializing before and after contents
       cama_content_init
 
-      @_hooks_skip = []
-      # trigger all hooks before_load_app
-      hooks_run('app_before_load')
-
-      request.env.except!('HTTP_X_FORWARDED_HOST') if request.env['HTTP_X_FORWARDED_HOST'] # just drop the variable
-
-      views_dir = 'app/apps/'
-      prepend_view_path(File.join($camaleon_engine_dir, views_dir).to_s)
-      prepend_view_path(Rails.root.join(views_dir).to_s)
-
-      CamaleonCms::PostDefault.current_user = cama_current_user
-      CamaleonCms::PostDefault.current_site = current_site
+      initialize_hook_skip_list
+      run_app_before_load_hooks
+      configure_runtime_request_context
     end
 
     # initialize ability for current user
@@ -89,67 +94,7 @@ module CamaleonCms
     end
 
     def cama_after_actions
-      # trigger all actions app after load
-      hooks_run('app_after_load')
-    end
-
-    # redirect to sessions login form when the session was expired.
-    def auth_session_error
-      redirect_to cama_root_path
-    end
-
-    # check if current site exist, if not, this will be redirected to main domain
-    # Also, check current site status
-    def cama_site_check_existence
-      if !current_site.present?
-        if Cama::Site.main_site.present?
-          url = Cama::Site.main_site.decorate.the_url
-          # TODO: Remove this condition when Rails 6.x won't be supported
-          if Rails.gem_version >= Gem::Version.new('7.0.0')
-            redirect_to url, allow_other_host: true
-          else
-            redirect_to url
-          end
-        else
-          redirect_to cama_admin_installers_path
-        end
-      elsif (cama_current_user.present? && !cama_current_user.admin?) || !cama_current_user.present?
-        # inactive page control
-        if current_site.is_inactive?
-          if request.original_url.to_s.match(%r{\A#{current_site.the_url}admin(/|\z)})
-            if cama_current_user.present?
-              cama_logout_user
-              flash[:error] = 'Site is Inactive'
-            end
-          else
-            p = current_site.posts.find_by_id(current_site.get_option('page_inactive')).try(:decorate)
-            if p
-              redirect_to(p.the_url) unless params == { 'controller' => 'camaleon_cms/frontend', 'action' => 'post',
-                                                        'slug' => p.the_slug }
-            else
-              render html: 'This site was inactivated. Please contact to administrator.'
-            end
-          end
-        end
-
-        # maintenance page and IP's control
-        if current_site.is_maintenance? && !current_site.get_option('maintenance_ips',
-                                                                    '').split(',').include?(request.remote_ip)
-          p = current_site.posts.find_by_id(current_site.get_option('page_maintenance')).try(:decorate)
-          if p
-            redirect_to(p.the_url) if params != { 'controller' => 'camaleon_cms/frontend', 'action' => 'post',
-                                                  'slug' => p.the_slug }
-          else
-            render html: 'This site is in maintenance mode. Please contact to administrator.'
-          end
-        end
-      end
-    end
-
-    unless ApplicationController.method_defined?(:current_user)
-      def current_user
-        cama_current_user
-      end
+      run_app_after_load_hooks
     end
   end
 end

data/app/controllers/camaleon_cms/frontend_controller.rb

@@ -1,22 +1,22 @@
 module CamaleonCms
   class FrontendController < CamaleonCms::CamaleonController
     before_action :init_frontent
+    include CamaleonCms::FrontendVisitedStateConcern
     include CamaleonCms::FrontendConcern
     include CamaleonCms::Frontend::ApplicationHelper
     layout proc { |controller|
-             args = {
-               layout: (params[:cama_ajax_request].present? ? 'cama_ajax' : PluginRoutes.static_system_info['default_layout']), controller: controller
-             }
-             hooks_run('front_default_layout', args)
-             args[:layout]
-           }
+      args = {
+        layout: (params[:cama_ajax_request].present? ? 'cama_ajax' : PluginRoutes.static_system_info['default_layout']),
+        controller: controller
+      }
+      hooks_run('front_default_layout', args)
+      args[:layout]
+    }
     before_action :before_hooks
     after_action :after_hooks
-    # rescue_from ActiveRecord::RecordNotFound, with: :page_not_found
-
     # home page for frontend
     def index
-      @cama_visited_home = true
+      mark_frontend_home_visited
       if @_site_options[:home_page].present?
         render_post(@_site_options[:home_page].to_i)
       else
@@ -29,28 +29,38 @@ module CamaleonCms
     # render category list
     def category
       begin
-        @category ||= current_site.the_full_categories.find_by_slug(params[:category_slug]).decorate if params[:category_slug].present?
+        if params[:category_slug].present?
+          @category ||= current_site.the_full_categories.find_by_slug(params[:category_slug]).decorate # rubocop:disable Rails/DynamicFindBy
+        end
         @category ||= current_site.the_full_categories.find(params[:category_id]).decorate
         @post_type = @category.the_post_type
       rescue StandardError
         return page_not_found
       end
-      @cama_visited_category = @category
+      mark_frontend_category_visited(@category)
       @children = @category.children.no_empty.decorate
       @posts = @category.the_posts.paginate(page: params[:page],
-                                            per_page: current_site.front_per_page).eager_load(:metas)
-      r_file = lookup_context.template_exists?("category_#{@category.the_slug}") ? "category_#{@category.the_slug}" : nil # specific template category with specific slug within a posttype
-      unless r_file.present?
-        r_file = lookup_context.template_exists?("post_types/#{@post_type.the_slug}/category") ? "post_types/#{@post_type.the_slug}/category" : nil
+                                            per_page: current_site.front_per_page)
+      category_slug = @category.the_slug
+
+      # specific template category with specific slug within a post-type
+      r_file = lookup_context.template_exists?("category_#{category_slug}") ? "category_#{category_slug}" : nil
+      post_type_slug = "post_types/#{@post_type.the_slug}"
+      if r_file.blank?
+        r_file = lookup_context.template_exists?("#{post_type_slug}/category") ? "#{post_type_slug}/category" : nil
       end
-      unless r_file.present?
-        r_file = lookup_context.template_exists?("categories/#{@category.the_slug}") ? "categories/#{@category.the_slug}" : 'category'
+      if r_file.blank?
+        r_file = if lookup_context.template_exists?("categories/#{category_slug}")
+                   "categories/#{category_slug}"
+                 else
+                   'category'
+                 end
       end
 
-      layout_ = if lookup_context.template_exists?("layouts/post_types/#{@post_type.the_slug}/category")
-                  "post_types/#{@post_type.the_slug}/category"
-                elsif lookup_context.template_exists?("layouts/categories/#{@category.the_slug}")
-                  "categories/#{@category.the_slug}"
+      layout_ = if lookup_context.template_exists?("layouts/#{post_type_slug}/category")
+                  "#{post_type_slug}/category"
+                elsif lookup_context.template_exists?("layouts/categories/#{category_slug}")
+                  "categories/#{category_slug}"
                 end
       r = { category: @category, layout: layout_, render: r_file }
       hooks_run('on_render_category', r)
@@ -60,18 +70,20 @@ module CamaleonCms
     # render contents from post type
     def post_type
       begin
-        @post_type = current_site.post_types.find_by_slug(params[:post_type_slug]).decorate
+        @post_type = current_site.post_types.find_by_slug(params[:post_type_slug]).decorate # rubocop:disable Rails/DynamicFindBy
       rescue StandardError
         return page_not_found
       end
       @object = @post_type
-      @cama_visited_post_type = @post_type
+      CurrentRequest.frontend_object = @object
+      mark_frontend_post_type_visited(@post_type)
       @posts = @post_type.the_posts.paginate(page: params[:page],
-                                             per_page: current_site.front_per_page).eager_load(:metas)
+                                             per_page: current_site.front_per_page)
       @categories = @post_type.categories.no_empty.eager_load(:metas).decorate
       @post_tags = @post_type.post_tags.eager_load(:metas)
-      r_file = lookup_context.template_exists?("post_types/#{@post_type.the_slug}") ? "post_types/#{@post_type.the_slug}" : 'post_type'
-      layout_ = lookup_context.template_exists?("layouts/post_types/#{@post_type.the_slug}") ? "post_types/#{@post_type.the_slug}" : nil
+      post_type_slug = "post_types/#{@post_type.the_slug}"
+      r_file = lookup_context.template_exists?(post_type_slug) ? post_type_slug : 'post_type'
+      layout_ = lookup_context.template_exists?("layouts/#{post_type_slug}") ? post_type_slug : nil
       r = { post_type: @post_type, layout: layout_, render: r_file }
       hooks_run('on_render_post_type', r)
       render r[:render], (!r[:layout].nil? ? { layout: r[:layout] } : {})
@@ -81,7 +93,7 @@ module CamaleonCms
     def post_tag
       begin
         @post_tag = if params[:post_tag_slug].present?
-                      current_site.post_tags.find_by_slug(params[:post_tag_slug]).decorate
+                      current_site.post_tags.find_by_slug(params[:post_tag_slug]).decorate # rubocop:disable Rails/DynamicFindBy
                     else
                       current_site.post_tags.find(params[:post_tag_id]).decorate
                     end
@@ -90,10 +102,12 @@ module CamaleonCms
         return page_not_found
       end
       @object = @post_tag
-      @cama_visited_tag = @post_tag
+      CurrentRequest.frontend_object = @object
+      mark_frontend_tag_visited(@post_tag)
       @posts = @post_tag.the_posts.paginate(page: params[:page],
-                                            per_page: current_site.front_per_page).eager_load(:metas)
-      r_file = lookup_context.template_exists?("post_types/#{@post_type.the_slug}/post_tag") ? "post_types/#{@post_type.the_slug}/post_tag" : 'post_tag'
+                                            per_page: current_site.front_per_page)
+      slug_post_tag = "post_types/#{@post_type.the_slug}/post_tag"
+      r_file = lookup_context.template_exists?(slug_post_tag) ? slug_post_tag : 'post_tag'
       layout_ = lookup_context.template_exists?('layouts/post_tag') ? 'post_tag' : nil
       r = { post_tag: @post_tag, layout: layout_, render: r_file }
       hooks_run('on_render_post_tag', r)
@@ -103,19 +117,17 @@ module CamaleonCms
     # search contents
     def search
       breadcrumb_add(ct('search'))
-      items = params[:post_type_slugs].present? ? current_site.the_posts(params[:post_type_slugs].split(',')) : current_site.the_posts
-      @cama_visited_search = true
+      post_type_slugs = params[:post_type_slugs]
+      items = post_type_slugs.present? ? current_site.the_posts(post_type_slugs.split(',')) : current_site.the_posts
+      mark_frontend_search_visited
       @param_search = params[:q]
       layout_ = lookup_context.template_exists?('layouts/search') ? 'search' : nil
       r = { layout: layout_, render: 'search', posts: nil }
       hooks_run('on_render_search', r)
-      params[:q] = (params[:q] || '').downcase
-      @posts = if !r[:posts].nil?
-                 r[:posts]
-               else
-                 items.where('LOWER(title) LIKE ? OR LOWER(content_filtered) LIKE ?',
-                             "%#{params[:q]}%", "%#{params[:q]}%")
-               end
+      q_params = params[:q].to_s.downcase
+      params[:q] = q_params
+      @posts = r[:posts] ||
+               items.where('LOWER(title) LIKE ? OR LOWER(content_filtered) LIKE ?', "%#{q_params}%", "%#{q_params}%")
       @posts_size = @posts.size
       @posts = @posts.paginate(page: params[:page], per_page: current_site.front_per_page)
       render r[:render], (!r[:layout].nil? ? { layout: r[:layout] } : {})
@@ -124,7 +136,7 @@ module CamaleonCms
     # ajax requests
     def ajax
       r = { render_file: nil, render_text: '', layout: nil }
-      @cama_visited_ajax = true
+      mark_frontend_ajax_visited
       hooks_run('on_ajax', r)
       if r[:render_file]
         render r[:render_file], (!r[:layout].nil? ? { layout: r[:layout] } : {})
@@ -150,7 +162,8 @@ module CamaleonCms
         return page_not_found
       end
       @object = @user
-      @cama_visited_profile = true
+      CurrentRequest.frontend_object = @object
+      mark_frontend_profile_visited(@user)
       layout_ = lookup_context.template_exists?('layouts/profile') ? 'profile' : nil
       r = { user: @user, layout: layout_, render: 'profile' }
       hooks_run('on_render_profile', r)
@@ -168,6 +181,7 @@ module CamaleonCms
     def draft_render
       post_draft = current_site.posts.drafts.find(params[:draft_id])
       @object = post_draft
+      CurrentRequest.frontend_object = @object
 
       # let a hook override the ability for certain roles see drafts
       args = { permitted: false }
@@ -184,25 +198,30 @@ module CamaleonCms
     # post_or_slug_or_id: slug_post | id post | post object
     # from_url: true/false => true (true, permit eval hooks "on_render_post")
     def render_post(post_or_slug_or_id, from_url = false, status = nil, force_visit = false)
+      # eager: false -- rendering one post must not pay the listing preloads (with_eager)
+      visible_posts = verify_front_visibility(current_site.posts, eager: false)
       @post = case post_or_slug_or_id
               when String # slug
-                current_site.the_posts.find_by_slug(post_or_slug_or_id)
+                # find_by_slug is multi-language aware (matches localized slugs like
+                # "<!--:en-->sample-post<!--:-->..."), unlike find_by(slug:)
+                visible_posts.find_by_slug(post_or_slug_or_id) # rubocop:disable Rails/DynamicFindBy
               when Integer # id
-                current_site.the_posts.where(id: post_or_slug_or_id).first
+                visible_posts.where(id: post_or_slug_or_id).first
               else # model
                 post_or_slug_or_id
               end
 
       @post = @post.try(:decorate)
-      if !@post.present? || !(force_visit || @post.can_visit?)
-        if params[:format] == 'html' || !params[:format].present?
+      if @post.blank? || !(force_visit || @post.can_visit?)
+        if params[:format] == 'html' || params[:format].blank?
           page_not_found
         else
-          head 404
+          head :not_found
         end
       else
         @object = @post
-        @cama_visited_post = @post
+        CurrentRequest.frontend_object = @object
+        mark_frontend_post_visited(@post)
         @post_type = @post.the_post_type
         @comments = @post.the_comments
         @categories = @post.the_categories
@@ -213,10 +232,11 @@ module CamaleonCms
         rescue StandardError
           nil
         end
+        post_template = @post.get_template(@post_type)
         r_file = if lookup_context.template_exists?("page_#{@post.id}")
                    "page_#{@post.id}"
-                 elsif @post.get_template(@post_type).present? && lookup_context.template_exists?(@post.get_template(@post_type))
-                   @post.get_template(@post_type)
+                 elsif post_template.present? && lookup_context.template_exists?(post_template)
+                   post_template
                  elsif home_page.present? && @post.id.to_s == home_page
                    'index'
                  elsif lookup_context.template_exists?("post_types/#{@post_type.the_slug}/single")
@@ -261,17 +281,54 @@ module CamaleonCms
     # if url hasn't a locale, then it will use default locale set on application.rb
     def init_frontent
       # preview theme initializing
-      @_current_theme = current_site.themes.where(slug: params[:ccc_theme_preview]).first_or_create!.decorate if cama_sign_in? && params[:ccc_theme_preview].present? && can?(
-        :manage, :themes
-      )
+      previewing_theme = cama_sign_in? && params[:ccc_theme_preview].present? && can?(:manage, :themes)
+      if previewing_theme
+        preview_theme = current_site.themes.where(slug: params[:ccc_theme_preview]).first_or_create!.decorate
+        @_current_theme = preview_theme
+        CurrentRequest.frontend_current_theme = preview_theme
+        ensure_preview_site_defaults
+      end
 
       @_site_options = current_site.options
-      session[:cama_current_language] = params[:cama_set_language].to_sym if params[:cama_set_language].present?
+      # Only a scalar language param participates in locale resolution — a non-scalar
+      # (?locale[]= / ?cama_set_language[]=) would crash to_sym and 500 the request
+      set_language = params[:cama_set_language]
+      session[:cama_current_language] = set_language.to_sym if set_language.is_a?(String) && set_language.present?
       session[:cama_current_language] = nil if current_site.get_languages.exclude?(session[:cama_current_language])
-      I18n.locale = params[:locale] || session[:cama_current_language] || current_site.get_languages.first
-      return page_not_found unless current_site.get_languages.include?(I18n.locale.to_sym)
+      requested_locale = params[:locale] if params[:locale].is_a?(String)
+      I18n.locale = requested_locale || session[:cama_current_language] || current_site.get_languages.first
+      # The availability gate renders the site's 404 (directly or via a custom error_404
+      # post), so the theme lookup prefixes must already be registered when it fires
+      configure_frontend_lookup_prefixes
+      theme_init
+      return if current_site.get_languages.include?(I18n.locale.to_sym)
+
+      # The unoffered locale must not style the 404 page or leak into its links
+      I18n.locale = current_site.get_languages.first
+      page_not_found
+    end
+
+    # initialize hooks before to execute action
+    def before_hooks
+      hooks_run('front_before_load')
+    end
+
+    # initialize hooks after executed action
+    def after_hooks
+      hooks_run('front_after_load')
+    end
+
+    # define default options for url helpers
+    # control for default locale
+    def default_url_options(options = {})
+      return options if current_site.get_languages.first.to_s == I18n.locale.to_s
 
-      # define render paths
+      { locale: I18n.locale }.merge!(options)
+    rescue StandardError
+      options
+    end
+
+    def configure_frontend_lookup_prefixes
       lookup_context.prefixes.delete('frontend')
       lookup_context.prefixes.delete('application')
       lookup_context.prefixes.delete('camaleon_cms/frontend')
@@ -282,36 +339,51 @@ module CamaleonCms
         t =~ %r{themes/(.*)/views}i || t == 'camaleon_cms/default_theme' || t == "themes/#{current_site.id}/views"
       end
 
-      lookup_context.prefixes.append("themes/#{current_site.id}/views") if Dir.exist?(Rails.root.join('app', 'apps',
-                                                                                                      'themes', current_site.id.to_s).to_s)
+      # Per-site theme override: views placed under app/apps/themes/<site_id>/views
+      # take precedence over the active theme's views (it is appended first).
+      if Dir.exist?(Rails.root.join('app', 'apps', 'themes', current_site.id.to_s).to_s)
+        lookup_context.prefixes.append("themes/#{current_site.id}/views")
+      end
       lookup_context.prefixes.append("themes/#{current_theme.slug}/views")
       lookup_context.prefixes.append('camaleon_cms/default_theme')
 
       lookup_context.prefixes = lookup_context.prefixes.uniq
       lookup_context.use_camaleon_partial_prefixes = true
-      theme_init
     end
 
-    # initialize hooks before to execute action
-    def before_hooks
-      hooks_run('front_before_load')
+    def ensure_preview_site_defaults
+      preview_required_menu_slugs.each do |slug|
+        current_site.nav_menus.where(slug: slug).first_or_create! do |menu|
+          menu.name = slug.to_s.humanize
+        end
+      end
     end
 
-    # initialize hooks after executed action
-    def after_hooks
-      hooks_run('front_after_load')
+    def preview_required_menu_slugs
+      slugs = ['main_menu']
+      slugs.concat(extract_theme_menu_slugs(current_theme.settings['path']))
+      slugs.uniq
     end
 
-    # define default options for url helpers
-    # control for default locale
-    def default_url_options(options = {})
-      if current_site.get_languages.first.to_s == I18n.locale.to_s
-        options
-      else
-        { locale: I18n.locale }.merge options
+    def extract_theme_menu_slugs(theme_path)
+      return [] if theme_path.blank?
+
+      views_path = File.join(theme_path, 'views')
+      return [] unless Dir.exist?(views_path)
+
+      Dir.glob(File.join(views_path, '**', '*.erb')).flat_map do |file_path|
+        extract_menu_slugs_from_template(File.read(file_path))
+      end.uniq
+    end
+
+    def extract_menu_slugs_from_template(content)
+      slugs = []
+      slugs.concat(content.scan(/nav_menus\.where\(\s*slug:\s*'([^']+)'\s*\)/).flatten)
+      slugs.concat(content.scan(/nav_menus\.where\(\s*slug:\s*"([^"]+)"\s*\)/).flatten)
+      content.scan(/nav_menus\.where\(\s*slug:\s*\[([^\]]+)\]\s*\)/).flatten.each do |array_content|
+        slugs.concat(array_content.scan(/['"]([^'"]+)['"]/).flatten)
       end
-    rescue StandardError
-      options
+      slugs
     end
   end
 end

data/app/controllers/concerns/camaleon_cms/admin/custom_fields_concern.rb

@@ -5,19 +5,34 @@ module CamaleonCms
 
       private
 
-      # Only permit field_options that match registered custom field slugs
-      def cama_permitted_field_options(object_class)
-        return {} unless params[:field_options].present?
+      # Only permit field values whose slug is registered under object_class. param_key selects
+      # which request param carries the payload, so sibling params (the theme form's
+      # theme_fields) get the same allowed-slugs permit as the default field_options.
+      def cama_permitted_field_options(object_class, param_key: :field_options)
+        field_options = params[param_key]
+        # A non-hash payload (a scalar `field_options=foo`, or an array) carries no groups to permit,
+        # so treat it as empty instead of calling #keys/#permit on it. Guarding here rather than
+        # `params.require` avoids a NoMethodError -> 500 an authenticated caller could trigger with a
+        # malformed param (the same crash every set_field_values caller shared).
+        return {} unless field_options.is_a?(ActionController::Parameters)
 
         allowed_keys = cama_custom_field_allowed_slugs(object_class)
         return {} if allowed_keys.blank?
 
-        field_options = params.require(:field_options)
-        field_options.permit(field_options.keys.select { |k| k.to_s =~ /\A\d+\z/ }.index_with do
+        permitted = field_options.permit(field_options.keys.select { |k| k.to_s =~ /\A\d+\z/ }.index_with do
           allowed_keys.index_with { [:id, :group_number, { values: {} }] }
         end).to_h
+        # Drop groups left empty after filtering. set_field_values deletes every existing value
+        # before writing, so handing it a non-blank-but-empty payload (a group whose submitted
+        # slugs were all unregistered) would wipe the object's stored values and write nothing.
+        permitted.reject { |_group, fields| fields.blank? }
       end
 
+      # The allow-list covers fields registered directly under object_class. For a post
+      # ('PostType_Post') this intentionally spans only the post type's own groups -- not per-post
+      # ('Post') or category-inherited ('Category_Post') groups the edit form also renders. It
+      # matches PostsController#save_post_with_fields, so the main post save and drafts confine field
+      # writes identically; values for those sibling scopes are deliberately not written this way.
       def cama_custom_field_allowed_slugs(object_class)
         CamaleonCms::CustomField.where(
           parent_id: CamaleonCms::CustomField.where(object_class: object_class).select(:id),