decidim-core 0.29.2 → 0.30.0.rc2

data/app/models/decidim/newsletter.rb

@@ -26,23 +26,23 @@ module Decidim
       sent_at.present?
     end
 
-    def sent_scopes_ids
-      extended_data["scope_ids"] || []
+    def sent_to_all_users?
+      extended_data["send_to_all_users"]
     end
 
-    def sent_scopes
-      @sent_scopes ||= organization.scopes.where(id: sent_scopes_ids)
+    def sent_to_verified_users?
+      extended_data["send_to_verified_users"]
     end
 
-    def sended_to_all_users?
-      extended_data["send_to_all_users"]
+    def sent_to_users_with_verification_types
+      extended_data["verification_types"]
     end
 
-    def sended_to_followers?
+    def sent_to_followers?
       extended_data["send_to_followers"]
     end
 
-    def sended_to_participants?
+    def sent_to_participants?
       extended_data["send_to_participants"]
     end
 
@@ -50,6 +50,10 @@ module Decidim
       extended_data["participatory_space_types"]
     end
 
+    def sent_to_private_members?
+      extended_data["send_to_private_members"]
+    end
+
     def template
       @template ||= Decidim::ContentBlock
                     .for_scope(:newsletter_template, organization:)

data/app/models/decidim/organization.rb

@@ -35,6 +35,8 @@ module Decidim
 
     has_many :templates, foreign_key: "decidim_organization_id", class_name: "Decidim::Templates::Template", dependent: :destroy if defined? Decidim::Templates
 
+    has_many :taxonomies, foreign_key: "decidim_organization_id", class_name: "Decidim::Taxonomy", inverse_of: :organization, dependent: :destroy
+
     # Users registration mode. Whether users can register or access the system. Does not affect users that access through Omniauth integrations.
     #  enabled: Users registration and sign in are enabled (default value).
     #  existing: Users cannot be registered in the system. Only existing users can sign in.
@@ -58,7 +60,7 @@ module Decidim
     has_one_attached :highlighted_content_banner_image
     validates_upload :highlighted_content_banner_image, uploader: Decidim::ImageUploader
 
-    has_one_attached :open_data_file
+    has_many_attached :open_data_files
 
     validate :unique_name
 
@@ -148,8 +150,10 @@ module Decidim
       !users_registration_mode_disabled?
     end
 
-    def open_data_file_path
-      "#{host}-open-data.zip"
+    def open_data_file_path(resource = nil)
+      return "#{host}-open-data.zip" if resource.nil?
+
+      "#{host}-open-data-#{resource}.csv"
     end
 
     def enabled_omniauth_providers

data/app/models/decidim/participatory_space_private_user.rb

@@ -5,15 +5,25 @@ module Decidim
   class ParticipatorySpacePrivateUser < ApplicationRecord
     include Decidim::DownloadYourData
     include ParticipatorySpaceUser
+    include Decidim::TranslatableResource
 
     belongs_to :privatable_to, polymorphic: true
 
+    translatable_fields :role
+
+    delegate :email, :name, to: :user
+
     scope :by_participatory_space, ->(privatable_to) { where(privatable_to_id: privatable_to.id, privatable_to_type: privatable_to.class.to_s) }
+    scope :published, -> { where(published: true) }
 
     def self.user_collection(user)
       where(decidim_user_id: user.id)
     end
 
+    def self.private_user_ids_for_participatory_spaces(spaces)
+      joins(:user).where(privatable_to: spaces).distinct.pluck(:decidim_user_id)
+    end
+
     def self.export_serializer
       Decidim::DownloadYourDataSerializers::DownloadYourDataParticipatorySpacePrivateUserSerializer
     end
@@ -26,6 +36,16 @@ module Decidim
       Arel.sql(%{("invitation_sent_at")::text})
     end
 
+    def self.ransackable_attributes(auth_object = nil)
+      return [] unless auth_object&.admin?
+
+      %w(name nickname email invitation_accepted_at last_sign_in_at invitation_sent_at role)
+    end
+
+    def self.ransackable_associations(_auth_object = nil)
+      %w(user)
+    end
+
     def target_space_association = :privatable_to
   end
 end

data/app/models/decidim/private_export.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  class PrivateExport < ApplicationRecord
+    belongs_to :attached_to, polymorphic: true
+
+    has_one_attached :file
+    validates :content_type, presence: true
+
+    before_validation :set_content_type_and_size, if: :attached?
+    delegate :attached?, to: :file
+
+    default_scope { order(created_at: :desc) }
+
+    def expired?
+      expires_at < Time.zone.now
+    end
+
+    def set_content_type_and_size
+      self.content_type = file.content_type
+      self.file_size = file.byte_size
+    end
+  end
+end

