decidim-core 0.29.6 → 0.30.0.rc1

data/lib/decidim/maintenance/import_models/scope.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class Scope < ApplicationRecord
+        resource_models [
+          "Decidim::Assembly", "Decidim::ParticipatoryProcess", "Decidim::Conference", "Decidim::InitiativesTypeScope",
+          "Decidim::ActionLog",
+          "Decidim::Accountability::Result",
+          "Decidim::Budgets::Budget", "Decidim::Budgets::Project",
+          "Decidim::Debates::Debate",
+          "Decidim::Meetings::Meeting",
+          "Decidim::Proposals::CollaborativeDraft", "Decidim::Proposals::Proposal"
+        ]
+        participatory_space_models ["Decidim::Assembly", "Decidim::ParticipatoryProcess", "Decidim::Conference", "Decidim::Initiative"]
+
+        self.table_name = "decidim_scopes"
+
+        def self.root_taxonomy_name = "~ #{I18n.t("decidim.admin.titles.scopes")}"
+
+        belongs_to :parent,
+                   class_name: "Decidim::Maintenance::ImportModels::Scope",
+                   inverse_of: :children,
+                   optional: true
+
+        has_many :children,
+                 foreign_key: "parent_id",
+                 class_name: "Decidim::Maintenance::ImportModels::Scope",
+                 inverse_of: :parent
+
+        attr_writer :full_name
+
+        def full_name
+          return @full_name if defined?(@full_name)
+
+          @full_name ||= name.dup
+          @full_name[I18n.locale.to_s] = "#{parent.full_name[I18n.locale.to_s]} > #{@full_name[I18n.locale.to_s]}" if parent_ids.count > 2
+          @full_name
+        end
+
+        def parent_ids
+          @parent_ids ||= parent_id ? parent.parent_ids + [parent_id] : []
+        end
+
+        def all_names
+          names = parent_ids.map do |id|
+            Scope.find_by(id:).name[I18n.locale.to_s]
+          end + [name[I18n.locale.to_s]]
+
+          return names if names.count < 4
+
+          names[0..1] + [names[2..].join(" > ")]
+        end
+
+        def all_children
+          @all_children ||= children.map do |child|
+            [child] + child.all_children
+          end.flatten
+        end
+
+        def children_taxonomies
+          # next level is going to be too deep, we transform the children into siblings
+          return sibling_taxonomies if parent_ids.count.positive?
+
+          children.to_h { |child| [child.full_name[I18n.locale.to_s], child.taxonomies] }
+        end
+
+        def sibling_taxonomies
+          all_children.to_h do |child|
+            [
+              child.full_name[I18n.locale.to_s],
+              {
+                name: child.full_name,
+                origin: child.to_global_id.to_s,
+                children: {},
+                resources: child.resources
+              }
+            ]
+          end
+        end
+
+        def taxonomies
+          {
+            name:,
+            origin: to_global_id.to_s,
+            children: children_taxonomies,
+            resources:
+          }
+        end
+
+        def resources
+          Scope.resource_classes.each_with_object({}) do |klass, hash|
+            items = if klass.to_s == "Decidim::InitiativesTypeScope"
+                      klass.where(decidim_scopes_id: id)
+                    else
+                      klass.where(decidim_scope_id: id)
+                    end
+            hash.merge!(items.to_h { |resource| [resource.to_global_id.to_s, resource_name(resource)] })
+          end
+        end
+
+        def self.filter_item_for_space_manifest(participatory_space_manifests)
+          items = []
+          all_in_org.where(parent_id: nil).find_each do |scope|
+            items << [scope.name[I18n.locale.to_s]]
+            scope.all_children.map(&:all_names).each do |names|
+              items << names
+            end
+          end
+
+          {
+            participatory_space_manifests:,
+            name: root_taxonomy_name,
+            items:,
+            components: []
+          }
+        end
+
+        def self.filter_item_for_component(component, space)
+          return unless component.settings.respond_to?(:taxonomy_filters)
+
+          scopes_enabled = component.attributes.dig("settings", "global", "scopes_enabled")
+          scope_id = component.attributes.dig("settings", "global", "scope_id")
+          return unless scopes_enabled
+
+          scope = find_by(id: scope_id) || (space.scopes_enabled? && find_by(id: space.decidim_scope_id))
+          list = scope ? [scope] + scope.all_children : all
+
+          {
+            name: root_taxonomy_name,
+            internal_name: "#{root_taxonomy_name}: #{component.name[I18n.locale.to_s]}",
+            items: list.map(&:all_names),
+            components: [component.to_global_id.to_s]
+          }
+        end
+
+        def self.all_filters
+          manifests = []
+          filters = []
+          Scope.participatory_space_classes.each do |space_class|
+            manifests << space_class.to_s.split("::").last.underscore.pluralize
+            # 1 filter per participatory space as space_filter=true
+            # 1 filter per component as space_filter=false on those with scopes, suffix: "Component Name"
+            # Only for components with scopes
+            space_class.where(organization:).each do |space|
+              space.components.each do |component|
+                component_filter = filter_item_for_component(component, space)
+                filters << component_filter if component_filter
+              end
+            end
+          end
+          filters << filter_item_for_space_manifest(manifests)
+          filters
+        end
+
+        def self.all_taxonomies
+          all_in_org.where(parent_id: nil).to_h { |scope| [scope.name[I18n.locale.to_s], scope.taxonomies] }
+        end
+      end
+    end
+  end
+end

