decidim-decidim_awesome 0.7.0 → 0.7.2

data/lib/decidim/decidim_awesome/awesome_helpers.rb

@@ -10,8 +10,12 @@ module Decidim
       def awesome_config_instance
         return @awesome_config_instance if @awesome_config_instance
 
-        @awesome_config_instance = Config.new request.env["decidim.current_organization"]
-        @awesome_config_instance.context_from_request request
+        # if already created in the middleware, reuse it as it might have additional constraints
+        @awesome_config_instance = request.env["decidim_awesome.current_config"]
+        unless @awesome_config_instance.is_a? Config
+          @awesome_config_instance = Config.new request.env["decidim.current_organization"]
+          @awesome_config_instance.context_from_request request
+        end
         @awesome_config_instance
       end
 
@@ -20,7 +24,7 @@ module Decidim
       end
 
       def javascript_config_vars
-        awesome_config.except(:scoped_styles).to_json.html_safe
+        awesome_config.except(:scoped_styles, :proposal_custom_fields, :scoped_admins).to_json.html_safe
       end
 
       def show_public_intergram?
@@ -51,14 +55,17 @@ module Decidim
 
       # Collects all CSS that is applied in the current URL context
       def awesome_custom_styles
-        return unless awesome_config[:scoped_styles]
-        return @awesome_custom_styles if @awesome_custom_styles
+        @awesome_custom_styles ||= awesome_config_instance.collect_sub_configs_values("scoped_style")
+      end
 
-        styles = awesome_config[:scoped_styles]&.filter do |key, _value|
-          config = AwesomeConfig.find_by(var: "scoped_style_#{key}", organization: current_organization)
-          @awesome_config_instance.valid_in_context?(config&.constraints)
-        end
-        @awesome_custom_styles = styles.values.join("\n")
+      # Collects all proposal custom fields that is applied in the current URL context
+      def awesome_scoped_admins
+        @awesome_scoped_admins ||= awesome_config_instance.collect_sub_configs_values("scoped_admin")
+      end
+
+      # Collects all proposal custom fields that is applied in the current URL context
+      def awesome_proposal_custom_fields
+        @awesome_proposal_custom_fields ||= awesome_config_instance.collect_sub_configs_values("proposal_custom_field")
       end
 
       def version_prefix

data/lib/decidim/decidim_awesome/checksums.yml

@@ -13,8 +13,21 @@ decidim-core:
     decidim-0.24: 284c96f19cd98df091d8178d6db5a8b3
   /app/presenters/decidim/menu_item_presenter.rb:
     decidim-0.23: 70db39954b5840924530bf94d2a0a73a
+  /app/helpers/decidim/amendments_helper.rb:
+    decidim-0.23: 75bd41c3186729c7c84911bc7c7e9677
 decidim-proposals:
-  /app/presenters/decidim/proposals/proposal_presenter.rb:
-    decidim-0.23: 437c0c25151f605401a4f14d090ba5ea
-    decidim-0.23.1: 892021b2ce9ac10c2e1b738e6948cde0
-    decidim-0.24: 0b6717a3eeecad03277cea5ed6ba1fb7
+  /app/forms/decidim/proposals/proposal_wizard_create_step_form.rb:
+    decidim-0.23: b99c3223f1e75f2a69a89ae9a3d28182
+    decidim-0.23.1: 13ebf86ec88fa64d2651ab9735d5de90
+    decidim-0.24: db69edd0ba8ffa3965a5c44a6bfaba8d
+  /app/helpers/decidim/proposals/application_helper.rb:
+    decidim-0.23: d923323e3db542b84f42db3a4f782a8d
+    decidim-0.24: c5f99f5fa7de9a6e45776983330e9d73
+  /app/views/decidim/proposals/collaborative_drafts/show.html.erb:
+    decidim-0.23: b0fc5dfaf056c1a1dc667f8ded1a4b2e
+    decidim-0.24: 2a7e0a4c65361f238fd1b917f39c8642
+  /app/views/decidim/proposals/collaborative_drafts/_edit_form_fields.html.erb:
+    decidim-0.23: b0fc5dfaf056c1a1dc667f8ded1a4b2e
+    decidim-0.24: 6f717555a20e2ab3f555003c337d3003
+  /app/views/decidim/proposals/admin/proposals/_form.html.erb:
+    decidim-0.23: 022eef3e8f57ccc2136ed1289b0f217d

data/lib/decidim/decidim_awesome/config.rb

