decidim-decidim_awesome 0.6.5 → 0.7.2

data/app/helpers/decidim/decidim_awesome/admin/config_constraints_helpers.rb

@@ -4,6 +4,8 @@ module Decidim
   module DecidimAwesome
     module Admin
       module ConfigConstraintsHelpers
+        OTHER_MANIFESTS = [:none, :system, :process_groups].freeze
+
         include Decidim::TranslatableAttributes
 
         def check(status)
@@ -28,7 +30,7 @@ module Decidim
         end
 
         def participatory_space_manifests
-          manifests = { system: I18n.t("decidim.decidim_awesome.admin.config.system") }
+          manifests = OTHER_MANIFESTS.map { |m| [m, I18n.t("decidim.decidim_awesome.admin.config.#{m}")] }.to_h
           Decidim.participatory_space_manifests.pluck(:name).each do |name|
             manifests[name.to_sym] = I18n.t("decidim.admin.menu.#{name}")
           end
@@ -36,7 +38,7 @@ module Decidim
         end
 
         def component_manifests(space = nil)
-          return {} if space == "system"
+          return {} if OTHER_MANIFESTS.include?(space)
 
           Decidim.component_manifests.pluck(:name).map do |name|
             [name.to_sym, I18n.t("decidim.components.#{name}.name")]
@@ -44,17 +46,17 @@ module Decidim
         end
 
         def participatory_spaces_list(manifest)
-          space = participatory_space_for_manifest(manifest)
+          space = model_for_manifest(manifest)
           return {} if space.blank?
 
           space.where(organization: current_organization).map do |item|
-            [item.slug, translated_attribute(item.title)]
+            [item.try(:slug) || item.id.to_s, translated_attribute(item.title)]
           end.to_h
         end
 
         def components_list(manifest, slug)
-          space = participatory_space_for_manifest(manifest)
-          return {} if space.blank?
+          space = model_for_manifest(manifest)
+          return {} unless space&.column_names&.include? "slug"
 
           components = Component.where(participatory_space: space.find_by(slug: slug))
           components.map do |item|
@@ -84,9 +86,11 @@ module Decidim
 
         private
 
-        def participatory_space_for_manifest(manifest)
+        def model_for_manifest(manifest)
           return nil if manifest.blank?
 
+          return Decidim::ParticipatoryProcessGroup if manifest == "process_groups"
+
           space = Decidim.find_participatory_space_manifest(manifest)
           return nil unless space
 

data/app/helpers/decidim/decidim_awesome/amendments_helper_override.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module AmendmentsHelperOverride
+      extend ActiveSupport::Concern
+
+      included do
+        # original method
+        alias_method :decidim_amendments_form_field_for, :amendments_form_field_for
+
+        # override with custom fields if scope applies
+        def amendments_form_field_for(attribute, form, original_resource)
+          custom_fields = awesome_custom_fields(attribute, form)
+          return decidim_amendments_form_field_for(attribute, form, original_resource) if custom_fields.blank?
+
+          render_amendment_custom_fields_override(custom_fields, attribute, form, original_resource)
+        end
+
+        private
+
+        def render_amendment_custom_fields_override(fields, attribute, form, original_resource)
+          custom_fields = Decidim::DecidimAwesome::CustomFields.new(fields)
+          custom_fields.translate!
+          body = amendments_form_fields_value(original_resource, attribute)
+          custom_fields.apply_xml(body) if body.present?
+          # TODO: find a way to add errors as form is not the parent form
+          # form.object.errors.add(attribute, custom_fields.errors) if custom_fields.errors
+          render partial: "decidim/decidim_awesome/custom_fields/form_render", locals: { spec: custom_fields.to_json, form: form, name: attribute }
+        end
+
+        # Amendments don't use a URL specifying participatory space and component
+        # context for awesome config constraints must be obtained from the resource
+        def awesome_custom_fields(attribute, _form)
+          return unless attribute == :body
+
+          component = amendable.try(:component)
+          return unless component
+          return if component.settings.participatory_texts_enabled?
+
+          awesome_config = Decidim::DecidimAwesome::Config.new(component.organization)
+          awesome_config.context_from_component(component)
+          awesome_config.collect_sub_configs_values("proposal_custom_field")
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/decidim_awesome/map_helper.rb

@@ -5,13 +5,19 @@ module Decidim
     module MapHelper
       include Decidim::MapHelper
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity:
       def awesome_map_for(components, &block)
