decidim-core 0.20.0 → 0.23.1.rc1

data/app/helpers/concerns/decidim/flash_helper_extensions.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  module FlashHelperExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      private
+
+      # Private: Foundation alert box.
+      #
+      # Overrides the foundation alert box helper for adding accessibility tags.
+      #
+      # value - The flash message.
+      # alert_class - The foundation class of the alert message.
+      # closable - A boolean indicating whether the close icon is added.
+      #
+      # Returns a HTML string.
+      def alert_box(value, alert_class, closable)
+        options = { class: "flash callout #{alert_class}" }
+        options[:data] = { closable: "" } if closable
+        options[:role] = "alert"
+        content_tag(:div, options) do
+          concat value
+          concat close_link if closable
+        end
+      end
+
+      # Private: Foudation alert box close link.
+      #
+      # Overrides the foundation alert box close link helper for the aria-label
+      # translations.
+      def close_link
+        button_tag(
+          class: "close-button",
+          type: "button",
+          data: { close: "" },
+          aria: { label: I18n.t("decidim.alert.dismiss") }
+        ) do
+          content_tag(:span, "×".html_safe, aria: { hidden: true })
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/action_authorization_helper.rb

@@ -65,12 +65,16 @@ module Decidim
       resource = html_options.delete(:resource)
 
       if !current_user
+        html_options = clean_authorized_to_data_open(html_options)
+
         html_options["data-open"] = "loginModal"
-        url = ""
+        url = "#"
       elsif action && !action_authorized_to(action, resource: resource).ok?
+        html_options = clean_authorized_to_data_open(html_options)
+
         html_options["data-open"] = "authorizationModal"
         html_options["data-open-url"] = modal_path(action, resource)
-        url = ""
+        url = "#"
       end
 
       html_options["onclick"] = "event.preventDefault();" if url == ""
@@ -90,5 +94,23 @@ module Decidim
                         end
       decidim.authorization_modal_path(authorization_action: action, component_id: current_component.id, **resource_params)
     end
+
+    def clean_authorized_to_data_open(html_options)
+      html_options.delete(:"data-open")
+      html_options.delete(:"data-open-url")
+
+      [:data, "data"].each do |key|
+        next unless html_options[key].is_a?(Hash)
+
+        html_options[key].delete(:open)
+        html_options[key].delete("open")
+        html_options[key].delete(:open_url)
+        html_options[key].delete("open_url")
+        html_options[key].delete(:"open-url")
+        html_options[key].delete("open-url")
+      end
+
+      html_options
+    end
   end
 end

data/app/helpers/decidim/amendments_helper.rb

@@ -3,6 +3,8 @@
 module Decidim
   # A Helper to render and link amendments to resources.
   module AmendmentsHelper
+    include RichTextEditorHelper
+
     # Renders the emendations of an amendable resource
     #
     # Returns Html grid of CardM.
@@ -107,8 +109,9 @@ module Decidim
 
     # Renders a UserGroup select field in a form.
     def user_group_select_field(form, name)
+      user_groups = UserGroups::ManageableUserGroups.for(current_user).verified
       form.select(name,
-                  current_user.user_groups.verified.map { |g| [g.name, g.id] },
+                  user_groups.map { |g| [g.name, g.id] },
                   selected: form.object.user_group_id.presence,
                   include_blank: current_user.name,
                   label: t("new.amendment_author", scope: "decidim.amendments"))
@@ -121,6 +124,31 @@ module Decidim
       I18n.t(attribute, scope: "activemodel.attributes.#{model_name}")
     end
 
