decidim-core 0.29.1 → 0.30.0.rc1

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
@@ -42,6 +86,7 @@ module Decidim
           @autocomplete_utility ||= Decidim::Map.autocomplete(
             organization: @template.current_organization
           )
+
           return text_field(attribute, options) unless @autocomplete_utility
 
           # Decidim::Map::Autocomplete::Builder

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/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
@@ -68,7 +72,7 @@ module Decidim
     end
 
     # Public: hides the resource
-    def hide!
+    def hide_with_admin_log!
       Decidim.traceability.perform_action!(
         "hide",
         moderation,
@@ -77,6 +81,13 @@ 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

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,20 @@ 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
+
       private
 
       # Private: check if the process and the user have the same organization

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

data/lib/decidim/query_extensions.rb

@@ -10,22 +10,6 @@ module Decidim
     #
     # Returns nothing.
     def self.included(type)
-      type.field :participatory_processes,
-                 [Decidim::ParticipatoryProcesses::ParticipatoryProcessType],
-                 null: true,
-                 description: "Lists all participatory_processes" do
-        argument :filter, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputFilter, "This argument lets you filter the results", required: false
-        argument :order, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputSort, "This argument lets you order the results", required: false
-      end
-
-      type.field :participatory_process,
-                 Decidim::ParticipatoryProcesses::ParticipatoryProcessType,
-                 null: true,
-                 description: "Finds a participatory_process" do
-        argument :id, GraphQL::Types::ID, "The ID of the participatory space", required: false
-        argument :slug, String, "The slug of the participatory process", required: false
-      end
-
       type.field :component, Decidim::Core::ComponentInterface, null: true do
         description "Lists the components this space contains."
         argument :id, GraphQL::Types::ID, required: true, description: "The ID of the component to be found"
@@ -62,16 +46,6 @@ module Decidim
       end
     end
 
-    def participatory_processes(filter: {}, order: {})
-      manifest = Decidim.participatory_space_manifests.select { |m| m.name == :participatory_processes }.first
-      Decidim::Core::ParticipatorySpaceListBase.new(manifest:).call(object, { filter:, order: }, context)
-    end
-
-    def participatory_process(id: nil, slug: nil)
-      manifest = Decidim.participatory_space_manifests.select { |m| m.name == :participatory_processes }.first
-      Decidim::Core::ParticipatorySpaceFinderBase.new(manifest:).call(object, { id:, slug: }, context)
-    end
-
     def component(id: {})
       component = Decidim::Component.published.find_by(id:)
       component&.organization == context[:current_organization] ? component : nil

data/lib/decidim/record_encryptor.rb

@@ -53,54 +53,59 @@ module Decidim
         #   def name=(value)
         #     super(encrypt_value(value))
         #   end
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-
-          # def full_name
-          #   return @full_name_decrypted if instance_variable_defined?(:@full_name_decrypted)
-          #
-          #   encrypted_value = begin
-          #     if defined?(super)
-          #       super
-          #     elsif instance_variable_defined?(:@full_name)
-          #       @full_name
-          #     end
-          #   end
-          #   @full_name_decrypted = decrypt_value(encrypted_value)
-          # end
-          def #{attribute}
-            return @#{attribute}_decrypted if instance_variable_defined?(:@#{attribute}_decrypted)
-
-            encrypted_value = begin
-              if defined?(super)
-                super
-              elsif instance_variable_defined?(:@#{attribute})
-                @#{attribute}
-              end
-            end
-            @#{attribute}_decrypted = decrypt_#{method_suffix}(encrypted_value)
-          end
+        create_encrypted_getter(attribute, method_suffix)
+        create_encrypted_setter(attribute, method_suffix)
+      end
+
+      # def full_name
+      #   return @full_name_decrypted if instance_variable_defined?(:@full_name_decrypted)
+      #
+      #   encrypted_value = begin
+      #     if defined?(super)
+      #       super
+      #     elsif instance_variable_defined?(:@full_name)
+      #       @full_name
+      #     end
+      #   end
+      #   @full_name_decrypted = decrypt_value(encrypted_value)
+      # end
+      def create_encrypted_getter(attribute, method_suffix)
+        define_method(attribute) do
+          return instance_variable_get(:"@#{attribute}_decrypted") if instance_variable_defined?(:"@#{attribute}_decrypted")
+
+          encrypted_value = if defined?(super)
+                              super()
+                            elsif instance_variable_defined?(:"@#{attribute}")
+                              instance_variable_get(:"@#{attribute}")
+                            end
+
+          decrypted_value = send(:"decrypt_#{method_suffix}", encrypted_value)
+          instance_variable_set(:"@#{attribute}_decrypted", decrypted_value)
+        end
+      end
 
-          # def full_name=(value)
-          #   remove_instance_variable(:@full_name_decrypted) if instance_variable_defined?(:@full_name_decrypted)
-          #   encrypted_value = encrypt_value(value)
-          #
-          #   if defined?(super)
-          #     super(encrypted_value)
-          #   else
-          #     @full_name = encrypted_value
-          #   end
-          # end
-          def #{attribute}=(value)
-            remove_instance_variable(:@#{attribute}_decrypted) if instance_variable_defined?(:@#{attribute}_decrypted)
-            encrypted_value = encrypt_#{method_suffix}(value)
-
-            if defined?(super)
-              super(encrypted_value)
-            else
-              @#{attribute} = encrypted_value
-            end
+      # def full_name=(value)
+      #   remove_instance_variable(:@full_name_decrypted) if instance_variable_defined?(:@full_name_decrypted)
+      #   encrypted_value = encrypt_value(value)
+      #
+      #   if defined?(super)
+      #     super(encrypted_value)
+      #   else
+      #     @full_name = encrypted_value
+      #   end
+      # end
+      def create_encrypted_setter(attribute, method_suffix)
+        define_method("#{attribute}=") do |value|
+          remove_instance_variable(:"@#{attribute}_decrypted") if instance_variable_defined?(:"@#{attribute}_decrypted")
+
+          encrypted_value = send(:"encrypt_#{method_suffix}", value)
+
+          if defined?(super)
+            super(encrypted_value)
+          else
+            instance_variable_set(:"@#{attribute}", encrypted_value)
           end
-        RUBY
+        end
       end
     end
 

data/lib/decidim/resourceable.rb

@@ -50,6 +50,22 @@ module Decidim
         scope.where(id: from).or(scope.where(id: to))
       end
 
+      def linked_resources_from(resource_name, link_name, component_published: true)
+        scope = sibling_scope(resource_name, component_published:)
+
+        scope
+          .joins(:resource_links_from)
+          .where(decidim_resource_links: { name: link_name, to_id: id, to_type: self.class.name })
+      end
+
+      def linked_resources_to(resource_name, link_name, component_published: true)
+        scope = sibling_scope(resource_name, component_published:)
+
+        scope
+          .joins(:resource_links_to)
+          .where(decidim_resource_links: { name: link_name, from_id: id, from_type: self.class.name })
+      end
+
       # Builds an ActiveRecord::Relation in order to load all the resources
       # that are in the same parent as this model.
       #