-        return legacy_map_for(components, &block) unless defined?(Decidim::Map)
+        return unless map_utility_dynamic
 
-        map = dynamic_map_for({}, {}, &block)
-        return unless map
+        map = awesome_builder.map_element({ class: "google-map" }, &block)
+        help = content_tag(:div, class: "map__help") do
+          sr_content = content_tag(:p, t("screen_reader_explanation", scope: "decidim.map.dynamic"), class: "show-for-sr")
+
+          sr_content
+        end
 
-        map_html_options = {
+        html_options = {
           "class" => "awesome-map",
           "id" => "awesome-map",
           "data-components" => components.map do |component|
@@ -23,58 +29,40 @@ module Decidim
                                    amendments: component.manifest.name == :proposals ? Decidim::Proposals::Proposal.where(component: component).only_emendations.count : 0
                                  }
                                end.to_json,
-          "data-collapsed" => current_component.settings.collapse,
-          "data-show-not-answered" => current_component.current_settings.show_not_answered,
-          "data-show-accepted" => current_component.current_settings.show_accepted,
-          "data-show-withdrawn" => current_component.current_settings.show_withdrawn,
-          "data-show-evaluating" => current_component.current_settings.show_evaluating
-          # "data-show-rejected" => current_component.current_settings.show_rejected
-        }
-        content_tag(:div, map, map_html_options)
-      end
-
-      # TODO: remove when 0.22 support is diched
-      def legacy_map_for(components)
-        return if Decidim.geocoder.blank?
-
-        map_html_options = {
-          class: "google-map",
-          id: "map",
-          "data-components" => components.map do |component|
-                                 {
-                                   id: component.id,
-                                   type: component.manifest.name,
-                                   name: translated_attribute(component.name),
-                                   url: Decidim::EngineRouter.main_proxy(component).root_path,
-                                   amendments: component.manifest.name == :proposals ? Decidim::Proposals::Proposal.where(component: component).only_emendations.count : 0
-                                 }
-                               end.to_json,
-          "data-collapsed" => current_component.settings.collapse,
-          "data-show-not-answered" => current_component.current_settings.show_not_answered,
-          "data-show-accepted" => current_component.current_settings.show_accepted,
-          "data-show-withdrawn" => current_component.current_settings.show_withdrawn,
-          "data-show-evaluating" => current_component.current_settings.show_evaluating,
-          # "data-show-rejected" => current_component.current_settings.show_rejected,
-          "data-markers-data" => [].to_json
+          "data-hide-controls" => settings_source.try(:hide_controls),
+          "data-collapsed" => global_settings.collapse,
+          "data-truncate" => global_settings.truncate || 255,
+          "data-map-center" => global_settings.map_center,
+          "data-map-zoom" => global_settings.map_zoom || 8,
+          "data-menu-amendments" => global_settings.menu_amendments,
+          "data-menu-meetings" => global_settings.menu_meetings,
+          "data-menu-hashtags" => global_settings.menu_hashtags,
+          "data-show-not-answered" => step_settings&.show_not_answered,
+          "data-show-accepted" => step_settings&.show_accepted,
+          "data-show-withdrawn" => step_settings&.show_withdrawn,
+          "data-show-evaluating" => step_settings&.show_evaluating,
+          "data-show-rejected" => step_settings&.show_rejected
         }
 
-        if Decidim.geocoder[:here_api_key]
-          map_html_options["data-here-api-key"] = Decidim.geocoder[:here_api_key]
-        else
-          # Compatibility mode for old api_id/app_code configurations
-          map_html_options["data-here-app-id"] = Decidim.geocoder[:here_app_id]
-          map_html_options["data-here-app-code"] = Decidim.geocoder[:here_app_code]
+        content_tag(:div, html_options) do
+          content_tag :div, class: "row column" do
+            help + map
+          end
         end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity:
 
-        content = capture { yield }.html_safe
-        help = content_tag(:div, class: "map__help") do
-          content_tag(:p, I18n.t("screen_reader_explanation", scope: "decidim.map.dynamic"), class: "show-for-sr")
-        end
-        content_tag :div, class: "awesome-map" do
-          map = content_tag(:div, "", map_html_options)
+      def step_settings
+        settings_source.try(:current_settings)
+      end
 