+    def amendments_form_field_for(attribute, form, original_resource)
+      options = {
+        class: "js-hashtags",
+        label: amendments_form_fields_label(attribute),
+        value: amendments_form_fields_value(original_resource, attribute)
+      }
+
+      case attribute
+      when :title
+        form.text_field(:title, options)
+      when :body
+        text_editor_for(form, :body, options.merge(hashtaggable: true))
+      end
+    end
+
+    # If the content is safe, HTML tags are sanitized, otherwise, they are stripped.
+    def render_emendation_body(emendation)
+      body = present(emendation).body(links: true, strip_tags: !rich_text_editor_in_public_views?)
+      body = simple_format(body, {}, sanitize: false)
+
+      return body unless rich_text_editor_in_public_views?
+
+      decidim_sanitize(body)
+    end
+
     # Return the edited field value or presents the original attribute value in a form.
     #
     # original_resource - name of the method to send to the controller (:amendable or :emendation)

data/app/helpers/decidim/application_helper.rb

@@ -28,7 +28,7 @@ module Decidim
     end
 
     def present(object, presenter_class: nil)
-      presenter_class ||= "#{object.class.name}Presenter".constantize
+      presenter_class ||= resolve_presenter_class(object, presenter_class: presenter_class)
       presenter = presenter_class.new(object)
 
       yield(presenter) if block_given?
@@ -36,22 +36,56 @@ module Decidim
       presenter
     end
 
+    def resolve_presenter_class(object, presenter_class: nil)
+      presenter_class || "#{object.class.name}Presenter".constantize
+    rescue StandardError
+      ::Decidim::NilPresenter
+    end
+
     # Generates a link to be added to the global Edit link so admins
     # can easily manage data without having to look for it at the admin
     # panel when they're at a public page.
     #
-    # link          - The String with the URL.
+    # link_url      - The String with the URL.
     # action        - The Symbol action to check the permissions for.
     # subject       - The Symbol subject to perform the action to.
     # extra_context - An optional Hash to check the permissions.
+    # link_options   - An optional Hash to change the default name and icon link.
+    # link_options[:name]   - An optional String to be used as the label of the link.
+    # link_options[:icon]   - An optional String with the identifier name of the icon.
+    # link_options[:class]  - An optional String to add as a css class to the link wrapper.
     #
     # Returns nothing.
-    def edit_link(link, action, subject, extra_context = {})
+    def edit_link(link_url, action, subject, extra_context = {}, link_options = { class: "topbar__edit__link" })
       return unless current_user
       return unless admin_allowed_to?(action, subject, extra_context)
       return if content_for?(:edit_link)
 
-      content_for(:edit_link, link)
+      cell_html = raw(cell("decidim/navbar_admin_link", link_url: link_url, link_options: link_options))
+      content_for(:edit_link, cell_html)
+    end
+
+    # Generates a second link to be added to the global admin action link so admins
+    # can easily manage data without having to look for it at the admin
+    # panel when they're at a public page.
+    #
+    # link_url       - The String with the URL.
+    # action         - The Symbol action to check the permissions for.
+    # subject        - The Symbol subject to perform the action to.
+    # extra_context  - An optional Hash to check the permissions.
+    # link_options   - An optional Hash to change the default name and icon link.
+    # link_options[:name]   - An optional String to be used as the label of the link.
+    # link_options[:icon]   - An optional String with the identifier name of the icon.
+    # link_options[:class]  - An optional String to add as a css class to the link wrapper.
+    #
+    # Returns nothing.
+    def extra_admin_link(link_url, action, subject, extra_context = {}, link_options = {})
+      return unless current_user
+      return unless admin_allowed_to?(action, subject, extra_context)
+      return if content_for?(:extra_admin_link)
+
+      cell_html = raw(cell("decidim/navbar_admin_link", link_url: link_url, link_options: link_options))
+      content_for(:extra_admin_link, cell_html)
     end
 
     # Public: Overwrites the `cell` helper method to automatically set some