data/app/models/decidim/push_notification_message.rb

@@ -26,7 +26,7 @@ module Decidim
     end
 
     def url
-      EngineRouter.new("decidim", {}).public_send(:conversation_path, host: organization.host, id: @conversation)
+      EngineRouter.new("decidim", {}).conversation_path(host: organization.host, id: @conversation)
     end
 
     private

data/app/models/decidim/report.rb

@@ -5,7 +5,7 @@ module Decidim
   class Report < ApplicationRecord
     include Decidim::DownloadYourData
 
-    REASONS = %w(spam offensive does_not_belong hidden_during_block).freeze
+    REASONS = %w(spam offensive does_not_belong hidden_during_block parent_hidden).freeze
 
     belongs_to :moderation, foreign_key: "decidim_moderation_id", class_name: "Decidim::Moderation"
     belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"

data/app/models/decidim/scope.rb

@@ -76,6 +76,10 @@ module Decidim
     # Allow ransacker to search for a key in a hstore column (`name`.`en`)
     ransacker_i18n :name
 
+    def self.ransackable_attributes(_auth_object = nil)
+      %w(name id)
+    end
+
     private
 
     def forbid_cycles

data/app/models/decidim/share_token.rb

@@ -2,33 +2,63 @@
 
 module Decidim
   class ShareToken < ApplicationRecord
-    validates :token, presence: true, uniqueness: { scope: [:decidim_organization_id, :token_for_type, :token_for_id] }
+    include Decidim::Traceable
 
     belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
     belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
     belongs_to :token_for, foreign_type: "token_for_type", polymorphic: true
 
-    after_initialize :generate, :set_default_expiration
+    validates :token, presence: true, uniqueness: { scope: [:decidim_organization_id, :token_for_type, :token_for_id] }
+    # validates token no spaces or strange characters
+    validates :token, format: { with: /\A[a-zA-Z0-9_-]+\z/ }
+
+    after_initialize :generate
+
+    def self.log_presenter_class_for(_log)
+      Decidim::AdminLog::ShareTokenPresenter
+    end
 
-    def self.use!(token_for:, token:)
+    def self.use!(token_for:, token:, user: nil)
       record = find_by!(token_for:, token:)
-      record.use!
+      record.use!(user:)
     end
 
-    def use!
+    def use!(user: nil)
       return raise StandardError, "Share token '#{token}' for '#{token_for_type}' with id = #{token_for_id} has expired." if expired?
+      return raise StandardError, "Share token '#{token}' for '#{token_for_type}' with id = #{token_for_id} requires a registered user." if registered_only? && user.nil?
 
       update!(times_used: times_used + 1, last_used_at: Time.zone.now)
     end
 
     def expired?
-      expires_at.past?
+      expires_at.past? unless expires_at.nil?
     end
 
     def url
       token_for.shareable_url(self)
     end
 
+    def participatory_space
+      return token_for if token_for.try(:manifest).is_a?(Decidim::ParticipatorySpaceManifest)
+      return token_for.participatory_space if token_for.respond_to?(:participatory_space)
+
+      component&.participatory_space
+    end
+
+    def component
+      return token_for if token_for.is_a?(Decidim::Component)
+
+      token_for.component if token_for.respond_to?(:component)
+    end
+
+    def self.ransackable_attributes(_auth_object = nil)
+      %w(token expires_at last_used_at registered_only times_used)
+    end
+
+    def self.ransackable_associations(_auth_object = nil)
+      %w(organization token_for user)
+    end
+
     private
 
     def generate
@@ -39,9 +69,5 @@ module Decidim
         break if ShareToken.find_by(token:).blank?
       end
     end
-
-    def set_default_expiration
-      self.expires_at ||= 1.day.from_now
-    end
   end
 end

data/app/models/decidim/taxonomization.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Represents the link between a taxonomy and any taxonomizable entity.
+  class Taxonomization < ApplicationRecord
+    belongs_to :taxonomy,
+               class_name: "Decidim::Taxonomy",
+               counter_cache: :taxonomizations_count,
+               inverse_of: :taxonomizations
+
+    belongs_to :taxonomizable, polymorphic: true
+
+    validate :prevent_root_taxonomization
+
+    private
+
+    def prevent_root_taxonomization
+      return unless taxonomy.root?
+
+      errors.add(:taxonomy, :invalid)
+    end
+  end
+end