-          help + map + content
-        end
+      def global_settings
+        settings_source.try(:settings)
+      end
+
+      def settings_source
+        try(:current_component) || self
       end
 
       # rubocop:disable Rails/HelperInstanceVariable
@@ -96,6 +84,30 @@ module Decidim
 
       private
 
+      def awesome_builder
+        options = {
+          popup_template_id: "marker-popup",
+          markers: []
+        }
+        builder = map_utility_dynamic.create_builder(self, options)
+
+        unless snippets.any?(:map)
+          snippets.add(:map, builder.stylesheet_snippets)
+          snippets.add(:map, builder.javascript_snippets)
+          snippets.add(:head, snippets.for(:map))
+        end
+
+        unless snippets.any?(:awesome_map)
+          snippets.add(:awesome_map, stylesheet_link_tag("decidim/decidim_awesome/awesome_map/map"))
+          snippets.add(:awesome_map, javascript_include_tag("decidim/decidim_awesome/awesome_map/map"))
+          snippets.add(:awesome_map, javascript_include_tag("decidim/decidim_awesome/awesome_map/load_map"))
+          snippets.add(:head, snippets.for(:awesome_map))
+        end
+
+        builder
+      end
+
+      # rubocop:disable Style/FormatStringToken
       def append_category(category)
         @h += @golden_ratio_conjugate
         @h %= 1
@@ -108,11 +120,12 @@ module Decidim
           color: format("#%02x%02x%02x", r, g, b)
         )
       end
+      # rubocop:enable Style/FormatStringToken
       # rubocop:enable Rails/HelperInstanceVariable
 
-      # rubocop:disable Naming/UncommunicativeMethodParamName
       # HSV values in [0..1[
       # returns [r, g, b] values from 0 to 255
+      # rubocop:disable Naming/MethodParameterName
       def hsv_to_rgb(h, s, v)
         h_i = (h * 6).to_i
         f = h * 6 - h_i
@@ -151,7 +164,7 @@ module Decidim
         end
         [(r * 256).to_i, (g * 256).to_i, (b * 256).to_i]
       end
-      # rubocop:enable Naming/UncommunicativeMethodParamName
     end
+    # rubocop:enable Naming/MethodParameterName
   end
 end

data/app/helpers/decidim/decidim_awesome/proposals/application_helper_override.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      module ApplicationHelperOverride
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method :decidim_text_editor_for_proposal_body, :text_editor_for_proposal_body
+          alias_method :decidim_safe_content?, :safe_content?
+
+          # replace safe content to consider all custom fields save (then embeded html will be rendered)
+          def safe_content?
+            awesome_proposal_custom_fields.present? || decidim_safe_content?
+          end
+
+          # replace normal method to draw the editor
+          def text_editor_for_proposal_body(form)
+            custom_fields = awesome_proposal_custom_fields
+
+            return decidim_text_editor_for_proposal_body(form) if custom_fields.blank?
+
+            render_proposal_custom_fields_override(custom_fields, form, :body)
+          end
+
+          # replace admin method to draw the editor (multi lang)
+          def admin_editor_for_proposal_body(form)
+            custom_fields = awesome_proposal_custom_fields
+
+            return form.translated(:editor, :body, hashtaggable: true) if custom_fields.blank?
+
+            locales = form.send(:locales)
+
+            return render_proposal_custom_fields_override(custom_fields, form, "body_#{locales.first}", locales.first) if locales.length == 1
+
+            tabs_id = form.send(:sanitize_tabs_selector, form.options[:tabs_id] || "#{form.object_name}-body-tabs")
+
+            label_tabs = form.content_tag(:div, class: "label--tabs") do
+              field_label = form.send(:label_i18n, "body", form.label_for("proposal_custom_fields"))
+
+              language_selector = "".html_safe
+              language_selector = form.create_language_selector(locales, tabs_id, "body") if form.options[:label] != false
+
+              safe_join [field_label, language_selector]
+            end
+
+            tabs_content = form.content_tag(:div, class: "tabs-content", data: { tabs_content: tabs_id }) do
+              locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
+                tab_content_id = "#{tabs_id}-body-panel-#{index}"
+                string + content_tag(:div, class: form.send(:tab_element_class_for, "panel", index), id: tab_content_id) do
+                  render_proposal_custom_fields_override(custom_fields, form, "body_#{locale}", locale)
+                end
+              end
+            end
+
+            safe_join [label_tabs, tabs_content]
+          end
+
+          def render_proposal_custom_fields_override(fields, form, name, locale = nil)
+            custom_fields = Decidim::DecidimAwesome::CustomFields.new(fields)
+            custom_fields.translate!
+
+            body = if form_presenter.proposal.body.is_a?(Hash) && locale
+                     form_presenter.body(extras: false, all_locales: true)[locale]
+                   else
+                     form_presenter.body(extras: false)
+                   end
+
+            custom_fields.apply_xml(body) if body.present?
+            form.object.errors.add(name, custom_fields.errors) if custom_fields.errors
+            render partial: "decidim/decidim_awesome/custom_fields/form_render", locals: { spec: custom_fields.to_json, form: form, name: name }
+          end
+        end
+      end
+    end
+  end
+end

