decidim-core 0.29.2 → 0.30.0.rc2

data/lib/decidim/maintenance/taxonomy_importer.rb

@@ -0,0 +1,142 @@
+# 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
+      rescue ActiveRecord::RecordInvalid => e
+        abort "Error importing taxonomy item #{name} with parent #{parent.name} (#{e.message})"
+      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
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      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
+      rescue ActiveRecord::RecordInvalid => e
+        abort "Error importing filter #{data} for root taxonomy #{root.name} (#{e.message})"
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      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
+      rescue ActiveRecord::RecordInvalid => e
+        abort "Error creating taxonomy #{name} with parent #{association.new.parent.name[organization.default_locale]} (#{e.message})"
+      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,46 +49,7 @@ module Decidim
           private
 
           def language_code
-            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
-            }
+            I18n.locale.to_s
           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.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

data/lib/decidim/moderation_tools.rb

@@ -28,12 +28,16 @@ module Decidim
 
     # Public: fetches the participatory space of the resource's component or from the resource itself
     def participatory_space
-      @participatory_space ||= @reportable.component&.participatory_space || @reportable.try(:participatory_space)
+      @participatory_space ||= if reportable.class.respond_to?(:participatory_space?)
+                                 reportable
+                               else
+                                 reportable.component&.participatory_space || reportable.try(:participatory_space)
+                               end
     end
 
     # Public: updates the reported content for the moderation object associated with resource
     def update_reported_content!
-      moderation.update!(reported_content: @reportable.reported_searchable_content_text)
+      moderation.update!(reported_content: reportable.reported_searchable_content_text)
     end
 
     # Public: creates a new report for the given resource, having a basic set of options
@@ -54,6 +58,8 @@ module Decidim
 
     # Public: Broadcasts a notification to the author of the resource that has been hidden
     def send_notification_to_author
+      return if affected_users.blank?
+
       data = {
         event: "decidim.events.reports.resource_hidden",
         event_class: Decidim::ResourceHiddenEvent,
@@ -61,14 +67,13 @@ module Decidim
         extra: {
           report_reasons:
         },
-        affected_users: @reportable.try(:authors) || [@reportable.try(:normalized_author)]
+        affected_users:
       }
 
       Decidim::EventsManager.publish(**data)
     end
 
-    # Public: hides the resource
-    def hide!
+    def hide_with_admin_log!
       Decidim.traceability.perform_action!(
         "hide",
         moderation,
@@ -77,13 +82,32 @@ module Decidim
           reportable_type: @reportable.class.name
         }
       ) do
+        hide!
+      end
+    end
+
+    # Public: hides the resources
+    def hide!
+      Decidim.traceability.perform_action_without_log!(current_user) do
         @reportable.moderation.update!(hidden_at: Time.current)
         @reportable.try(:touch)
       end
+
+      if @reportable.is_a?(Decidim::Comments::Commentable)
+        @reportable.comment_threads.each do |comment|
+          Decidim::HideChildResourcesJob.perform_later(comment, @current_user.id)
+        end
+      end
+
+      send_notification_to_author
     end
 
     private
 
+    def affected_users
+      @affected_users ||= (@reportable.try(:authors) || [@reportable.try(:normalized_author)]).select { |author| author.is_a?(Decidim::User) }
+    end
+
     def report_reasons
       @reportable.moderation.reports.pluck(:reason).uniq
     end

data/lib/decidim/newsletter_encryptor.rb

@@ -14,7 +14,7 @@ module Decidim
 
     def self.crypt_data
       key = ActiveSupport::KeyGenerator.new("sent_at").generate_key(
-        Rails.application.secrets.secret_key_base, ActiveSupport::MessageEncryptor.key_len
+        Rails.application.secret_key_base, ActiveSupport::MessageEncryptor.key_len
       )
       ActiveSupport::MessageEncryptor.new(key)
     end

data/lib/decidim/paddable.rb

@@ -66,7 +66,7 @@ module Decidim
           return tokenizer.hex_digest(id)
         end
 
-        Digest::MD5.hexdigest("#{id}-#{Rails.application.secrets.secret_key_base}")
+        Digest::MD5.hexdigest("#{id}-#{Rails.application.secret_key_base}")
       end
 
       def build_pad_url(id)

data/lib/decidim/participable.rb

@@ -14,25 +14,25 @@ module Decidim
 
       def skip_space_slug?(method_name)
         [
-          "edit_#{underscored_name}_path".to_sym,
-          "edit_#{underscored_name}_url".to_sym,
-          "new_#{underscored_name}_path".to_sym,
-          "new_#{underscored_name}_url".to_sym,
-          "#{underscored_name}_path".to_sym,
-          "#{underscored_name}_url".to_sym,
-          "#{underscored_name.pluralize}_path".to_sym,
-          "#{underscored_name.pluralize}_url".to_sym
+          :"edit_#{underscored_name}_path",
+          :"edit_#{underscored_name}_url",
+          :"new_#{underscored_name}_path",
+          :"new_#{underscored_name}_url",
+          :"#{underscored_name}_path",
+          :"#{underscored_name}_url",
+          :"#{underscored_name.pluralize}_path",
+          :"#{underscored_name.pluralize}_url"
         ].include?(method_name)
       end
 
       def slug_param_name
-        "#{underscored_name}_slug".to_sym
+        :"#{underscored_name}_slug"
       end
 
       def mounted_params
         {
           :host => organization.host,
-          "#{underscored_name}_slug".to_sym => slug
+          :"#{underscored_name}_slug" => slug
         }
       end
 

data/lib/decidim/participatory_space_user.rb

@@ -37,6 +37,16 @@ module Decidim
         raise "Not implemented"
       end
 
+      def self.ransackable_attributes(auth_object = nil)
+        return [] unless auth_object&.admin?
+
+        %w(name nickname email invitation_accepted_at last_sign_in_at role)
+      end
+
+      def self.ransackable_associations(_auth_object = nil)
+        []
+      end
+
       def self.order_by_name
         includes(:user).order("decidim_users.name ASC")
       end

data/lib/decidim/private_download_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module PrivateDownloadHelper
+    def attach_archive(export_data, name, user)
+      private_exports = user.private_exports.build
+      private_exports.export_type = name
+      private_exports.file.attach(io: StringIO.open(FileZipper.new(export_data.filename(name), export_data.read).zip), filename: "#{name}.zip")
+      private_exports.expires_at = Decidim.download_your_data_expiry_time.from_now
+      private_exports.metadata = {}
+      private_exports.save!
+      private_exports.reload
+    end
+  end
+end