decidim-core 0.21.0 → 0.22.0

data/app/helpers/decidim/check_boxes_tree_helper.rb

@@ -18,11 +18,10 @@ module Decidim
       }
       options.merge!(checkbox_options)
 
-      if options[:is_root_check_box] == true
+      if options.delete(:is_root_check_box) == true
         options[:label_options].merge!("data-global-checkbox": "")
         options[:label_options].delete(:"data-children-checkbox")
       end
-      options[:label_options].delete(:is_root_check_box)
 
       options
     end
@@ -62,7 +61,7 @@ module Decidim
       end
 
       categories_values = sorted_main_categories.flat_map do |category|
-        sorted_descendant_categories = category.descendants.sort_by do |subcategory|
+        sorted_descendant_categories = category.descendants.includes(:subcategories).sort_by do |subcategory|
           [subcategory.weight, translated_attribute(subcategory.name, organization)]
         end
 
@@ -83,7 +82,7 @@ module Decidim
     end
 
     def filter_scopes_values
-      main_scopes = current_participatory_space.scope.present? ? [current_participatory_space.scope] : current_participatory_space.scopes.top_level
+      main_scopes = current_participatory_space.scope.present? ? [current_participatory_space.scope] : current_participatory_space.scopes.top_level.includes(:scope_type, :children)
 
       scopes_values = main_scopes.flat_map do |scope|
         TreeNode.new(
@@ -104,7 +103,7 @@ module Decidim
       return if scope.scope_type && scope.scope_type == current_participatory_space.try(:scope_type_max_depth)
       return unless scope.children.any?
 
-      scope.children.flat_map do |child|
+      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)

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
@@ -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?

data/app/helpers/decidim/endorsable_helper.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A Helper for views with Endorsable resources.
+  module EndorsableHelper
+    # Invokes the decidim/endorsement_buttons cell.
+    def endorsement_buttons_cell(resource)
+      cell("decidim/endorsement_buttons", resource)
+    end
+
+    # Invokes the decidim/endorsers_list cell.
+    def endorsers_list_cell(resource)
+      cell("decidim/endorsers_list", resource)
+    end
+
+    #
+    # Public: Checks if the given resource has been endorsed by all identities of the user.
+    #
+    # @param resource: The resource from which endorsements will be checked against.
+    # @param user:     The user whose identities and endorsements  will be checked against.
+    #
+    def fully_endorsed?(resource, user)
+      return false unless user
+
+      user_group_endorsements = Decidim::UserGroups::ManageableUserGroups.for(user).verified.all? { |user_group| resource.endorsed_by?(user, user_group) }
+
+      user_group_endorsements && resource.endorsed_by?(user)
+    end
+
+    # Public: Checks if endorsement are enabled in this step.
+    #
+    # Returns true if enabled, false otherwise.
+    def endorsements_enabled?
+      current_settings.endorsements_enabled
+    end
+
+    # Public: Checks if endorsements are blocked in this step.
+    #
+    # Returns true if blocked, false otherwise.
+    def endorsements_blocked?
+      current_settings.endorsements_blocked
+    end
+
+    # Public: Checks if the current user is allowed to endorse in this step.
+    #
+    # Returns true if the current user can endorse, false otherwise.
+    def current_user_can_endorse?
+      current_user && endorsements_enabled? && !endorsements_blocked?
+    end
+
+    # Public: Checks if the card for endorsements should be rendered.
+    #
+    # Returns true if the endorsements card should be rendered, false otherwise.
+    def show_endorsements_card?
+      endorsements_enabled?
+    end
+
+    # produces the path that should be POST to create an endorsement
+    def path_to_create_endorsement(resource, user_group = nil)
+      endorsements_path(resource_id: resource.to_gid.to_param,
+                        user_group_id: user_group&.id,
+                        authenticity_token: form_authenticity_token)
+    end
+
+    # Produces the path that should be DELETE to destroy an endorsement.
+    def path_to_destroy_endorsement(resource, user_group = nil)
+      endorsement_path(resource.to_gid.to_param,
+                       user_group_id: user_group&.id,
+                       authenticity_token: form_authenticity_token)
+    end
+
+    # Renders an identity for endorsement.
+    #
+    # Parameters:
+    #   resources  - The endorsable resource.
+    #   user       - The user that is endorsing at the end (mandatory).
+    #   user_group - The user_group on behalf of which the endorsement is being done (optional).
+    def render_endorsement_identity(resource, user, user_group = nil)
+      presenter = if user_group
+                    Decidim::UserGroupPresenter.new(user_group)
+                  else
+                    Decidim::UserPresenter.new(user)
+                  end
+      selected = resource.endorsed_by?(user, user_group)
+      http_method = selected ? :delete : :post
+      render partial: "decidim/endorsements/identity", locals:
+      { identity: presenter, selected: selected,
+        http_method: http_method,
+        create_url: path_to_create_endorsement(resource, user_group),
+        destroy_url: path_to_destroy_endorsement(resource, user_group) }
+    end
+  end
+end

data/app/helpers/decidim/filters_helper.rb