data/lib/decidim/maintenance/import_models.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class should not be imported automatically by the Decidim web app
+  # It holds utilities for maintenance tasks (such as importing taxonomies)
+  # and compatibility models that might not be longer present in the current Decidim version
+  module Maintenance
+    module ImportModels
+      autoload :ApplicationRecord, "decidim/maintenance/import_models/application_record"
+      autoload :ParticipatoryProcessType, "decidim/maintenance/import_models/participatory_process_type"
+      autoload :AssemblyType, "decidim/maintenance/import_models/assembly_type"
+      autoload :Scope, "decidim/maintenance/import_models/scope"
+      autoload :Area, "decidim/maintenance/import_models/area"
+      autoload :AreaType, "decidim/maintenance/import_models/area_type"
+      autoload :Category, "decidim/maintenance/import_models/category"
+      autoload :Categorization, "decidim/maintenance/import_models/categorization"
+    end
+  end
+end

data/lib/decidim/maintenance/taxonomy_importer.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    class TaxonomyImporter
+      def initialize(organization, roots)
+        @organization = organization
+        @roots = roots
+        @result = { taxonomy_map: {}, taxonomies_created: [], taxonomies_assigned: {}, filters_created: {}, components_assigned: {}, failed_resources: [], failed_components: [] }
+      end
+
+      attr_reader :organization, :roots, :result
+
+      def import!(&)
+        roots.each do |name, element|
+          root = find_taxonomy!(root_taxonomies, name)
+          element["taxonomies"].each do |item_name, taxonomy|
+            import_taxonomy_item(root, item_name, taxonomy)
+            yield "Taxonomy imported", item_name if block_given?
+          end
+          element["filters"].each do |filter|
+            import_filter(root, filter)
+            yield "Filter imported", filter["name"] if block_given?
+          end
+        end
+      end
+
+      private
+
+      def import_taxonomy_item(parent, name, item)
+        taxonomy = find_taxonomy!(parent.children, name)
+        taxonomy.update!(name: item["name"]) if item["name"].present?
+        result[:taxonomy_map][taxonomy.id] = item["origin"]
+
+        item["resources"].each do |object_id, _name|
+          apply_taxonomy_to_resource(object_id, taxonomy)
+        end
+        item["children"].each do |child_name, child|
+          import_taxonomy_item(taxonomy, child_name, child)
+        end
+      end
+
+      def apply_taxonomy_to_resource(object_id, taxonomy)
+        resource = GlobalID::Locator.locate(object_id)
+        return result[:failed_resources] << object_id unless resource
+
+        name = taxonomy.name[organization.default_locale]
+
+        begin
+          if resource.respond_to? :taxonomy
+            resource.update(decidim_taxonomy_id: taxonomy.id)
+          else
+            return if resource.taxonomies.include?(taxonomy)
+
+            resource.taxonomies << taxonomy
+          end
+          result[:taxonomies_assigned][name] ||= []
+          result[:taxonomies_assigned][name] << object_id unless result[:taxonomies_assigned][name].include?(object_id)
+        rescue ActiveRecord::RecordInvalid
+          result[:failed_resources] << object_id
+        end
+      end
+
+      def import_filter(root, data)
+        filter = find_taxonomy_filter!(root, data)
+
+        data["items"].each do |item_names|
+          taxonomy = root
+          item_names.each do |item_name|
+            taxonomy = find_taxonomy!(taxonomy.children, item_name)
+          end
+          next if filter.filter_items.exists?(taxonomy_item: taxonomy)
+
+          filter.filter_items.create!(taxonomy_item: taxonomy) do
+            result[:filters_created][filter.internal_name[organization.default_locale]] ||= []
+            result[:filters_created][filter.internal_name[organization.default_locale]] << item_names.join(" > ")
+          end
+        end
+
+        data["components"].each do |component_id|
+          component = GlobalID::Locator.locate(component_id)
+          if component
+            begin
+              component.update!(settings: { taxonomy_filters: [filter.id.to_s] })
+              result[:components_assigned][filter.internal_name[organization.default_locale]] ||= []
+              result[:components_assigned][filter.internal_name[organization.default_locale]] << component_id
+            rescue ActiveRecord::RecordInvalid
+              result[:failed_components] << component_id
+            end
+          else
+            result[:failed_components] << component_id
+          end
+        end
+      end
+
+      def find_taxonomy(association, name)
+        association.find_by("name->>? = ?", organization.default_locale, name)
+      end
+
+      def find_taxonomy!(association, name)
+        find_taxonomy(association, name) || create_taxonomy!(association, name)
+      end
+
+      def create_taxonomy!(association, name)
+        association.create!(name: { organization.default_locale => name }, organization:) do
+          result[:taxonomies_created] << name
+        end
+      end
+
+      def find_taxonomy_filter!(root_taxonomy, data)
+        name = data["internal_name"] || data["name"]
+        attributes = {
+          "participatory_space_manifests" => data["participatory_space_manifests"] || []
+        }
+        attributes["internal_name"] = { organization.default_locale => data["internal_name"] } if data["internal_name"]
+        attributes["name"] = { organization.default_locale => data["public_name"] } if data["public_name"]
+
+        find_taxonomy_filter(root_taxonomy, name:, participatory_space_manifests: data["participatory_space_manifests"]) || root_taxonomy.taxonomy_filters.create!(attributes)
+      end
+
+      def find_taxonomy_filter(root_taxonomy, name:, participatory_space_manifests:)
+        root_taxonomy.taxonomy_filters.all.detect do |filter|
+          filter.internal_name[organization.default_locale] == name && filter.participatory_space_manifests == participatory_space_manifests
+        end
+      end
+
+      def root_taxonomies
+        organization.taxonomies.roots
+      end
+    end
+  end
+end