@@ -9,13 +9,14 @@ module Decidim
         @vars = AwesomeConfig.for_organization(organization).includes(:constraints)
         @context = {
           participatory_space_manifest: nil,
-          participatory_slug: nil,
+          participatory_space_slug: nil,
           component_id: nil,
           component_manifest: nil
         }
+        @sub_configs = {}
       end
 
-      attr_reader :context
+      attr_reader :context, :organization, :vars
       attr_writer :defaults
 
       def defaults
@@ -84,14 +85,60 @@ module Decidim
         # if no constraints defined, applies to everything
         return true if constraints.blank?
 
+        # if containts the "none" constraints, deactivate everything else
+        return false if constraints.detect { |c| c.settings["participatory_space_manifest"] == "none" }
+
         # check if current context matches some constraint
         constraints.detect do |constraint|
-          # if some setting is different, rejects
-          invalid = constraint.settings.detect { |key, val| context[key.to_sym].to_s != val.to_s }
-          invalid.blank?
+          settings = constraint.settings.symbolize_keys
+          match_method = settings.delete(:match)
+          if match_method == "exclusive"
+            # all keys must match
+            settings == context
+          else
+            # constraints keys can match the context partially (ie: if slug is not specified, any space matches in the same manifest)
+            # if some setting is different, rejects
+            invalid = constraint.settings.detect { |key, val| context[key.to_sym].to_s != val.to_s }
+            invalid.blank?
+          end
         end
       end
 
+      # adds some custom constraints for the instance that can be generated dynamically
+      def inject_sub_config_constraints(singular_key, subkey, constraints)
+        sub_configs_for(singular_key)[subkey.to_sym]&.add_constraints constraints
+      end
+
+      # Merges all subconfigs values for custom_styles or any other scoped confs
+      # by default filtered according to the current scope, a block can be passed for custom filtering
+      # ie, collect everything:
+      #    collect_sub_configs_values("scoped_style") { true }
+      def collect_sub_configs_values(singular_key)
+        plural_key = singular_key.pluralize.to_sym
+
+        fields = config[plural_key]&.filter do |key, _value|
+          subconfig = sub_configs_for(singular_key)[key]
+          # allow custom filtering if block given
+          if block_given?
+            yield subconfig
+          else
+            valid_in_context?(subconfig&.all_constraints)
+          end
+        end
+        fields.values
+      end
+
+      def sub_configs_for(singular_key)
+        return @sub_configs[singular_key] if @sub_configs[singular_key]
+
+        plural_key = singular_key.pluralize.to_sym
+        return {} unless config[plural_key]
+
+        @sub_configs[singular_key] = config[plural_key].map do |key, _value|
+          [key, AwesomeConfig.find_by(var: "#{singular_key}_#{key}", organization: @organization)]
+        end.to_h
+      end
+
       private
 
       def map_defaults
@@ -107,7 +154,7 @@ module Decidim
 
       def calculate_config
         # filter vars compliant with current context
-        valid = @vars.filter { |item| enabled_for_organization?(item.var) && valid_in_context?(item.constraints) }
+        valid = @vars.filter { |item| enabled_for_organization?(item.var) && valid_in_context?(item.all_constraints) }
                      .map { |v| [v.var.to_sym, v.value] }.to_h
 
         map_defaults do |key|

data/lib/decidim/decidim_awesome/context_analyzers/request_analyzer.rb

@@ -5,17 +5,32 @@ module Decidim
     module ContextAnalyzers
       # Translates some Decidim URL path to detected participatory spaces and components
       class RequestAnalyzer
+        class << self
+          def context_for(request)
+            analyzer = new request
+            analyzer.extract_context!
+            analyzer.context
+          end
+
+          # In the frontend there's no a 100% correspondence between url and manifest name
+          def participatory_spaces_routes
+            spaces = Decidim.participatory_space_manifests \
+                            .filter { |space| !DecidimAwesome.config.participatory_spaces_routes_context.has_key?(space.name) } \
+                            .map { |space| [space.name.to_s, space.name.to_s] }.to_h
+            DecidimAwesome.config.participatory_spaces_routes_context.each do |manifest, routes|
+              routes.each do |route|
+                spaces[route.to_s] = manifest.to_s
+              end
+            end
+            spaces
+          end
+        end
+
         def initialize(request)
           @request = request
           @context = {}
         end
 
-        def self.context_for(request)
-          analyzer = new request
-          analyzer.extract_context!
-          analyzer.context
-        end
-
         attr_reader :request, :context
 
         def extract_context!