data/app/helpers/decidim/categories_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper for rendering Decidim::Category related stuff.
+  module CategoriesHelper
+    def categories_for_select(scope)
+      sorted_main_categories = scope.first_class.includes(:subcategories).sort_by do |category|
+        translated_attribute(category.name, category.participatory_space.organization)
+      end
+
+      sorted_main_categories.flat_map do |category|
+        parent = [[translated_attribute(category.name, category.participatory_space.organization), category.id]]
+
+        sorted_subcategories = category.subcategories.sort_by do |subcategory|
+          translated_attribute(subcategory.name, subcategory.participatory_space.organization)
+        end
+
+        sorted_subcategories.each do |subcategory|
+          parent << ["- #{translated_attribute(subcategory.name, subcategory.participatory_space.organization)}", subcategory.id]
+        end
+
+        parent
+      end
+    end
+  end
+end

data/app/helpers/decidim/cells_helper.rb

@@ -6,18 +6,6 @@ module Decidim
       options[:from].presence || context[:from].presence
     end
 
-    def proposals_controller?
-      context[:controller].class.to_s == "Decidim::Proposals::ProposalsController"
-    end
-
-    def collaborative_drafts_controller?
-      context[:controller].class.to_s == "Decidim::Proposals::CollaborativeDraftsController"
-    end
-
-    def posts_controller?
-      context[:controller].class.to_s == "Decidim::Blogs::PostsController"
-    end
-
     def index_action?
       context[:controller].action_name == "index"
     end
@@ -32,15 +20,15 @@ module Decidim
 
     def withdrawable?
       return unless from_context
-      return unless proposals_controller?
+      return unless context[:controller].try(:withdrawable_controller?)
       return if index_action?
 
       from_context.withdrawable_by?(current_user)
     end
 
-    def flagable?
+    def flaggable?
       return unless from_context
-      return unless proposals_controller? || collaborative_drafts_controller?
+      return unless context[:controller].try(:flaggable_controller?)
       return if index_action?
 
       true

data/app/helpers/decidim/check_boxes_tree_helper.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This helper include some methods for rendering a checkboxes tree input.
+  module CheckBoxesTreeHelper
+    # This method returns a hash with the options for the checkbox and its label
+    # used in filters that uses checkboxes trees
+    def check_boxes_tree_options(value, label, **options)
+      checkbox_options = {
+        value: value,
+        label: label,
+        multiple: true,
+        include_hidden: false,
+        label_options: {
+          "data-children-checkbox": "",
+          value: value
+        }
+      }
+      options.merge!(checkbox_options)
+
+      if options.delete(:is_root_check_box) == true
+        options[:label_options].merge!("data-global-checkbox": "")
+        options[:label_options].delete(:"data-children-checkbox")
+      end
+
+      options
+    end
+
+    # struct for nodes of checkboxes trees
+    TreeNode = Struct.new(:leaf, :node) do
+      def tree_node?
+        is_a?(TreeNode)
+      end
+    end
+
+    # struct for leafs of checkboxes trees
+    TreePoint = Struct.new(:value, :label) do
+      def tree_node?
+        is_a?(TreeNode)
+      end
+    end
+
+    # Overwrite this method in your component helper to define
+    # origin values.
+    def filter_origin_values
+      raise StandardError, "Not implemented"
+    end
+
+    def filter_categories_values
+      organization = current_participatory_space.organization
+
+      sorted_main_categories = current_participatory_space.categories.first_class.includes(:subcategories).sort_by do |category|
+        [category.weight, translated_attribute(category.name, organization)]
+      end
+
+      categories_values = sorted_main_categories.flat_map do |category|
+        sorted_descendant_categories = category.descendants.includes(:subcategories).sort_by do |subcategory|
+          [subcategory.weight, translated_attribute(subcategory.name, organization)]
+        end
+
+        subcategories = sorted_descendant_categories.flat_map do |subcategory|
+          TreePoint.new(subcategory.id.to_s, translated_attribute(subcategory.name, organization))
+        end
+
+        TreeNode.new(
+          TreePoint.new(category.id.to_s, translated_attribute(category.name, organization)),
+          subcategories
+        )
+      end
+
+      TreeNode.new(
+        TreePoint.new("", t("decidim.proposals.application_helper.filter_category_values.all")),
+        categories_values
+      )
+    end
+
+    def resource_filter_scope_values(resource)
+      if resource.is_a?(Scope)
+        filter_scopes_values_from([resource])
+      else
+        filter_scopes_values
+      end
+    end
+
+    def filter_scopes_values
+      main_scopes = if current_component.scope.present?
+                      [current_component.scope]
+                    else
+                      current_participatory_space.scopes.top_level
+                                                 .includes(:scope_type, :children)
+                    end
+      filter_scopes_values_from(main_scopes)
+    end
+
+    def filter_scopes_values_from(scopes)
+      scopes_values = scopes.compact.flat_map do |scope|
+        TreeNode.new(
+          TreePoint.new(scope.id.to_s, translated_attribute(scope.name, current_participatory_space.organization)),
+          scope_children_to_tree(scope)
+        )
+      end
+
+      scopes_values.prepend(TreePoint.new("global", t("decidim.scopes.global"))) if current_participatory_space.scope.blank?
+
+      TreeNode.new(
+        TreePoint.new("", t("decidim.proposals.application_helper.filter_scope_values.all")),
+        scopes_values
+      )
+    end
+
+    def scope_children_to_tree(scope)
+      return if scope.scope_type && scope.scope_type == current_participatory_space.try(:scope_type_max_depth)
+      return unless scope.children.any?
+
+      scope.children.includes(:scope_type, :children).flat_map do |child|
+        TreeNode.new(
+          TreePoint.new(child.id.to_s, translated_attribute(child.name, current_participatory_space.organization)),
+          scope_children_to_tree(child)
+        )
+      end
+    end
+  end
+end