data/lib/decidim/maintenance/taxonomy_plan.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    class TaxonomyPlan
+      def initialize(organization, models, importer: TaxonomyImporter)
+        @organization = organization
+        @models = models
+        @importer = importer
+      end
+
+      attr_reader :organization, :models, :importer
+
+      def import(data, &)
+        data["imported_taxonomies"].each do |model_name, taxonomies|
+          klass = importer.new(organization, taxonomies)
+          if block_given?
+            yield klass, model_name
+          else
+            klass.import!
+          end
+        end
+      end
+
+      def to_json(*_args, &)
+        I18n.with_locale(organization.default_locale) do
+          JSON.pretty_generate(to_h(&))
+        end
+      end
+
+      def to_h(&)
+        {
+          organization: {
+            id: organization.id,
+            locale: organization.default_locale,
+            host: organization.host,
+            name: translate(organization.name)
+          },
+          existing_taxonomies:,
+          imported_taxonomies: imported_taxonomies(&)
+        }
+      end
+
+      def imported_taxonomies
+        return @imported_taxonomies if defined?(@imported_taxonomies)
+
+        @imported_taxonomies = {}
+        models.map do |model|
+          yield model if block_given?
+          @imported_taxonomies[model.table_name] = model.with(organization).to_taxonomies
+        end
+        @imported_taxonomies
+      end
+
+      def existing_taxonomies
+        organization.taxonomies.roots.to_h do |root|
+          [
+            translate(root.name),
+            root.children.to_h do |taxonomy|
+              [
+                translate(taxonomy.name),
+                taxonomy.children.map do |child|
+                  translate(child.name)
+                end
+              ]
+            end
+          ]
+        end
+      end
+
+      private
+
+      def translate(translatable)
+        return translatable[organization.default_locale.to_s]
+      end
+    end
+  end
+end

data/lib/decidim/maintenance.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "decidim/maintenance/import_models"
+module Decidim
+  # This class should not be imported automatically by the Decidim web app
+  # It holds utilities for maintenance tasks (such as importing taxonomies)
+  # and compatibility models that might not be longer present in the current Decidim version
+  module Maintenance
+    autoload :TaxonomyImporter, "decidim/maintenance/taxonomy_importer"
+    autoload :TaxonomyPlan, "decidim/maintenance/taxonomy_plan"
+  end
+end

