decidim-core 0.22.0 → 0.23.0

data/app/helpers/decidim/check_boxes_tree_helper.rb

@@ -40,17 +40,10 @@ module Decidim
       end
     end
 
+    # Overwrite this method in your component helper to define
+    # origin values.
     def filter_origin_values
-      origin_values = []
-      origin_values << TreePoint.new("official", t("decidim.proposals.application_helper.filter_origin_values.official")) if component_settings.official_proposals_enabled
-      origin_values << TreePoint.new("citizens", t("decidim.proposals.application_helper.filter_origin_values.citizens"))
-      origin_values << TreePoint.new("user_group", t("decidim.proposals.application_helper.filter_origin_values.user_groups")) if current_organization.user_groups_enabled?
-      origin_values << TreePoint.new("meeting", t("decidim.proposals.application_helper.filter_origin_values.meetings"))
-
-      TreeNode.new(
-        TreePoint.new("", t("decidim.proposals.application_helper.filter_origin_values.all")),
-        origin_values
-      )
+      raise StandardError, "Not implemented"
     end
 
     def filter_categories_values
@@ -81,10 +74,26 @@ module Decidim
       )
     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 = current_participatory_space.scope.present? ? [current_participatory_space.scope] : current_participatory_space.scopes.top_level.includes(:scope_type, :children)
+      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
 
-      scopes_values = main_scopes.flat_map do |scope|
+    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)

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

@@ -87,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
 

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

@@ -9,42 +9,91 @@ 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?
-
-      zoom = options[:zoom] || 17
-      latitude = resource.latitude
-      longitude = resource.longitude
+      return unless map_utility_static || map_utility_dynamic
 
       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
+        )
+
+        # 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)
 
-      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}"
+        # 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
 
-      content = capture { yield }.html_safe
+      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
+
+      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")
@@ -52,11 +101,25 @@ module Decidim
         sr_content + link
       end
       content_tag :div, class: "row column" do
-        map = content_tag(:div, "", map_html_options)
+        map = builder.map_element(map_html_options, &block)
         link = link_to("", "#", id: "map_bottom")
 
-        help + map + content + link
+        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/orders_helper.rb