@@ -6,14 +6,24 @@ module Decidim
     # This method wraps everything in a div with class filters and calls
     # the form_for helper with a custom builder
     #
-    # filter - A filter object
-    # url    - A String with the URL to post the from. Self URL by default.
-    # block  - A block to be called with the form builder
+    # filter       - A filter object
+    # url          - A String with the URL to post the from. Self URL by default.
+    # html_options - Extra HTML options to be passed to form_for
+    # block        - A block to be called with the form builder
     #
     # Returns the filter resource form wrapped in a div
-    def filter_form_for(filter, url = url_for)
+    def filter_form_for(filter, url = url_for, html_options = {})
       content_tag :div, class: "filters" do
-        form_for filter, namespace: filter_form_namespace, builder: FilterFormBuilder, url: url, as: :filter, method: :get, remote: true, html: { id: nil } do |form|
+        form_for(
+          filter,
+          namespace: filter_form_namespace,
+          builder: FilterFormBuilder,
+          url: url,
+          as: :filter,
+          method: :get,
+          remote: true,
+          html: { id: nil }.merge(html_options)
+        ) do |form|
           yield form
         end
       end

data/app/helpers/decidim/followable_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A Helper for views with Followable resources.
+  module FollowableHelper
+    # Invokes the decidim/shared/follow_button partial.
+    def follow_button_for(model, large = nil)
+      render partial: "decidim/shared/follow_button.html", locals: { followable: model, large: large }
+    end
+  end
+end

data/app/helpers/decidim/layout_helper.rb

@@ -21,6 +21,7 @@ module Decidim
     # options - The Hash options used to customize the icon (default {}):
     #             :width  - The Number of width in pixels (optional).
     #             :height - The Number of height in pixels (optional).
+    #             :title - The title for the SVG element (optional, similar to alt for img)
     #             :aria_label - The String to set as aria label (optional).
     #             :aria_hidden - The Truthy value to enable aria_hidden (optional).
     #             :role - The String to set as the role (optional).
@@ -32,14 +33,17 @@ module Decidim
 
       html_properties["width"] = options[:width]
       html_properties["height"] = options[:height]
-      html_properties["aria-label"] = options[:aria_label]
-      html_properties["role"] = options[:role]
-      html_properties["aria-hidden"] = options[:aria_hidden]
+      html_properties["aria-label"] = options[:aria_label] || options[:"aria-label"] || options["aria-label"]
+      html_properties["role"] = options[:role] || "img"
+      html_properties["aria-hidden"] = options[:aria_hidden] || options[:"aria-hidden"] || options["aria-hidden"]
 
       html_properties["class"] = (["icon--#{name}"] + _icon_classes(options)).join(" ")
 
       content_tag :svg, html_properties do
-        content_tag :use, nil, "xlink:href" => "#{asset_path("decidim/icons.svg")}#icon-#{name}"
+        inner = content_tag :title, options["title"] || html_properties["aria-label"]
+        inner += content_tag :use, nil, role: options[:role], "href" => "#{asset_path("decidim/icons.svg")}#icon-#{name}"
+
+        inner
       end
     end
 
@@ -54,13 +58,21 @@ module Decidim
       classes = _icon_classes(options) + ["external-icon"]
 
       if path.split(".").last == "svg"
+        attributes = { class: classes.join(" ") }.merge(options)
         asset = Rails.application.assets_manifest.find_sources(path).first
-        asset.gsub("<svg ", "<svg class=\"#{classes.join(" ")}\" ").html_safe
+        asset.gsub("<svg ", "<svg#{tag_builder.tag_options(attributes)} ").html_safe
       else
         image_tag(path, class: classes.join(" "), style: "display: none")
       end
     end
 
+    # Allows to create role attribute according to accessibility rules
+    #
+    # Returns role attribute string if role option is specified
+    def role(options = {})
+      "role=\"#{options[:role]}\" " if options[:role]
+    end
+
     def _icon_classes(options = {})
       classes = options[:remove_icon_class] ? [] : ["icon"]
       classes += [options[:class]]
@@ -102,5 +114,11 @@ module Decidim
       css = current_organization.colors.each.map { |k, v| "--#{k}: #{v};--#{k}-rgb: #{v[1..2].hex},#{v[3..4].hex},#{v[5..6].hex};" }.join
       render partial: "layouts/decidim/organization_colors", locals: { css: css }
     end
+
+    private
+
+    def tag_builder
+      @tag_builder ||= ActionView::Helpers::TagHelper::TagBuilder.new(self)
+    end
   end
 end

data/app/helpers/decidim/map_helper.rb

@@ -16,10 +16,14 @@ module Decidim
       latitude = resource.latitude
       longitude = resource.longitude
 
+      address_text = resource.try(:address)
+      address_text ||= t("latlng_text", latitude: latitude, longitude: longitude, scope: "decidim.map.static")
+      map_service_brand = t("map_service_brand", scope: "decidim.map.static")
+
       map_url = "https://www.openstreetmap.org/?mlat=#{latitude}&mlon=#{longitude}#map=#{zoom}/#{latitude}/#{longitude}"
 
       link_to map_url, target: "_blank", rel: "noopener" do