data/app/models/decidim/taxonomy.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Represents a hierarchical classification used to organize various entities within the system.
+  # Taxonomies are primarily used to categorize and manage different aspects of participatory spaces,
+  # such as proposals, assemblies, and other components, within an organization.
+  class Taxonomy < ApplicationRecord
+    include Decidim::TranslatableResource
+    include Decidim::FilterableResource
+    include Decidim::Traceable
+
+    before_create :set_default_weight
+    before_validation :update_part_of, on: [:update, :create]
+    after_create_commit :create_part_of
+
+    translatable_fields :name
+
+    belongs_to :organization,
+               foreign_key: "decidim_organization_id",
+               class_name: "Decidim::Organization",
+               inverse_of: :taxonomies
+
+    belongs_to :parent,
+               class_name: "Decidim::Taxonomy",
+               counter_cache: :children_count,
+               inverse_of: :children,
+               optional: true
+
+    has_many :children,
+             foreign_key: "parent_id",
+             class_name: "Decidim::Taxonomy",
+             inverse_of: :parent,
+             dependent: :destroy
+
+    has_many :taxonomizations, class_name: "Decidim::Taxonomization", dependent: :destroy
+    has_many :taxonomy_filters, foreign_key: "root_taxonomy_id", class_name: "Decidim::TaxonomyFilter", dependent: :destroy
+    has_many :taxonomy_filter_items, foreign_key: "taxonomy_item_id", class_name: "Decidim::TaxonomyFilterItem", dependent: :destroy
+
+    validates :name, presence: true
+    validates :weight, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
+    validate :validate_max_children_levels
+    validate :forbid_cycles
+
+    default_scope { order(:weight) }
+    scope :for, ->(organization) { where(organization:) }
+    scope :roots, -> { where(parent_id: nil) }
+    scope :non_roots, -> { where.not(parent_id: nil) }
+
+    ransacker_i18n :name
+
+    scope :search_by_name, lambda { |name|
+      where("name ->> ? ILIKE ?", I18n.locale.to_s, "%#{name}%")
+    }
+
+    scope :part_of, lambda { |id|
+      where("part_of @> ARRAY[?]", id.to_i)
+    }
+
+    def self.log_presenter_class_for(_log)
+      Decidim::AdminLog::TaxonomyPresenter
+    end
+
+    def self.ransackable_scopes(_auth_object = nil)
+      [:search_by_name, :part_of]
+    end
+
+    def self.ransackable_attributes(_auth_object = nil)
+      %w(id name parent_id part_of)
+    end
+
+    def self.ransackable_associations(_auth_object = nil)
+      %w(children)
+    end
+
+    def translated_name
+      Decidim::TaxonomyPresenter.new(self).translated_name
+    end
+
+    def root_taxonomy
+      @root_taxonomy ||= root? ? self : parent.root_taxonomy
+    end
+
+    def parent_ids
+      @parent_ids ||= part_of.excluding(id)
+    end
+
+    def root? = parent_id.nil?
+
+    # this might change in the future if we want to prevent the deletion of taxonomies with associated resources
+    def removable?
+      true
+    end
+
+    def all_children
+      @all_children ||= Decidim::Taxonomy.non_roots.part_of(id).reorder(Arel.sql("array_length(part_of, 1) ASC"), "parent_id ASC", "weight ASC")
+    end
+
+    def reset_all_counters
+      Taxonomy.reset_counters(id, :children_count, :taxonomizations_count, :taxonomy_filters_count, :taxonomy_filter_items_count)
+    end
+
+    private
+
+    def set_default_weight
+      return if weight.present?
+
+      self.weight = Taxonomy.where(parent_id:).count
+    end
+
+    def forbid_cycles
+      return unless parent_id
+
+      errors.add(:parent_id, :invalid) if parent.part_of.include?(id)
+    end
+
+    def create_part_of
+      build_part_of
+      save if changed?
+    end
+
+    def update_part_of
+      build_part_of
+    end
+
+    def build_part_of
+      if parent
+        part_of.clear.append(id).concat(parent.reload.part_of)
+      else
+        part_of.clear.append(id)
+      end
+    end
+
+    def validate_max_children_levels
+      return unless parent_id
+
+      errors.add(:base, :invalid) if parent_ids.size > 3
+    end
+  end
+end

