decidim-core 0.20.1 → 0.23.1

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/filter_params_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A helper to allow only Decidim params to be added to a link.
+  # This is useful when we want to preserve the params from a search, ordering
+  # or paginating results. Using this, we can link back to where the user was
+  # at the show page.
+  module FilterParamsHelper
+    # Public: Builds a hash to be added to a _path or _url method with only
+    # allowed params.
+    #
+    # params - An optional Hash with the values of the params. It will try to
+    # get them from the controller if none are present.
+    #
+    # Returns a Hash.
+    def filter_link_params(params = nil)
+      return {} if params.blank? && (!respond_to?(:controller) || !controller.respond_to?(:params))
+
+      params = controller.params.to_unsafe_h if params.blank?
+
+      params.stringify_keys.slice(
+        "order",
+        "filter",
+        "page",
+        "per_page",
+        "locale"
+      )
+    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

@@ -9,41 +9,117 @@ module Decidim
     # resource - A geolocalizable resource
     # options - An optional hash of options (default: { zoom: 17 })
     #           * zoom: A number to represent the zoom value of the map
-    def static_map_link(resource, options = {})
+    def static_map_link(resource, options = {}, map_html_options = {}, &block)
       return unless resource.geocoded?
+      return unless map_utility_static || map_utility_dynamic
 
-      zoom = options[:zoom] || 17
-      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}"
+      if map_utility_static
+        map_url = map_utility_static.link(
+          latitude: resource.latitude,
+          longitude: resource.longitude,
+          options: options
+        )
 
-      link_to map_url, target: "_blank", rel: "noopener" do
-        image_tag decidim.static_map_path(sgid: resource.to_sgid.to_s)
+        # Check that the static map utility actually returns a URL before
+        # creating the static map utility. If it does not, the image would be
+        # otherwise blank.
+        if map_utility_static.url(latitude: resource.latitude, longitude: resource.longitude)
+          return link_to map_url, target: "_blank", rel: "noopener" do
+            image_tag decidim.static_map_path(sgid: resource.to_sgid.to_s), alt: "#{map_service_brand} - #{address_text}"
+          end
+        end
       end
+
+      # Fall back to the dynamic map utility in case static maps are not
+      # provided.
+      builder = map_utility_dynamic.create_builder(self, {
+        type: :static,
+        latitude: resource.latitude,
+        longitude: resource.longitude,
+        zoom: 15,
+        title: "#{map_service_brand} - #{address_text}",
+        link: map_url
+      }.merge(options))
+
+      unless snippets.any?(:map)
+        snippets.add(:map, builder.stylesheet_snippets)
+        snippets.add(:map, builder.javascript_snippets)
+
+        # This will display the snippets in the <head> part of the page.
+        snippets.add(:head, snippets.for(:map))
+      end
+
+      builder.map_element(
+        { class: "static-map", tabindex: "0" }.merge(map_html_options),
+        &block
+      )
     end
 
-    def dynamic_map_for(markers_data)
-      return if Decidim.geocoder.blank?
+    def dynamic_map_for(options_or_markers = {}, html_options = {}, &block)
+      return unless map_utility_dynamic
 
-      map_html_options = {
-        class: "google-map",
-        id: "map",
-        "data-markers-data" => markers_data.to_json
+      options = {
+        popup_template_id: "marker-popup"
       }
-
-      if Decidim.geocoder[:here_api_key]
-        map_html_options["data-here-api-key"] = Decidim.geocoder[:here_api_key]
+      if options_or_markers.is_a?(Array)
+        options[:markers] = options_or_markers
       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]
+        options = options.merge(options_or_markers)
+      end
+
+      builder = map_utility_dynamic.create_builder(self, options)
+
+      # The map snippets are stored to the snippets utility in order to ensure
+      # that they are only loaded once during each page load. In case they were
+      # loaded multiple times, the maps would break. We store the map assets to
+      # a special "map" snippets category in order to avoid displaying them
+      # multiple times. Then we inject them to the "head" category during the
+      # first load which will actually display them in the <head> section of the
+      # view.
+      #
+      # Ideally we would use Rails' native content_for here (which is exactly
+      # for this purpose) but unfortunately it does not work in the cells which
+      # also need to display maps.
+      unless snippets.any?(:map)
+        snippets.add(:map, builder.stylesheet_snippets)
+        snippets.add(:map, builder.javascript_snippets)
+
+        # This will display the snippets in the <head> part of the page.
+        snippets.add(:head, snippets.for(:map))
       end
 
-      content = capture { yield }.html_safe
+      map_html_options = { id: "map", class: "google-map" }.merge(html_options)
+
+      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 = builder.map_element(map_html_options, &block)
+        link = link_to("", "#", id: "map_bottom")
+
+        help + map + link
       end
     end
+
+    private
+
+    def map_utility_dynamic
+      @map_utility_dynamic ||= Decidim::Map.dynamic(
+        organization: current_organization
+      )
+    end
+
+    def map_utility_static
+      @map_utility_static ||= Decidim::Map.static(
+        organization: current_organization
+      )
+    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