-        image_tag decidim.static_map_path(sgid: resource.to_sgid.to_s)
+        image_tag decidim.static_map_path(sgid: resource.to_sgid.to_s), alt: "#{map_service_brand} - #{address_text}"
       end
     end
 
@@ -41,8 +45,17 @@ module Decidim
       end
 
       content = capture { yield }.html_safe
+      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")
+        link = link_to(t("skip_button", scope: "decidim.map.dynamic"), "#map_bottom", class: "skip")
+
+        sr_content + link
+      end
       content_tag :div, class: "row column" do
-        content_tag(:div, "", map_html_options) + content
+        map = content_tag(:div, "", map_html_options)
+        link = link_to("", "#", id: "map_bottom")
+
+        help + map + content + link
       end
     end
   end

data/app/helpers/decidim/markup_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Decidim
+  module MarkupHelper
+    def element_id(prefix)
+      "#{prefix}_#{SecureRandom.uuid}"
+    end
+  end
+end

data/app/helpers/decidim/messaging/conversation_helper.rb

@@ -3,25 +3,47 @@
 module Decidim
   module Messaging
     module ConversationHelper
+      #
+      # Generates a visualization of users for listing conversations threads
+      #
+      def username_list(users, shorten = false)
+        return users.pluck(:name).join(", ") unless shorten
+        return users.pluck(:name).join(", ") unless users.count > 3
+
+        "#{users.first(3).pluck(:name).join(", ")} + #{users.count - 3}"
+      end
+
       #
       # Links to the conversation between the current user and another user
       #
       def link_to_current_or_new_conversation_with(user, title = t("decidim.contact"))
-        link_to current_or_new_conversation_path_with(user), title: title do
-          icon "envelope-closed", aria_label: title, class: "icon--small"
+        conversation_path = current_or_new_conversation_path_with(user)
+        if conversation_path
+          link_to conversation_path, title: title do
+            icon "envelope-closed", aria_label: title, class: "icon--small"
+          end
+        else
+          content_tag :span, title: t("decidim.user_contact_disabled"), data: { tooltip: true } do
+            icon "envelope-closed", aria_label: title, class: "icon--small muted"
+          end
         end
       end
 
       #
       # Finds the right path to the conversation the current user and another
-      # user.
+      # user (the interlocutor).
       #
       # * If there's no current user, it returns to the login form path.
       #
-      # * If there's no prior existing conversation between the users, it
-      #   returns the new conversation form path.
+      # * If there's a prior existing conversation between the users it returns
+      #   the path to the existing conversation.
+      #
+      # * If there's no prior conversation between the users, it checks if the
+      #   the interlocutor accepts the current user to new conversation.
+      #   If affirmative, it returns the new conversation form path.
       #
-      # * Otherwise, it returns the path to the existing conversation.
+      # * Otherwise returns nil, meaning that no conversation can be established
+      #   with the interlocutor
       #
       # @param user [Decidim::User] The user to link to a conversation with
       #
@@ -35,7 +57,7 @@ module Decidim
 
         if conversation
           decidim_routes.conversation_path(conversation)
-        else
+        elsif user.accepts_conversation?(current_user)
           decidim_routes.new_conversation_path(recipient_id: user.id)
         end
       end
@@ -54,6 +76,38 @@ module Decidim
           conversation.participants.to_set == participants.to_set
         end
       end
+
+      #
+      # Links to the conversation between the current user and another users group
+      #
+      def current_or_new_conversation_path_with_multiple(users)
+        decidim_routes = Decidim::Core::Engine.routes.url_helpers
+        return decidim_routes.new_user_session_path unless user_signed_in?
+
+        participants = users.to_a.prepend(current_user)
+        conversation = conversation_between_multiple(participants)
+
+        if conversation
+          decidim_routes.conversation_path(conversation)
+        else
+          decidim_routes.new_conversation_path(recipient_id: users.pluck(:id))
+        end
+      end
+
+      #
+      # Finds the conversation between the given participants
+      #
+      # @param participants [Array<Decidim::User>] The participants to find a
+      #   conversation between.
+      #
+      # @return [Decidim::Messaging::Conversation]
+      def conversation_between_multiple(participants)
+        return if participants.to_set.length <= 1
+
+        UserConversations.for(participants.first).find do |conversation|
+          conversation.participants.to_set == participants.to_set
+        end
+      end
     end
   end
 end

data/app/helpers/decidim/orders_helper.rb

@@ -23,7 +23,16 @@ module Decidim
     # options - An optional hash of options
     #         * i18n_scope - The scope of the i18n translations
     def order_link(order, options = {})
-      link_to t("#{options[:i18n_scope]}.#{order}"), url_for(params.to_unsafe_h.merge(page: nil, order: order)), data: { order: order }, remote: true
+      i18n_scope = options.delete(:i18n_scope)
+
+      link_to(
+        t("#{i18n_scope}.#{order}"),
+        url_for(params.to_unsafe_h.merge(page: nil, order: order)),
+        {
+          data: { order: order },
+          remote: true
+        }.merge(options)
+      )
     end
   end
 end