data/lib/decidim/map/autocomplete.rb

@@ -9,24 +9,68 @@ module Decidim
       # Provides all the necessary functionality to initialize the front-end
       # geocoding autocompletion functionality.
       class Builder < Decidim::Map::Frontend::Builder
-        # Displays the geocoding field element's markup for the view.
+        delegate :icon, :content_tag, :asset_pack_path, to: :template
+
+        # Renders the geocoding field element for the view. If the component supports
+        # geolocation (as determined by `show_my_location_button?`), the field will include
+        # a button allowing the user to use their current location to autofill the address.
+        # Otherwise, a standard geocoding input field is rendered without the location button.
         #
-        # @param object_name [String, Symbol] The name for the object for which
-        #   the field is generated for.
-        # @param method [String, Symbol] The method/property in the object that
-        #   the field is for.
-        # @param options [Hash] Extra options for the field.
-        # @return [String] The field element's markup.
+        # @param object_name [String, Symbol] The name of the object the field is being generated for.
+        # @param method [String, Symbol] The specific attribute or property of the object.
+        # @param options [Hash] Additional options for customizing the field's behavior and appearance.
+        # @return [String] The HTML markup for the geocoding field.
         def geocoding_field(object_name, method, options = {})
           options[:autocomplete] ||= "off"
-
           append_assets
+
+          if show_my_location_button?
+            geocoding_field_with_location_button(object_name, method, options)
+          else
+            geocoding_field_without_location_button(object_name, method, options)
+          end
+        end
+
+        private
+
+        def geocoding_field_with_location_button(object_name, method, options)
+          template.snippets.add(:decidim_geocoding_scripts, template.append_javascript_pack_tag("decidim_geocoding"))
+          template.snippets.add(:decidim_geocoding_styles, template.append_stylesheet_pack_tag("decidim_geocoding"))
+
+          template.content_tag(:div, class: "geocoding-container") do
+            template.text_field(
+              object_name,
+              method,
+              options.merge("data-decidim-geocoding" => view_options.to_json)
+            ) +
+              template.content_tag(:div, class: "input-group-button user-device-location") do
+                template.content_tag(:button, class: "button button__sm md:button__sm button__text-secondary", type: "button", data: {
+                                       input: "#{object_name}_#{method}",
+                                       latitude: "#{object_name}_latitude",
+                                       longitude: "#{object_name}_longitude",
+                                       error_no_location: I18n.t("errors.no_device_location", scope: "decidim.proposals.forms"),
+                                       error_unsupported: I18n.t("errors.device_not_supported", scope: "decidim.proposals.forms"),
+                                       url: Decidim::Core::Engine.routes.url_helpers.locate_path
+                                     }) do
+                  icon("map-pin-line", role: "img", "aria-hidden": true) + " #{I18n.t("use_my_location", scope: "decidim.proposals.forms")}"
+                end
+              end
+          end
+        end
+
+        def geocoding_field_without_location_button(object_name, method, options)
           template.text_field(
             object_name,
             method,
             options.merge("data-decidim-geocoding" => view_options.to_json)
           )
         end
+
+        def show_my_location_button?
+          return unless template.respond_to?(:current_component)
+
+          template.current_component.manifest_name.to_sym == :proposals
+        end
       end
 
       # This module will be included in the main application's form builder in

data/lib/decidim/map/dynamic_map.rb

@@ -71,7 +71,7 @@ module Decidim
           content = template.capture { yield }.html_safe if block_given?
 
           template.content_tag(:div, map_html_options) do
-            (content || "")
+            content || ""
           end
         end
 

data/lib/decidim/map/provider/dynamic_map/here.rb

@@ -49,7 +49,46 @@ module Decidim
           private
 
           def language_code