data/app/middleware/decidim/decidim_awesome/current_config.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    # A middleware that stores the current awesome context by parsing the request
+    class CurrentConfig
+      # Initializes the Rack Middleware.
+      #
+      # app - The Rack application
+      def initialize(app)
+        @app = app
+      end
+
+      # Main entry point for a Rack Middleware.
+      #
+      # env - A Hash.
+      def call(env)
+        @request = Rack::Request.new(env)
+        if @request.env["decidim.current_organization"] && processable_path?
+          @config = awesome_config_instance
+          env["decidim_awesome.current_config"] = @config
+          tamper_user_model
+          add_flash_message_from_request(env)
+
+          # puts "requested path: #{env["PATH_INFO"]}"
+          # puts "current_organization: #{@request.env["decidim.current_organization"]&.id}"
+          # puts "potential_admins: #{Decidim::User.awesome_potential_admins}"
+          # puts "scoped admins: #{Decidim::User.awesome_admins_for_current_scope}"
+        else
+          reset_user_model
+        end
+
+        @app.call(env)
+      end
+
+      private
+
+      # a workaround to set a flash message if comming from the error controller (route not found)
+      def add_flash_message_from_request(env)
+        return unless scoped_admins_active?
+        return unless @request.params.has_key? "unauthorized"
+
+        env["rack.session"]["flash"] = ActionDispatch::Flash::FlashHash.new(alert: I18n.t("decidim.core.actions.unauthorized")).to_session_value
+      end
+
+      def awesome_config_instance
+        @awesome_config_instance = Config.new @request.env["decidim.current_organization"]
+        @awesome_config_instance.context_from_request @request
+        @awesome_config_instance
+      end
+
+      def reset_user_model
+        return unless scoped_admins_active?
+
+        Decidim::User.awesome_potential_admins = []
+        Decidim::User.awesome_admins_for_current_scope = []
+      end
+
+      def tamper_user_model
+        return unless scoped_admins_active?
+
+        Decidim::User.awesome_potential_admins = potential_admins
+
+        Decidim::User.awesome_admins_for_current_scope = if safe_get_route? || safe_post_route?
+                                                           Decidim::User.awesome_potential_admins
+                                                         else
+                                                           valid_admins
+                                                         end
+      end
+
+      def potential_admins
+        @config.collect_sub_configs_values("scoped_admin") do |subconfig|
+          subconfig&.constraints&.detect { |c| c.settings["participatory_space_manifest"] == "none" } ? false : true
+        end.flatten.uniq.map(&:to_i)
+      end
+
+      def valid_admins
+        @config.collect_sub_configs_values("scoped_admin") do |subconfig|
+          # allow index controllers if scoped to a subspace/component
+          constraints = subconfig&.constraints || []
+          additional_constraints = additional_get_constraints(constraints) + additional_post_constraints(constraints)
+          # inject additional constraints here for further use
+          @config.inject_sub_config_constraints("scoped_admin", subconfig.var[13..], additional_constraints) if subconfig
+          @config.valid_in_context?(constraints + additional_constraints)
+        end.flatten.uniq.map(&:to_i)
+      end
+
+      # avoid unnecessary processing for non-user routes
+      def processable_path?
+        return true if safe_get_route?
+
+        spaces = ContextAnalyzers::RequestAnalyzer.participatory_spaces_routes.keys.join("|^(/admin){0,1}/")
+        case @request.path
+        when %r{"|^(/admin){0,1}/#{spaces}}
+          true
+        when %r{^/admin/}
+          true
+        end
+      end
+
+      def safe_get_route?
+        return unless @request.get?
+
+        case @request.path
+        when "/"
+          true
+        when "/admin/"
+          true
+        when %r{^/admin/admin_terms}
+          true
+        when %r{^/profiles/|^/notifications/|^/conversations/|^/pages/}
+          true
+        end
+      end
+
+      def safe_post_route?
+        return unless @request.post? || @request.put? || @request.patch?
+
+        case @request.path
+        when %r{^/admin/admin_terms}
+          true
+        end
+      end
+
+      # to access certain deeper routes it requires first to click on a parent route, even without Post permissions in there
+      # this adds this additional routes to these cases
+      # For instance:
+      #        accessing /admin/participatory_processes/som-procress requires access first to /admin/participatory_processes
+      def additional_get_constraints(constraints)
+        return [] unless @request.get?
+
+        additions = []
+        constraints.each do |constraint|
+          next if constraint.settings["participatory_space_manifest"].blank?
+
+          # processes groups must give access to processes generic url
+          if constraint.settings["participatory_space_manifest"] == "process_groups"
+            additions << OpenStruct.new(settings: { "participatory_space_manifest" => "participatory_processes", "match" => "exclusive" })
+          end
+
+          # adds a exclusive constraint to the parent participatory space (so index page can be accessed)
+          next unless constraint.settings.size > 1
+
+          additions << OpenStruct.new(settings: {
+                                        "participatory_space_manifest" => constraint.settings["participatory_space_manifest"],
+                                        "match" => "exclusive"
+                                      })
+        end
+
+        additions
+      end
+
+      # adds access to REST routes with id instead of the slug ot allow editing
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def additional_post_constraints(constraints)
+        return [] unless @request.post? || @request.patch?
+
+        constraints.filter_map do |constraint|
+          settings = constraint.settings.dup
+          next unless settings["participatory_space_manifest"].present? && settings["participatory_space_slug"].present?
+
+          # replicate the constraint with the id of the participatory space
+          manifest = Decidim.participatory_space_manifests.find { |s| s.name.to_s == settings["participatory_space_manifest"] }
+          next unless manifest
+
+          model = manifest.model_class_name.try(:constantize)
+          next unless model
+
+          settings["participatory_space_slug"] = model.find_by(slug: settings["participatory_space_slug"])&.id
+          OpenStruct.new(settings: settings) if settings["participatory_space_slug"]
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def scoped_admins_active?
+        Decidim::User.respond_to?(:awesome_admins_for_current_scope) && Decidim::User.respond_to?(:awesome_potential_admins)
+      end
+    end
+  end
+end

data/app/models/decidim/decidim_awesome/awesome_config.rb

@@ -15,9 +15,24 @@ module Decidim
       validates :organization, presence: true
       validates :var, uniqueness: { scope: :decidim_organization_id }
 
+      def additional_constraints
+        @additional_constraints ||= []
+      end
+
+      def add_constraints(constraints)
+        return if constraints.blank?
+
+        additional_constraints.concat(constraints.respond_to?(:each) ? constraints : [constraints])
+      end
+
       def self.for_organization(organization)
         where(organization: organization)
       end
+
+      # use this instead of "constraints" to evaluate dynamically added constants
+      def all_constraints
+        constraints + additional_constraints
+      end
     end
   end
 end

data/app/models/decidim/decidim_awesome/user_override.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module UserOverride
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          attr_accessor :awesome_admins_for_current_scope, :awesome_potential_admins
+        end
+
+        def admin
+          return self["admin"] if self["admin"]
+
+          Decidim::User.awesome_admins_for_current_scope&.include?(id)
+        end
+
+        def admin?
+          admin.present?
+        end
+      end
+    end
+  end
+end

data/app/permissions/decidim/decidim_awesome/admin/permissions.rb

@@ -8,6 +8,8 @@ module Decidim
 
         def permissions
           return permission_action if permission_action.scope != :admin
+          return permission_action unless user
+          return permission_action if user.read_attribute("admin").blank?
 
           toggle_allow(config_enabled?(permission_action.subject)) if permission_action.action == :edit_config
 

data/app/uploaders/decidim/decidim_awesome/image_uploader.rb

@@ -10,11 +10,6 @@ module Decidim
         process resize_to_fit: [nil, 237]
       end
 
-      # TODO: remove when diching 0.22 support
-      def extension_white_list
-        %w(jpg jpeg png)
-      end
-
       def extension_whitelist
         %w(jpg jpeg png)
       end

data/app/views/decidim/decidim_awesome/admin/checks/index.html.erb

@@ -56,8 +56,8 @@
         <strong><%= t ".admin_head_tags" %></strong>
         <ul class="vertical menu">
         <% {
-          CSS: "//link[@rel='stylesheet'][contains(@href,'decidim_awesome/admin')]",
-          JavaScript: "//script[contains(@src,'decidim_awesome/admin')]"
+          CSS: "//link[@rel='stylesheet'][contains(@href,'decidim_awesome/awesome_admin')]",
+          JavaScript: "//script[contains(@src,'decidim_awesome')]"
           }.each do |part, xpath| %>
           <li>
             <%= part %>

data/app/views/decidim/decidim_awesome/admin/config/_autoedit_box_label.html.erb

@@ -0,0 +1,7 @@
+<%= label_tag var do %>
+    <%= t("config.#{var}",
+        scope: "activemodel.attributes",
+        id: "<span class='awesome-auto-edit' data-var='#{var}' data-scope='#{scope}' data-key='#{key}'>#{key}</span>").html_safe %>
+    <%= icon_link_to "pencil", "#", t("edit_label", scope: "decidim.decidim_awesome.admin.config.form"), class: "action-icon--edit awesome-auto-edit", data: { "scope" => "#{scope}" } %>
+    <%= link_to t("remove", scope: "decidim.decidim_awesome.admin.config.form_#{var}"), delete_path, method: :delete, class: "float-right delete-box", data: { confirm: t("sure_to_remove", scope: "decidim.decidim_awesome.admin.config.form_#{var}") } %>
+<% end %>

data/app/views/decidim/decidim_awesome/admin/config/_constraints.html.erb

@@ -11,11 +11,11 @@
     <span class="label warning"><%= t ".always" %></span>
   <% end %>
 
-  <ul class="constraints-list">
+  <ul class="constraints-list<%= " inactive" if constraints&.detect{|c| c.settings["participatory_space_manifest"]=="none" } %>">
     <% constraints&.each do |constraint| %>
         <li>
             <% constraint.settings.reverse_each do |k, val| %>
-              <span class="label <%= k %>"><%= translate_constraint_value constraint, k %></span>
+              <span class="label <%= k %> constraint-<%= val %>"><%= translate_constraint_value constraint, k %></span>
             <% end %>
           <a href="<%= constraint_path(id: constraint.id, key: key) %>" class="edit-condition"><%= t ".edit" %></a>
           <%= link_to t(".delete"), constraint_path(id: constraint.id), remote: true, method: :delete %>

data/app/views/decidim/decidim_awesome/admin/config/_form_admins.html.erb

@@ -0,0 +1,21 @@
+<div class="row column decidim_awesome-form">
+  <% if config_enabled? :scoped_admins %>
+    <p class="help-text"><%= t("help.scoped_admins", scope: "decidim.decidim_awesome.admin.config.form") %></p>
+
+    <% form.object.scoped_admins&.each do |key, value| %>
+      <div class="scoped_admins_container" data-key="<%= key %>">
+        <%= render(partial: "decidim/decidim_awesome/admin/config/autoedit_box_label", locals: { var: "scoped_admins", key: key, scope: "scoped_admin_#{key}", delete_path: decidim_admin_decidim_awesome.scoped_admin_path(key: key) }) %>
+        <p class="form-error is-visible" id="scoped-admin-error-<%= $key %>"><%= errors[key.to_sym].join("<br>") if errors %></p>
+
+        <%= select_tag "config[scoped_admins][#{key}]", options_from_collection_for_select(users_for(value), :id, :text, proc { true }), { include_blank: false ,  class: "multiusers-select", multiple: true, data: { url: decidim_admin_decidim_awesome.users_path } } %>
+
+        <%= render(partial: "decidim/decidim_awesome/admin/config/constraints", locals: { key: "scoped_admin_#{key}", constraints: constraints_for("scoped_admin_#{key}") }) %>
+      </div>
+    <% end %>
+
+    <%= link_to t("new", scope: "decidim.decidim_awesome.admin.config.form_scoped_admins"), decidim_admin_decidim_awesome.scoped_admins_path, method: :post %>
+
+  <% end %>
+</div>
+
+<%= javascript_include_tag "decidim/decidim_awesome/admin/form_exit_warn" %>