data/app/models/decidim/taxonomy_filter.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Represents the association between a taxonomy and a filterable entity within the system.
+  class TaxonomyFilter < ApplicationRecord
+    include Decidim::TranslatableResource
+    include Decidim::Traceable
+
+    translatable_fields :name, :internal_name
+
+    belongs_to :root_taxonomy,
+               class_name: "Decidim::Taxonomy",
+               counter_cache: :filters_count,
+               inverse_of: :taxonomy_filters
+
+    has_many :filter_items,
+             class_name: "Decidim::TaxonomyFilterItem",
+             inverse_of: :taxonomy_filter,
+             dependent: :destroy
+
+    validate :root_taxonomy_is_root
+    validate :space_manifest_is_registered
+
+    scope :for_manifest, ->(space_manifest) { where("? = ANY(participatory_space_manifests)", space_manifest) }
+    scope :space_filters, -> { where.not(participatory_space_manifests: []) }
+    # filters for the organization
+    scope :for, ->(organization) { joins(:root_taxonomy).where(decidim_taxonomies: { decidim_organization_id: organization.id }) }
+
+    delegate :organization, to: :root_taxonomy
+    delegate :translated_name, :translated_internal_name, to: :presenter
+
+    def presenter
+      Decidim::TaxonomyFilterPresenter.new(self)
+    end
+
+    # Returns the presenter class for this log.
+    #
+    # log - A Decidim::Log instance.
+    #
+    # Returns a Decidim::AdminLog::TaxonomyFilterPresenter class
+    def self.log_presenter_class_for(_log)
+      Decidim::AdminLog::TaxonomyFilterPresenter
+    end
+
+    # Public name for this filter, defaults to the root taxonomy name.
+    def name
+      return root_taxonomy&.name if super&.compact_blank.blank?
+
+      super
+    end
+
+    # Internal name for this filter, defaults to the root taxonomy name.
+    def internal_name
+      return root_taxonomy&.name if super&.compact_blank.blank?
+
+      super
+    end
+
+    # Components that have this taxonomy filter enabled.
+    def components
+      @components ||= Decidim::Component.where("(settings->'global'->'taxonomy_filters') @> ?", "\"#{id}\"")
+    end
+
+    def filter_taxonomy_ids
+      @filter_taxonomy_ids ||= filter_items.map(&:taxonomy_item_id)
+    end
+
+    # A memoized taxonomy tree hash filtered according to the filter_items
+
+    # that respects the order given by the taxonomies table.
+    # The returned hash structure is:
+    # {
+    #  _object_id_ => {
+    #    taxonomy: _object_,
+    #    children: {
+    #        _sub_object_id_: {
+    #          taxonomy: _sub_object_,
+    #          children: {
+    #    ...
+    # }
+    # @returns [Hash] a hash with the taxonomy tree structure.
+    def taxonomies
+      @taxonomies ||= root_taxonomy
+                      .all_children
+                      .where(id: filter_taxonomy_ids)
+                      .each_with_object({}) do |taxonomy, tree|
+        insert_child(taxonomy, tree)
+      end
+    end
+
+    def update_components_count
+      update(components_count: components.count)
+    end
+
+    def reset_all_counters
+      Decidim::TaxonomyFilter.reset_counters(id, :filter_items_count)
+      update_components_count
+    end
+
+    private
+
+    def insert_child(taxonomy, tree)
+      return if tree[taxonomy.id]
+
+      if (parent = find_parent(taxonomy, tree))
+        insert_child(taxonomy, parent[:children])
+      else
+        tree[taxonomy.id] = { taxonomy:, children: {} }
+      end
+    end
+
+    def find_parent(taxonomy, tree)
+      tree[taxonomy.parent_id].presence ||
+        tree.values.detect { |v| find_parent(taxonomy, v[:children]) }
+    end
+
+    def root_taxonomy_is_root
+      return if root_taxonomy&.root?
+
+      errors.add(:root_taxonomy, :invalid)
+    end
+
+    def space_manifest_is_registered
+      available_manifests = Decidim.participatory_space_manifests.map(&:name)
+      return if (participatory_space_manifests.map(&:to_sym) - available_manifests).empty?
+
+      errors.add(:participatory_space_manifests, :invalid)
+    end
+  end
+end