-            I18n.locale.to_s
+            primary = I18n.locale.to_s
+            secondary = primary.split("-")[0]
+            available_language_codes[primary] || available_language_codes[secondary] || ""
+          end
+
+          def available_language_codes
+            @available_language_codes ||= {
+              "ar" => "ara", # Arabic
+              "eu" => "baq", # Basque
+              "ca" => "cat", # Catalan
+              "zh" => "chi", # Chinese (simplified)
+              # "" => "cht", # Chinese (traditional)
+              "cs" => "cze", # Czech
+              "da" => "dan", # Danish
+              "nl" => "dut", # Dutch
+              "en" => "eng", # English
+              "fi" => "fin", # Finnish
+              "fr" => "fre", # French
+              "de" => "ger", # German
+              "ga" => "gle", # Gaelic
+              "el" => "gre", # Greek
+              "he" => "heb", # Hebrew
+              "hi" => "hin", # Hindi
+              "id" => "ind", # Indonesian
+              "it" => "ita", # Italian
+              "no" => "nor", # Norwegian
+              "fa" => "per", # Persian
+              "pl" => "pol", # Polish
+              "pt" => "por", # Portuguese
+              "ru" => "rus", # Russian
+              "si" => "sin", # Sinhalese
+              "es" => "spa", # Spanish
+              "sv" => "swe", # Swedish
+              "th" => "tha", # Thai
+              "tr" => "tur", # Turkish
+              "uk" => "ukr", # Ukrainian
+              "ur" => "urd", # Urdu
+              "vi" => "vie", # Vietnamese
+              "cy" => "wel" # Welsh
+            }
           end
         end
       end

data/lib/decidim/map/provider/geocoding/here.rb

@@ -29,9 +29,7 @@ module Decidim
             # Some of the matches that have "resultType" == "street" do not even
             # contain the street name unless they also have the "streets" key in
             # the "scoring" -> "fieldScore" attribute defined.
-            street_result = results.find do |r|
-              r.data["scoring"]["fieldScore"].has_key?("streets")
-            end
+            street_result = find_street_with_name(results)
             return street_result.address if street_result
 
             # Otherwise, sort the results based on their exact distances from
@@ -51,6 +49,14 @@ module Decidim
 
             results.first.address
           end
+
+          private
+
+          def find_street_with_name(results)
+            results.find do |r|
+              r.data && r.data["scoring"] && r.data["scoring"]["fieldScore"] && r.data["scoring"]["fieldScore"].has_key?("streets")
+            end
+          end
         end
       end
     end

data/lib/decidim/map/provider/static_map/here.rb

@@ -6,42 +6,8 @@ module Decidim
       module StaticMap
         # The static map utility class for the HERE maps service
         class Here < ::Decidim::Map::StaticMap
-          def url(latitude:, longitude:, options: {})
-            map_url = configuration.fetch(:url, nil)
-            return super unless map_url
-
-            return super unless map_url.include?("mia/v3")
-
-            w = options[:width] || Decidim::Map::StaticMap::DEFAULT_SIZE
-            h = options[:height] || Decidim::Map::StaticMap::DEFAULT_SIZE
-
-            params = {
-              apiKey: configuration[:api_key],
-              overlay: "point:#{latitude},#{longitude};icon=cp;size=large|#{latitude},#{longitude};style=circle;width=50m;color=%231B9D2C60"
-            }
-
-            URI.parse("#{map_url}:radius=90/#{w}x#{h}/png8").tap do |uri|
-              uri.query = URI.encode_www_form(params)
-            end.to_s
-          end
-
           # @See Decidim::Map::StaticMap#url_params
           def url_params(latitude:, longitude:, options: {})
-            ActiveSupport::Deprecation.warn(
-              <<~DEPRECATION.strip
-                Please use a V3 version HERE maps.
-                For further information, see:
-                https://www.here.com/docs/bundle/map-image-migration-guide-v3/page/README.html
-                Also make sure your Decidim.maps configurations are using the
-                up to date format.
-                You need to change:
-                  static_url = "https://image.maps.ls.hereapi.com/mia/1.6/mapview" if static_provider == "here" && static_url.blank?
-                to:
-                  static_url = "https://image.maps.hereapi.com/mia/v3/base/mc/overlay" if static_provider == "here"
-                in your config/initializers/decidim.rb file.
-              DEPRECATION
-            )
-
             params = {
               c: "#{latitude}, #{longitude}",
               z: options[:zoom] || Decidim::Map::StaticMap::DEFAULT_ZOOM,

data/lib/decidim/map.rb

@@ -73,12 +73,9 @@ module Decidim
       @utility_modules ||= {}
       @utility_modules[category] = mod
 
-      # Dynamically define the category method.
-      module_eval %{
-        def self.#{category}(options)    # def self.dynamic(options)
-          utility(:#{category}, options) #  utility(:dynamic, options)
-        end                              # end
-      }, __FILE__, __LINE__ - 4
+      define_singleton_method(category) do |options|
+        utility(category, options)
+      end
 
       mod
     end