@@ -25,20 +40,8 @@ module Decidim
 
         private
 
-        # In the frontend there's no a 100% correspondence between url and manifest name
-        def participatory_spaces
-          spaces = Decidim.participatory_space_manifests.map do |space|
-            [space.name.to_s, space.name.to_s]
-          end.to_h
-          spaces.merge(
-            "processes" => "participatory_processes",
-            "participatory_process_groups" => "participatory_processes",
-            "assemblies_types" => "assemblies"
-          )
-        end
-
         def process_admin_segments(segments)
-          spaces = participatory_spaces
+          spaces = RequestAnalyzer.participatory_spaces_routes
           return unless spaces[segments[0]]
 
           @context[:participatory_space_manifest] = spaces[segments[0]]
@@ -53,7 +56,7 @@ module Decidim
         end
 
         def process_front_segments(segments)
-          spaces = participatory_spaces
+          spaces = RequestAnalyzer.participatory_spaces_routes
           return unless spaces[segments[0]]
 
           @context[:participatory_space_manifest] = spaces[segments[0]]
@@ -70,8 +73,11 @@ module Decidim
         def system_manifest?(path)
           patterns = [
             %r{^/admin/newsletters},
+            %r{^/admin/moderations},
+            %r{^/admin/users},
             %r{^/admin/organization},
-            %r{^/admin/static_pages}
+            %r{^/admin/static_pages},
+            %r{^/admin/logs}
           ]
           path.match(Regexp.union(patterns))
         end

data/lib/decidim/decidim_awesome/custom_fields.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class CustomFields
+      def initialize(fields)
+        @fields = if fields.respond_to? :map
+                    fields.map { |f| JSON.parse(f) }.flatten
+                  else
+                    JSON.parse(fields)
+                  end
+      end
+
+      attr_reader :fields, :xml, :errors, :data
+
+      def apply_xml(xml)
+        parse_xml(xml)
+        map_fields!
+      rescue StandardError => e
+        @errors = e.message
+      end
+
+      def to_json(*_args)
+        @fields
+      end
+
+      def translate!
+        translate_values!
+      end
+
+      private
+
+      def parse_xml(xml)
+        @xml = xml
+        @data = Nokogiri.XML(xml).xpath("//dl/dd")
+        return if @data.present?
+
+        apply_to_first_textarea
+      end
+
+      def map_fields!
+        return unless data
+
+        @fields.map! do |field|
+          if field["name"] # ignore headers/paragraphs
+            value = data.search("##{field["name"]} div")
+            field["userData"] = value.map { |v| v.attribute("alt")&.value || v.inner_html(encoding: "UTF-8") } if value.present?
+          end
+
+          field
+        end
+      end
+
+      # Finds the first textarea and applies non-xml compatible content
+      # when textarea has not wysiwyg assigned, strips html
+      def apply_to_first_textarea
+        # quill editor might leave html traces without any user content
+        # so we won't process it if there is no text (html free) result
+        text = Nokogiri.HTML(xml).html? ? Nokogiri.HTML(xml).text.strip : text.strip
+        return if text.blank?
+
+        textarea = @fields.find { |field| field["type"] == "textarea" }
+        @errors = I18n.t(".invalid_xml", scope: "decidim.decidim_awesome.custom_fields.errors")
+        return unless textarea
+
+        textarea["userData"] = [textarea["subtype"] == "textarea" ? text : xml]
+        @errors = I18n.t(".invalid_fields", scope: "decidim.decidim_awesome.custom_fields.errors", field: textarea["label"] || textarea["name"])
+      end
+
+      def translate_values!
+        deep_transform_values!(@fields) do |value|
+          next value unless value.is_a? String
+          next value unless (match = value.match(/^(.*\..*)$/))
+
+          I18n.t(match[1], raise: true)
+        rescue I18n::MissingTranslationData
+          value
+        end
+        @fields
+      end
+
+      def deep_transform_values!(object, &block)
+        case object
+        when Hash
+          object.transform_values! { |value| deep_transform_values!(value, &block) }
+        when Array
+          object.map! { |e| deep_transform_values!(e, &block) }
+        else
+          yield(object)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/engine.rb

@@ -8,30 +8,86 @@ module Decidim
   module DecidimAwesome
     # This is the engine that runs on the public interface of decidim_awesome.
     class Engine < ::Rails::Engine
+      include AwesomeHelpers
+
       isolate_namespace Decidim::DecidimAwesome
 
       routes do
         post :editor_images, to: "editor_images#create"
       end
 