data/app/models/decidim/taxonomy_filter_item.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Represents the association between a taxonomy and a filterable entity within the system.
+  class TaxonomyFilterItem < ApplicationRecord
+    belongs_to :taxonomy_filter,
+               class_name: "Decidim::TaxonomyFilter",
+               counter_cache: :filter_items_count,
+               inverse_of: :filter_items
+
+    belongs_to :taxonomy_item,
+               class_name: "Decidim::Taxonomy",
+               counter_cache: :filter_items_count,
+               inverse_of: :taxonomy_filter_items
+
+    validate :taxonomy_item_is_not_root
+    validate :taxonomy_item_is_child_of_taxonomy_filter_root
+
+    private
+
+    def taxonomy_item_is_not_root
+      return unless taxonomy_item&.root?
+
+      errors.add(:taxonomy_item, :invalid)
+    end
+
+    def taxonomy_item_is_child_of_taxonomy_filter_root
+      return if taxonomy_item&.root_taxonomy == taxonomy_filter&.root_taxonomy
+
+      errors.add(:taxonomy_item, :invalid)
+    end
+  end
+end

data/app/models/decidim/user.rb

@@ -35,6 +35,7 @@ module Decidim
     has_many :access_grants, class_name: "Doorkeeper::AccessGrant", foreign_key: :resource_owner_id, dependent: :destroy
     has_many :access_tokens, class_name: "Doorkeeper::AccessToken", foreign_key: :resource_owner_id, dependent: :destroy
     has_many :reminders, foreign_key: "decidim_user_id", class_name: "Decidim::Reminder", dependent: :destroy
+    has_many :private_exports, class_name: "Decidim::PrivateExport", dependent: :destroy, inverse_of: :attached_to, as: :attached_to
 
     validates :name, presence: true, unless: -> { deleted? }
     validates :nickname,
@@ -45,6 +46,7 @@ module Decidim
     validates :locale, inclusion: { in: :available_locales }, allow_blank: true
     validates :tos_agreement, acceptance: true, allow_nil: false, on: :create
     validates :tos_agreement, acceptance: true, if: :user_invited?
+    validates :tos_agreement, acceptance: true, if: :ephemeral?
     validates :email, :nickname, uniqueness: { scope: :organization }, unless: -> { deleted? || managed? || nickname.blank? }
 
     validate :all_roles_are_valid
@@ -59,25 +61,13 @@ module Decidim
     scope :officialized, -> { where.not(officialized_at: nil) }
     scope :not_officialized, -> { where(officialized_at: nil) }
 
-    scope :interested_in_scopes, lambda { |scope_ids|
-      actual_ids = scope_ids.select(&:presence)
-      if actual_ids.count.positive?
-        ids = actual_ids.map(&:to_i).join(",")
-        where(Arel.sql("extended_data->'interested_scopes' @> ANY('{#{ids}}')").to_s)
-      else
-        # Do not apply the scope filter when there are scope ids available. Note
-        # that the active record scope must always return an active record
-        # collection.
-        self
-      end
-    }
-
     scope :org_admins_except_me, ->(user) { where(organization: user.organization, admin: true).where.not(id: user.id) }
 
+    scope :ephemeral, -> { where("extended_data @> ?", Arel.sql({ ephemeral: true }.to_json)) }
+
     attr_accessor :newsletter_notifications
 
     searchable_fields({
-                        # scope_id: :decidim_scope_id,
                         organization_id: :decidim_organization_id,
                         A: :name,
                         B: :nickname,
@@ -195,7 +185,7 @@ module Decidim
     end
 
     def tos_accepted?
-      return true if managed
+      return true if managed && !ephemeral?
       return false if accepted_tos_version.nil?
 
       # For some reason, if we do not use `#to_i` here we get some
@@ -217,14 +207,6 @@ module Decidim
       ImpersonationLog.active.exists?(user: self)
     end
 
-    def interested_scopes_ids
-      extended_data["interested_scopes"] || []
-    end
-
-    def interested_scopes
-      @interested_scopes ||= organization.scopes.where(id: interested_scopes_ids)
-    end
-
     def user_name
       extended_data["user_name"] || name
     end
@@ -278,6 +260,10 @@ module Decidim
       false
     end
 
+    def ephemeral?
+      extended_data["ephemeral"]
+    end
+
     def after_confirmation
       return unless organization.send_welcome_notification?
 

data/app/models/decidim/user_base_entity.rb

@@ -65,6 +65,18 @@ module Decidim
       Decidim::UserBaseEntity.joins(:follows).where(decidim_follows: { user: self }).blocked.exists?
     end
 
+    def self.ransackable_attributes(auth_object = nil)
+      base = %w(name email nickname last_sign_in_at)
+
+      return base unless auth_object&.admin?
+
+      base + %w(invitation_sent_at invitation_accepted_at officialized_at)
+    end
+
+    def self.ransackable_associations(_auth_object = nil)
+      []
+    end
+
     private
 
     def only_public(klass, ids)