decidim-core 0.29.2 → 0.30.0.rc1

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