+      initializer "decidim.middleware" do |app|
+        app.config.middleware.insert_after Decidim::CurrentOrganization, Decidim::DecidimAwesome::CurrentConfig
+      end
+
+      # Prepare a zone to create overrides
+      # https://edgeguides.rubyonrails.org/engines.html#overriding-models-and-controllers
+      # overrides
+      config.to_prepare do
+        if DecidimAwesome.config[:scoped_admins] != :disabled
+          # override user's admin property
+          Decidim::User.include(UserOverride)
+          # redirect unauthorized scoped admins to allowed places
+          Decidim::ErrorsController.include(AdminNotFoundRedirect)
+        end
+
+        Decidim::Proposals::ApplicationHelper.include(Decidim::DecidimAwesome::Proposals::ApplicationHelperOverride)
+        Decidim::AmendmentsHelper.include(Decidim::DecidimAwesome::AmendmentsHelperOverride)
+
+        # TODO: move to include overrides
+        Dir.glob("#{Engine.root}/app/awesome_overrides/**/*_override.rb").each do |override|
+          require_dependency override
+        end
+      end
+
       initializer "decidim_awesome.view_helpers" do
         ActionView::Base.include AwesomeHelpers
       end
 
       initializer "decidim_decidim_awesome.assets" do |app|
-        app.config.assets.precompile += %w(decidim_decidim_awesome_manifest.js decidim_decidim_awesome_manifest.css)
+        app.config.assets.precompile += if version_prefix == "v0.23"
+                                          %w(legacy_decidim_decidim_awesome_manifest.js decidim_decidim_awesome_manifest.css)
+                                        else
+                                          %w(decidim_decidim_awesome_manifest.js decidim_decidim_awesome_manifest.css)
+                                        end
         # add to precompile any present theme asset
         Dir.glob(Rails.root.join("app/assets/themes/*.*")).each do |path|
           app.config.assets.precompile << path
         end
       end
 
-      # Prepare a zone to create overrides
-      # https://edgeguides.rubyonrails.org/engines.html#overriding-models-and-controllers
-      config.to_prepare do
-        Dir.glob("#{Engine.root}/app/awesome_overrides/**/*_override.rb").each do |override|
-          require_dependency override
+      initializer "decidim_decidim_awesome.add_cells_view_paths" do
+        Cell::ViewModel.view_paths << File.expand_path("#{Decidim::DecidimAwesome::Engine.root}/app/cells")
+        Cell::ViewModel.view_paths << File.expand_path("#{Decidim::DecidimAwesome::Engine.root}/app/views")
+      end
+
+      initializer "decidim_decidim_awesome.content_blocks" do |_app|
+        # === Home Map block ===
+        Decidim.content_blocks.register(:homepage, :awesome_map) do |content_block|
+          content_block.cell = "decidim/decidim_awesome/content_blocks/map"
+          content_block.settings_form_cell = "decidim/decidim_awesome/content_blocks/map_form"
+          content_block.public_name_key = "decidim.decidim_awesome.content_blocks.map.name"
+
+          content_block.settings do |settings|
+            settings.attribute :title, type: :text, translated: true
+
+            settings.attribute :map_height, type: :integer, default: 500
+            settings.attribute :map_center, type: :string, default: ""
+            settings.attribute :map_zoom, type: :integer, default: 8
+            settings.attribute :truncate, type: :integer, default: 255
+            settings.attribute :collapse, type: :boolean, default: false
+            settings.attribute :menu_amendments, type: :boolean, default: true
+            settings.attribute :menu_meetings, type: :boolean, default: true
+            settings.attribute :menu_hashtags, type: :boolean, default: true
+
+            settings.attribute :show_not_answered, type: :boolean, default: true
+            settings.attribute :show_accepted, type: :boolean, default: true
+            settings.attribute :show_withdrawn, type: :boolean, default: false
+            settings.attribute :show_evaluating, type: :boolean, default: true
+            settings.attribute :show_rejected, type: :boolean, default: false
+          end
         end
+        # === TODO: processes groups map block ===
       end
     end
   end