data/app/helpers/decidim/cookies_helper.rb

@@ -5,7 +5,7 @@ module Decidim
   module CookiesHelper
     # Public: Returns true if the cookie policy has been accepted
     def cookies_accepted?
-      cookies["decidim-cc"].present?
+      cookies[Decidim.config.consent_cookie_name].present?
     end
   end
 end

data/app/helpers/decidim/cta_button_helper.rb

@@ -8,7 +8,7 @@ module Decidim
     def cta_button
       button_text = translated_attribute(current_organization.cta_button_text).presence || t("decidim.pages.home.hero.participate")
 
-      link_to button_text, cta_button_path, class: "hero-cta button expanded large button--sc"
+      link_to button_text, cta_button_path, class: "hero-cta button expanded large button--sc", title: t("decidim.pages.home.hero.participate_title")
     end
 
     # Finds the CTA button path to reuse it in other places.

data/app/helpers/decidim/decidim_form_helper.rb

@@ -17,6 +17,18 @@ module Decidim
       options[:html] ||= {}
       options[:html].update(novalidate: true)
 
+      # Generally called by form_for but we need the :url option generated
+      # already before that.
+      #
+      # See:
+      # https://github.com/rails/rails/blob/master/actionview/lib/action_view/helpers/form_helper.rb#L459
+      if record.is_a?(ActiveRecord::Base)
+        object = record.is_a?(Array) ? record.last : record
+        format = options[:format]
+        apply_form_for_options!(record, object, options) if object
+        options[:format] = format if format
+      end
+
       output = ""
       output += base_error_messages(record).to_s
       output += form_for(record, options, &block).to_s
@@ -75,7 +87,7 @@ module Decidim
                          picker_options: picker_options,
                          prompt_params: prompt_params,
                          scopes: scopes,
-                         checkboxes_on_top: true)
+                         values_on_top: true)
       template.html_safe
     end
 
@@ -183,6 +195,17 @@ module Decidim
       end
     end
 
+    # Helper method to show an explanation for the form's required fields that
+    # are marked with an asterisk character. This improves the accessibility of
+    # the forms.
+    #
+    # Returns an HTML-safe String.
+    def form_required_explanation
+      content_tag(:div, class: "help-text help-text-form-required-fields") do
+        I18n.t("forms.required_explanation")
+      end
+    end
+
     def base_error_messages(record)
       return unless record.respond_to?(:errors)
       return unless record.errors[:base].any?