decidim-core 0.29.4 → 0.30.0.rc1

data/lib/decidim/legacy_form_builder.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2015 Sébastien Gruhier (http://xilinus.com/) - MIT LICENSE
+#
+# This file has been copied and modified from https://github.com/sgruhier/foundation_rails_helper/blob/master/lib/foundation_rails_helper/form_builder.rb
+# We have done this so we can decouple Decidim from this dependency, which is not updated to Rails 7.1
+# We also plan to fully remove Foundation CSS legacy code in the future
+
+module Decidim
+  class LegacyFormBuilder < ActionView::Helpers::FormBuilder
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::OutputSafetyHelper
+    %w(file_field email_field text_field text_area url_field
+       number_field date_field datetime_field search_field color_field)
+      .each do |method_name|
+      define_method(method_name) do |*args|
+        attribute = args[0]
+        options = args[1] || {}
+        field(attribute, options) do |opts|
+          super(attribute, opts)
+        end
+      end
+    end
+
+    def label(attribute, text = nil, options = {})
+      if error?(attribute)
+        options[:class] ||= ""
+        options[:class] += " is-invalid-label"
+      end
+
+      super(attribute, (text || "").html_safe, options)
+    end
+
+    def radio_button(attribute, tag_value, options = {})
+      options[:label_options] ||= {}
+      label_options = options.delete(:label_options)&.merge!(value: tag_value)
+      label_text = options.delete(:label)
+      l = label(attribute, label_text, label_options) unless label_text == false
+      r = @template.radio_button(@object_name, attribute, tag_value,
+                                 objectify_options(options))
+
+      "#{r}#{l}".html_safe
+    end
+
+    def datetime_select(attribute, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        super(attribute, options, html_opts.merge(autocomplete: :off))
+      end
+    end
+
+    def date_select(attribute, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        super(attribute, options, html_opts.merge(autocomplete: :off))
+      end
+    end
+
+    def time_zone_select(attribute, priorities = nil, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        super(attribute, priorities, options,
+              html_opts.merge(autocomplete: :off))
+      end
+    end
+
+    def select(attribute, choices, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        html_options[:autocomplete] ||= :off
+        super(attribute, choices, options, html_opts)
+      end
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def collection_select(attribute, collection, value_method, text_method, options = {}, html_options = {})
+      field attribute, options, html_options do |html_opts|
+        html_options[:autocomplete] ||= :off
+        super(attribute, collection, value_method, text_method, options,
+              html_opts)
+      end
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def autocomplete(attribute, url, options = {})
+      field attribute, options do |opts|
+        opts.merge!(update_elements: opts[:update_elements],
+                    min_length: 0, value: object.send(attribute))
+        autocomplete_field(attribute, url, opts)
+      end
+    end
+
+    def submit(value = nil, options = {})
+      options[:class] ||= "button"
+      super
+    end
+
+    def error_for(attribute, options = {})
+      return unless error?(attribute)
+
+      class_name = "form-error is-visible"
+      class_name += " #{options[:class]}" if options[:class]
+
+      error_messages = object.errors[attribute].join(", ")
+      error_messages = error_messages.html_safe if options[:html_safe_errors]
+      content_tag(:small, error_messages,
+                  class: class_name.sub("is-invalid-input", ""))
+    end
+
+    private
+
+    def error?(attribute)
+      object.respond_to?(:errors) && object.errors[attribute].present?
+    end
+
+    def default_label_text(object, attribute)
+      return object.class.human_attribute_name(attribute) if object.class.respond_to?(:human_attribute_name)
+
+      attribute.to_s.humanize
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class ApplicationRecord < ActiveRecord::Base
+        self.abstract_class = true
+        @resource_classes = []
+        @participatory_space_classes = []
+
+        def self.with(organization)
+          @organization = organization
+          self
+        end
+
+        class << self
+          attr_reader :organization
+        end
+
+        attr_reader :organization
+
+        def self.all_in_org
+          where(decidim_organization_id: @organization.id)
+        end
+
+        def self.participatory_space_classes
+          @participatory_space_classes.map(&:safe_constantize).compact_blank
+        end
+
+        def self.participatory_space_models(classes)
+          @participatory_space_classes = classes
+        end
+
+        def self.resource_classes
+          @resource_classes.map(&:safe_constantize).compact_blank
+        end
+
+        def self.resource_models(classes)
+          @resource_classes = classes
+        end
+
+        def self.add_resource_class(klass)
+          @resource_classes ||= []
+          @resource_classes << klass
+        end
+
+        def resource_title(resource)
+          if resource.respond_to?(:full_name)
+            resource.full_name
+          elsif resource.respond_to?(:title)
+            resource.title
+          elsif resource.respond_to?(:name)
+            resource.name
+          else
+            resource.to_s
+          end
+        end
+
+        def resource_name(resource)
+          title = resource_title(resource)
+          if title.is_a?(Hash)
+            title[I18n.locale.to_s]
+          else
+            title
+          end
+        end
+
+        def self.all_taxonomies
+          raise NotImplementedError
+        end
+
+        def self.all_filters
+          raise NotImplementedError
+        end
+
+        def self.to_taxonomies
+          return [] unless all_taxonomies.any?
+
+          {
+            root_taxonomy_name => to_h
+          }
+        end
+
+        def self.to_h
+          {
+            taxonomies: all_taxonomies,
+            filters: all_filters
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class Area < ApplicationRecord
+        resource_models ["Decidim::Assembly", "Decidim::ParticipatoryProcess", "Decidim::Initiative", "Decidim::ActionLog"]
+        participatory_space_models ["Decidim::Assembly", "Decidim::ParticipatoryProcess", "Decidim::Initiative"]
+
+        self.table_name = "decidim_areas"
+        belongs_to :area_type, class_name: "Decidim::Maintenance::ImportModels::AreaType", inverse_of: :areas, optional: true
+
+        def self.root_taxonomy_name = "~ #{I18n.t("decidim.admin.titles.areas")}"
+
+        def resources
+          Area.resource_classes.each_with_object({}) do |klass, hash|
+            items = klass.where(decidim_area_id: id)
+            hash.merge!(items.to_h { |resource| [resource.to_global_id.to_s, resource_name(resource)] })
+          end
+        end
+
+        def taxonomies
+          {
+            name:,
+            origin: to_global_id.to_s,
+            children: {},
+            resources:
+          }
+        end
+
+        def self.filter_item_for_space_manifest(participatory_space_manifests)
+          items = all_in_org.map do |area|
+            if area.area_type
+              [
+                area.area_type.name[I18n.locale.to_s],
+                area.name[I18n.locale.to_s]
+              ]
+            else
+              [area.name[I18n.locale.to_s]]
+            end
+          end
+
+          {
+            participatory_space_manifests:,
+            name: root_taxonomy_name,
+            items:,
+            components: []
+          }
+        end
+
+        def self.plain_areas
+          all_in_org.where(area_type_id: nil).to_h { |area| [area.name[I18n.locale.to_s], area.taxonomies] }
+        end
+
+        def self.areas_with_type
+          AreaType.with(organization).all_in_org.to_h do |type|
+            [
+              type.plural[I18n.locale.to_s],
+              {
+                name: type.plural,
+                origin: type.to_global_id.to_s,
+                children: type.areas.to_h { |area| [area.name[I18n.locale.to_s], area.taxonomies] },
+                resources: {}
+              }
+            ]
+          end
+        end
+
+        def self.all_taxonomies
+          plain_areas.merge(areas_with_type)
+        end
+
+        def self.all_filters
+          manifests = Area.participatory_space_classes.map do |space_class|
+            space_class.to_s.split("::").last.underscore.pluralize
+          end
+          [filter_item_for_space_manifest(manifests)]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class AreaType < ApplicationRecord
+        self.table_name = "decidim_area_types"
+        has_many :areas, class_name: "Decidim::Maintenance::ImportModels::Area", inverse_of: :area_type, dependent: :nullify
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class AssemblyType < ApplicationRecord
+        self.table_name = "decidim_assemblies_types"
+
+        def self.root_taxonomy_name = "~ #{I18n.t("decidim.admin.titles.assemblies_types")}"
+
+        def self.participatory_space_manifests = ["assemblies"]
+
+        def name
+          title
+        end
+
+        def taxonomies
+          {
+            name:,
+            origin: to_global_id.to_s,
+            children: {},
+            resources:
+          }
+        end
+
+        def resources
+          Decidim::Assembly.where(decidim_assemblies_type_id: id).to_h do |process|
+            [process.to_global_id.to_s, process.title[I18n.locale.to_s]]
+          end
+        end
+
+        def self.all_taxonomies
+          all_in_org.to_h { |type| [type.name[I18n.locale.to_s], type.taxonomies] }
+        end
+
+        def self.all_filters
+          [
+            {
+              name: root_taxonomy_name,
+              participatory_space_manifests:,
+              items: all_in_org.map { |type| [type.name[I18n.locale.to_s]] },
+              components: []
+            }
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class Categorization < ApplicationRecord
+        self.table_name = "decidim_categorizations"
+
+        belongs_to :category, foreign_key: :decidim_category_id
+        belongs_to :categorizable, polymorphic: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class Category < ApplicationRecord
+        resource_models []
+        participatory_space_models ["Decidim::Assembly", "Decidim::ParticipatoryProcess", "Decidim::Conference", "Decidim::Initiative"]
+
+        self.table_name = "decidim_categories"
+        belongs_to :participatory_space, foreign_key: "decidim_participatory_space_id", foreign_type: "decidim_participatory_space_type", polymorphic: true
+        has_many :subcategories, foreign_key: "parent_id", class_name: "Decidim::Maintenance::ImportModels::Category", dependent: :destroy, inverse_of: :parent
+        belongs_to :parent, class_name: "Decidim::Maintenance::ImportModels::Category", inverse_of: :subcategories, optional: true
+        has_many :categorizations, foreign_key: "decidim_category_id", class_name: "Decidim::Maintenance::ImportModels::Categorization", dependent: :destroy
+
+        def self.root_taxonomy_name = "~ #{I18n.t("decidim.admin.categories.index.categories_title")}"
+
+        def invalid_categorization?(categorization)
+          return true if categorization.categorizable.nil?
+
+          return categorization.categorizable.participatory_space != participatory_space if categorization.categorizable.respond_to?(:participatory_space)
+          return categorization.categorizable.component.participatory_space != participatory_space if categorization.categorizable.respond_to?(:component)
+
+          false
+        end
+
+        def resources
+          categorizations.filter_map do |categorization|
+            next if invalid_categorization?(categorization)
+
+            [categorization.categorizable.to_global_id.to_s, resource_name(categorization.categorizable)]
+          end.to_h
+        end
+
+        def taxonomies
+          {
+            name:,
+            origin: to_global_id.to_s,
+            children: subcategories.to_h do |subcategory|
+              [
+                subcategory.name[I18n.locale.to_s],
+                subcategory.taxonomies
+              ]
+            end,
+            resources:
+          }
+        end
+
+        def self.children_taxonomies(participatory_space)
+          Category.where(participatory_space:, parent_id: nil).to_h do |category|
+            [
+              category.name[I18n.locale.to_s],
+              category.taxonomies
+            ]
+          end
+        end
+
+        def self.children_components(participatory_space)
+          participatory_space.components.filter_map do |component|
+            # skip components without taxonomies in settings
+            next unless component.settings.respond_to?(:taxonomy_filters)
+
+            component.to_global_id.to_s
+          end
+        end
+
+        def self.all_taxonomies
+          participatory_space_classes.each_with_object({}) do |klass, hash|
+            klass.where(organization:).each do |participatory_space|
+              next unless Category.where(participatory_space:, parent_id: nil).any?
+
+              name = "#{klass.model_name.human}: #{participatory_space.title[I18n.locale.to_s]}"
+              hash.merge!(name => {
+                            name: { I18n.locale.to_s => name },
+                            origin: participatory_space.to_global_id.to_s,
+                            resources: {},
+                            children: children_taxonomies(participatory_space)
+                          })
+            end
+          end
+        end
+
+        def self.all_filters
+          participatory_space_classes.each_with_object([]) do |klass, list|
+            klass.where(organization:).each do |participatory_space|
+              name = "#{klass.model_name.human}: #{participatory_space.title[I18n.locale.to_s]}"
+              components = children_components(participatory_space)
+              next unless components.any?
+
+              list << {
+                name: root_taxonomy_name,
+                internal_name: name,
+                items: Category.where(participatory_space:).map do |category|
+                  names = [name]
+                  names << category.parent.name[I18n.locale.to_s] if category.parent
+                  names << category.name[I18n.locale.to_s]
+                  names
+                end,
+                components:
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Maintenance
+    module ImportModels
+      class ParticipatoryProcessType < AssemblyType
+        self.table_name = "decidim_participatory_process_types"
+
+        def self.root_taxonomy_name = "~ #{I18n.t("decidim.admin.titles.participatory_process_types")}"
+
+        def self.participatory_space_manifests = ["participatory_processes"]
+
+        def resources
+          Decidim::ParticipatoryProcess.where(decidim_participatory_process_type_id: id).to_h do |process|
+            [process.to_global_id.to_s, process.title[I18n.locale.to_s]]
+          end
+        end
+      end
+    end
+  end
+end

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