data/lib/decidim/decidim_awesome/test/shared_examples/box_label_editor.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+shared_examples "edits box label inline" do |test_case, key|
+  let(:data) { '[{"type":"text","label":"Short Name","subtype":"text","className":"form-control","name":"text-1476748004559"}]' }
+
+  it "updates the label when no changes" do
+    link = find("[data-key=#{key}] a.awesome-auto-edit", match: :first)
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    link.click
+    expect(page).to have_css("input.awesome-auto-edit")
+    find("body").click
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    link.click
+    input = find("[data-key=#{key}] input.awesome-auto-edit")
+    input.fill_in with: "A new làbel\n"
+    sleep 1
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    expect(page).to have_css("span.awesome-auto-edit[data-key=a_new_label]")
+
+    find("*[type=submit]").click
+    case test_case
+    when :css
+      expect(page).to have_content("body {background: red;}")
+    when :fields
+      expect(page).to have_content("Occupation")
+      expect(page).to have_content("Street Sweeper")
+      expect(page).not_to have_content("Short Bio")
+    when :admins
+      expect(page).not_to have_content(user.name.to_s)
+      expect(page).to have_content(user2.name.to_s)
+      expect(page).to have_content(user3.name.to_s)
+    end
+    expect(page).to have_css("span.awesome-auto-edit[data-key=a_new_label]")
+    expect(page).not_to have_css("span.awesome-auto-edit[data-key=#{key}]")
+  end
+
+  it "updates the label with previous changes" do
+    case test_case
+    when :css
+      sleep 1
+      page.execute_script("document.querySelector(\"[data-key=#{key}] .CodeMirror\").CodeMirror.setValue(\"div {background: brown;}\");")
+    when :fields
+      sleep 2
+      page.execute_script("$('.proposal_custom_fields_container[data-key=#{key}] .proposal_custom_fields_editor')[0].FormBuilder.actions.setData(#{data})")
+    when :admins
+      sleep 1
+      page.execute_script("$('.multiusers-select:first').append(new Option('#{user.name}', #{user.id}, true, true)).trigger('change');")
+    end
+
+    link = find("[data-key=#{key}] a.awesome-auto-edit", match: :first)
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    link.click
+    expect(page).to have_css("input.awesome-auto-edit")
+    find("body").click
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    link.click
+    input = find("[data-key=#{key}] input.awesome-auto-edit")
+    input.fill_in with: "A new làbel\n"
+    sleep 1
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    expect(page).to have_css("span.awesome-auto-edit[data-key=a_new_label]")
+
+    find("*[type=submit]").click
+    case test_case
+    when :css
+      expect(page).to have_admin_callout("updated successfully")
+      expect(page).to have_content("div {background: brown;}")
+    when :fields
+      expect(page).to have_content("Short Name")
+    when :admins
+      expect(page).to have_content(user.name.to_s)
+      expect(page).to have_content(user2.name.to_s)
+      expect(page).to have_content(user3.name.to_s)
+    end
+    expect(page).to have_css("span.awesome-auto-edit[data-key=a_new_label]")
+    expect(page).not_to have_css("span.awesome-auto-edit[data-key=#{key}]")
+  end
+
+  it "updates the label with post changes" do
+    link = find("[data-key=#{key}] a.awesome-auto-edit", match: :first)
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    link.click
+    expect(page).to have_css("input.awesome-auto-edit")
+    find("body").click
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    link.click
+    input = find("[data-key=#{key}] input.awesome-auto-edit")
+    input.fill_in with: "A new làbel\n"
+    sleep 1
+    expect(page).not_to have_css("input.awesome-auto-edit")
+    expect(page).to have_css("span.awesome-auto-edit[data-key=a_new_label]")
+
+    case test_case
+    when :css
+      sleep 1
+      page.execute_script('document.querySelector("[data-key=a_new_label] .CodeMirror").CodeMirror.setValue("body {background: lilac;}");')
+      find("*[type=submit]").click
+      expect(page).to have_admin_callout("updated successfully")
+      expect(page).to have_content("body {background: lilac;}")
+    when :fields
+      expect(page).to have_content("Full Name")
+      sleep 2
+      page.execute_script("$('.proposal_custom_fields_container[data-key=a_new_label] .proposal_custom_fields_editor')[0].FormBuilder.actions.setData(#{data})")
+      find("*[type=submit]").click
+      expect(page).to have_content("Short Name")
+    when :admins
+      page.execute_script("$('.multiusers-select:first').append(new Option('#{user.name}', #{user.id}, true, true)).trigger('change');")
+      find("*[type=submit]").click
+      expect(page).to have_content(user.name.to_s)
+      expect(page).to have_content(user2.name.to_s)
+      expect(page).to have_content(user3.name.to_s)
+    end
+    expect(page).to have_css("span.awesome-auto-edit[data-key=a_new_label]")
+    expect(page).not_to have_css("span.awesome-auto-edit[data-key=#{key}]")
+  end
+end