@@ -27,7 +27,12 @@ module Decidim
 
       link_to(
         t("#{i18n_scope}.#{order}"),
-        url_for(params.to_unsafe_h.merge(page: nil, order: order)),
+        url_for(params.to_unsafe_h.except(
+          "component_id",
+          "participatory_process_slug",
+          "assembly_slug",
+          "initiative_slug"
+        ).merge(page: nil, order: order)),
         {
           data: { order: order },
           remote: true

data/app/helpers/decidim/paginate_helper.rb

@@ -12,7 +12,9 @@ module Decidim
       # Kaminari uses url_for to generate the url, but this doesn't play nice with our engine system
       # and unless we remove these params they are added again as query string :(
       default_params = {
-        participatory_process_id: nil,
+        participatory_process_slug: nil,
+        assembly_slug: nil,
+        initiative_slug: nil,
         component_id: nil
       }
 

data/app/helpers/decidim/scopes_helper.rb

@@ -13,9 +13,9 @@ module Decidim
     #
     # Returns boolean.
     def has_visible_scopes?(resource)
-      resource.participatory_space.scopes_enabled? &&
+      resource.component.scopes_enabled? &&
         resource.scope.present? &&
-        resource.participatory_space.scope != resource.scope
+        resource.component.scope != resource.scope
     end
 
     # Retrieves the translated name and type for an scope.
@@ -35,7 +35,7 @@ module Decidim
     # form - FormBuilder object
     # name - attribute name
     # options       - An optional Hash with options:
-    # - checkboxes_on_top - Show checked picker values on top (default) or below the picker prompt
+    # - checkboxes_on_top - Show checked picker values on top (default) or below the picker prompt (only for multiple pickers)
     #
     # Returns nothing.
     def scopes_picker_field(form, name, root: false, options: { checkboxes_on_top: true })
@@ -64,7 +64,7 @@ module Decidim
     # Renders a scopes picker field in a filter form.
     # form - FilterFormBuilder object
     # name - attribute name
-    # checkboxes_on_top - Show picker values on top (default) or below the picker prompt
+    # checkboxes_on_top - Show picker values on top (default) or below the picker prompt (only for multiple pickers)
     #
     # Returns nothing.
     def scopes_picker_filter(form, name, checkboxes_on_top = true)

data/app/helpers/decidim/translations_helper.rb

@@ -54,6 +54,12 @@ module Decidim
       end
     end
 
-    module_function :multi_translation, :empty_translatable, :ensure_translatable
+    def translated_in_current_locale?(attribute)
+      return false if attribute.nil?
+
+      attribute[I18n.locale.to_s].present?
+    end
+
+    module_function :multi_translation, :empty_translatable, :ensure_translatable, :translated_in_current_locale?
   end
 end

data/app/jobs/decidim/machine_translation_fields_job.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This job is part of the machine translation flow. This one specifically
+  # delegates the arguments to the translation service, if any.
+  class MachineTranslationFieldsJob < ApplicationJob
+    queue_as :default
+
+    # Performs the job. It won't perform anything if the
+    # `Decidim.machine_translation_service` config is not set.
+    #
+    # resource - Any kind of `Decidim::TranslatableResource` model instance
+    # field_name - A Symbol representing the name of the field being translated
+    # field_value - A String with the value of the field to translate
+    # target_locale - A Symbol representing the target locale for the translation
+    # source_locale - A Symbol representing the source locale for the translation
+    def perform(resource, field_name, field_value, target_locale, source_locale)
+      klass = Decidim.machine_translation_service_klass
+      return unless klass
+
+      klass.new(
+        resource,
+        field_name,
+        field_value,
+        target_locale,
+        source_locale
+      ).translate
+    end
+  end
+end

data/app/jobs/decidim/machine_translation_resource_job.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This job is part of the machine translation flow. This one is fired every
+  # time a `Decidim::TranslatableResource` is created or updated. If any of the
+  # attributes defines as translatable is modified, then for each of those
+  # attributes this job will schedule a `Decidim::MachineTranslationFieldsJob`.
+  class MachineTranslationResourceJob < ApplicationJob
+    queue_as :default
+
+    # Performs the job.
+    #
+    # resource - Any kind of `Decidim::TranslatableResource` model instance
+    # previous_changes - A Hash with the set fo changes. This is intended to be
+    #   taken from `resource.previous_changes`, but we need to manually pass
+    #   them to the job because the value gets lost when serializing the
+    #   resource.
+    # source_locale - A Symbol representing the source locale for the translation
+    def perform(resource, previous_changes, source_locale)
+      return unless Decidim.machine_translation_service_klass
+
+      @resource = resource
+      @locales_to_be_translated = []
+      translatable_fields = @resource.class.translatable_fields_list.map(&:to_s)
+      translatable_fields.each do |field|
+        next unless @resource[field].is_a?(Hash) && previous_changes.keys.include?(field)
+
+        translated_locales = translated_locales_list(field)
+        remove_duplicate_translations(field, translated_locales) if @resource[field]["machine_translations"].present?
+
+        next unless default_locale_changed_or_translation_removed(previous_changes, field)
+
+        @locales_to_be_translated += pending_locales(translated_locales) if @locales_to_be_translated.blank?
+
+        @locales_to_be_translated.each do |target_locale|
+          MachineTranslationFieldsJob.perform_later(
+            resource,
+            field,
+            resource_field_value(
+              previous_changes,
+              field
+            ),
+            target_locale,
+            source_locale
+          )
+        end
+      end
+    end
+
+    def default_locale_changed_or_translation_removed(previous_changes, field)
+      default_locale = default_locale(@resource)
+      values = previous_changes[field]
+      old_value = values.first
+      new_value = values.last
+      return true unless old_value.is_a?(Hash)
+
+      return true if old_value[default_locale] != new_value[default_locale]
+
+      # In a case where the default locale isn't changed
+      # but a translation of a different locale is deleted
+      # We trigger a job to translate only for that locale
+      if old_value[default_locale] == new_value[default_locale]
+        locales_present = old_value.keys
+        locales_present.each do |locale|
+          @locales_to_be_translated << locale if old_value[locale] != new_value[locale] && new_value[locale] == ""
+        end
+      end
+
+      @locales_to_be_translated.present?
+    end
+
+    def resource_field_value(previous_changes, field)
+      values = previous_changes[field]
+      new_value = values.last
+      return new_value[default_locale(@resource)] if new_value.is_a?(Hash)
+
+      new_value
+    end
+
+    def default_locale(resource)
+      if resource.respond_to? :organization
+        resource.organization.default_locale.to_s
+      else
+        Decidim.available_locales.first.to_s
+      end
+    end
+
+    def translated_locales_list(field)
+      return nil unless @resource[field].is_a? Hash
+
+      translated_locales = []
+      existing_locales = @resource[field].keys - ["machine_translations"]
+      existing_locales.each do |locale|
+        translated_locales << locale if @resource[field][locale].present?
+      end
+
+      translated_locales
+    end
+
+    def remove_duplicate_translations(field, translated_locales)
+      machine_translated_locale = @resource[field]["machine_translations"].keys
+      unless (translated_locales & machine_translated_locale).nil?
+        (translated_locales & machine_translated_locale).each { |key| @resource[field]["machine_translations"].delete key }
+      end
+    end
+
+    def pending_locales(translated_locales)
+      available_locales = @resource.organization.available_locales.map(&:to_s) if @resource.respond_to? :organization
+      available_locales ||= Decidim.available_locales.map(&:to_s)
+      available_locales - translated_locales
+    end
+  end
+end