decidim-core 0.27.8 → 0.28.0.rc4

data/app/helpers/decidim/user_profile_helper.rb

@@ -14,14 +14,9 @@ module Decidim
     #
     # Returns a String with the menu tab.
     def user_profile_tab(text, link, options = {})
-      aria = {}
-      cls = %w(tabs-title)
-      if is_active_link?(link, (options[:aria_link_type] || :inclusive))
-        cls << "is-active"
-        aria[:current] = "page"
-      end
+      active = is_active_link?(link, (options[:aria_link_type] || :inclusive))
 
-      content_tag(:li, class: cls.join(" "), aria: aria) do
+      content_tag(:li, class: "tabs-title#{active ? " is-active" : nil}") do
         link_to(text, link, options)
       end
     end

data/app/helpers/decidim/view_hooks_helper.rb

@@ -5,14 +5,11 @@ module Decidim
   module ViewHooksHelper
     # Public: Renders all hooks registered as `hook_name`.
     #
-    #   Note: We're passing a deep copy of the view context to allow
-    #   us to extend it without polluting the original view context
-    #
     # @param hook_name [Symbol] representing the name of the hook.
     #
     # @return [String] an HTML safe String
     def render_hook(hook_name)
-      Decidim.view_hooks.render(hook_name, deep_dup)
+      Decidim.view_hooks.render(hook_name, self)
     end
   end
 end

data/app/jobs/decidim/email_notifications_digest_generator_job.rb

@@ -8,10 +8,10 @@ module Decidim
       user = Decidim::User.find_by(id: user_id)
       return if user.blank?
 
-      should_notify = force || NotificationsDigestSendingDecider.must_notify?(user, time: time)
+      should_notify = force || NotificationsDigestSendingDecider.must_notify?(user, time:)
       return unless should_notify
 
-      notification_ids = user.notifications.try(frequency, time: time).pluck(:id)
+      notification_ids = user.notifications.try(frequency, time:).pluck(:id)
       return if notification_ids.blank?
 
       NotificationsDigestMailer.digest_mail(user, notification_ids).deliver_later

data/app/jobs/decidim/event_publisher_job.rb

@@ -36,8 +36,8 @@ module Decidim
     # event to decide based on the params.
     #
     # It returns false when the resource or any element in the chain is a
-    # `Decidim::Publicable` and it isn't published or participatory_space
-    # is a `Decidim::Participable` and the user can't participate.
+    # `Decidim::Publicable` and it is not published or participatory_space
+    # is a `Decidim::Participable` and the user cannot participate.
     def notifiable?
       return false if resource.is_a?(Decidim::Publicable) && !resource.published?
       return false if participatory_space.is_a?(Decidim::Publicable) && !participatory_space&.published?

data/app/jobs/decidim/export_job.rb

@@ -4,17 +4,20 @@ module Decidim
   class ExportJob < ApplicationJob
     queue_as :exports
 
-    def perform(user, component, name, format, resource_id = nil)
+    # rubocop:disable Metrics/ParameterLists
+    def perform(user, component, name, format, resource_id = nil, filters = nil)
       export_manifest = component.manifest.export_manifests.find do |manifest|
         manifest.name == name.to_sym
       end
 
       collection = export_manifest.collection.call(component, user, resource_id)
+      collection = collection.ransack(filters).result if collection.respond_to?(:ransack) && filters
       serializer = export_manifest.serializer
 
       export_data = Decidim::Exporters.find_exporter(format).new(collection, serializer).export
 
       ExportMailer.export(user, name, export_data).deliver_now
     end
+    # rubocop:enable Metrics/ParameterLists
   end
 end

data/app/jobs/decidim/find_and_update_descendants_job.rb

@@ -39,7 +39,7 @@ module Decidim
         next if klass.blank?
         next if klass.column_names.exclude? "decidim_component_id"
 
-        ary << klass.where(component: component).to_a
+        ary << klass.where(component:).to_a
       end
 
       ary

data/app/jobs/decidim/hide_all_created_by_author_job.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  class HideAllCreatedByAuthorJob < ApplicationJob
+    queue_as :user_report
+
+    def perform(resource:, extra: {})
+      return unless extra.fetch(:hide, false)
+
+      @author = resource.reload
+
+      base_query.find_each do |content|
+        hide_content(content, extra[:event_author], extra[:justification])
+      end
+    end
+
+    protected
+
+    attr_reader :author
+
+    private
+
+    def hide_content(content, current_user, justification)
+      tool = Decidim::ModerationTools.new(content, current_user)
+      tool.update_reported_content!
+      tool.create_report!(reason: "hidden_during_block", details: justification)
+      tool.update_report_count!
+      tool.hide!
+    end
+  end
+end

data/app/jobs/decidim/machine_translation_fields_job.rb

@@ -6,7 +6,7 @@ module Decidim
   class MachineTranslationFieldsJob < ApplicationJob
     queue_as :translations
 
-    # Performs the job. It won't perform anything if the
+    # Performs the job. It will not perform anything if the
     # `Decidim.machine_translation_service` config is not set.
     #
     # resource - Any kind of `Decidim::TranslatableResource` model instance

data/app/jobs/decidim/machine_translation_resource_job.rb

@@ -60,7 +60,7 @@ module Decidim
 
       return true if old_value[default_locale] != new_value[default_locale]
 
-      # In a case where the default locale isn't changed
+      # In a case where the default locale is not changed
       # but a translation of a different locale is deleted
       # We trigger a job to translate only for that locale
       if old_value[default_locale] == new_value[default_locale]

data/app/jobs/decidim/machine_translation_save_job.rb

@@ -2,13 +2,13 @@
 
 module Decidim
   # This job is used by machine translation services to store the result of
-  # a field translation. This way services don't need to care about how to
+  # a field translation. This way services do not need to care about how to
   # save it and also enables storing translations asynchronously when the
   # translation service returns the translated text in a webhook.
   class MachineTranslationSaveJob < ApplicationJob
     queue_as :translations
 
-    # Performs the job. It won't perform anything if the
+    # Performs the job. It will not perform anything if the
     # `Decidim.machine_translation_service` config is not set.
     #
     # resource - Any kind of `Decidim::TranslatableResource` model instance

data/app/jobs/decidim/open_data_job.rb

@@ -8,7 +8,7 @@ module Decidim
       path = Rails.root.join("tmp/#{organization.open_data_file_path}")
 
       exporter = OpenDataExporter.new(organization, path)
-      raise "Couldn't generate Open Data export" unless exporter.export.positive?
+      raise "Could not generate Open Data export" unless exporter.export.positive?
 
       organization.open_data_file.attach(io: File.open(path, "rb"), filename: organization.open_data_file_path)
       # Deletes the temporary file file

data/app/mailers/decidim/application_mailer.rb

@@ -7,57 +7,23 @@ module Decidim
     include LocalisedMailer
     include MultitenantAssetHost
     after_action :set_smtp
-    after_action :set_from
 
     default from: Decidim.config.mailer_sender
     layout "decidim/mailer"
 
     private
 
-    attr_reader :organization
-
     def set_smtp
-      return if organization.nil? || organization.smtp_settings.blank? || organization.smtp_settings.except("from", "from_label", "from_email").all?(&:blank?)
+      return if @organization.nil? || @organization.smtp_settings.blank?
 
+      mail.from = @organization.smtp_settings["from"].presence || mail.from
       mail.reply_to = mail.reply_to || Decidim.config.mailer_reply
       mail.delivery_method.settings.merge!(
-        address: organization.smtp_settings["address"],
-        port: organization.smtp_settings["port"],
-        user_name: organization.smtp_settings["user_name"],
-        password: Decidim::AttributeEncryptor.decrypt(organization.smtp_settings["encrypted_password"])
+        address: @organization.smtp_settings["address"],
+        port: @organization.smtp_settings["port"],
+        user_name: @organization.smtp_settings["user_name"],
+        password: Decidim::AttributeEncryptor.decrypt(@organization.smtp_settings["encrypted_password"])
       ) { |_k, o, v| v.presence || o }.compact_blank!
     end
-
-    def set_from
-      return if organization.nil?
-      return if already_defined_name_in_mail?(mail.from.first)
-
-      mail.from = sender
-    end
-
-    def sender
-      return Decidim.config.mailer_sender if return_mailer_sender?
-      return default_sender if organization.smtp_settings.blank?
-      return default_sender if organization.smtp_settings["from"].nil?
-      return default_sender if organization.smtp_settings["from"].empty?
-
-      smtp_settings_from = organization.smtp_settings["from"]
-      return smtp_settings_from if already_defined_name_in_mail?(smtp_settings_from)
-
-      email_address_with_name(smtp_settings_from, organization.name)
-    end
-
-    def default_sender
-      email_address_with_name(Decidim.config.mailer_sender, organization.name)
-    end
-
-    def already_defined_name_in_mail?(mail_address)
-      # if there is an space, there is already a name in the address
-      mail_address.match?(/ /)
-    end
-
-    def return_mailer_sender?
-      already_defined_name_in_mail?(Decidim.config.mailer_sender) && organization.smtp_settings.present?
-    end
   end
 end

data/app/mailers/decidim/block_user_mailer.rb

@@ -15,7 +15,7 @@ module Decidim
           justification: @justification
         )
 
-        mail(to: user.email, subject: subject)
+        mail(to: user.email, subject:)
       end
     end
   end

data/app/mailers/decidim/decidim_devise_mailer.rb

@@ -28,7 +28,7 @@ module Decidim
     private
 
     # Overwrite devise_mail so we can inject the organization from the user.
-    def devise_mail(user, action, opts = {}, &block)
+    def devise_mail(user, action, opts = {}, &)
       with_user(user) do
         @organization = user.organization
         super

data/app/mailers/decidim/messaging/conversation_mailer.rb

@@ -5,12 +5,74 @@ module Decidim
     # A custom mailer for sending notifications to users when they receive
     # private messages
     class ConversationMailer < Decidim::ApplicationMailer
-      include HasConversations
+      def new_conversation(originator, user, conversation)
+        notification_mail(
+          from: originator,
+          to: user,
+          conversation:,
+          message: conversation.messages.first.body,
+          action: "new_conversation"
+        )
+      end
+
+      def new_group_conversation(originator, manager, conversation, group)
+        notification_mail(
+          from: originator,
+          to: manager,
+          conversation:,
+          message: conversation.messages.first.body,
+          action: "new_group_conversation",
+          third_party: group
+        )
+      end
+
+      def comanagers_new_conversation(group, user, conversation, manager)
+        notification_mail(
+          from: group,
+          to: user,
+          conversation:,
+          message: conversation.messages.first.body,
+          action: "comanagers_new_conversation",
+          third_party: manager
+        )
+      end
+
+      def new_message(sender, user, conversation, message)
+        notification_mail(
+          from: sender,
+          to: user,
+          conversation:,
+          message: message.body,
+          action: "new_message"
+        )
+      end
+
+      def new_group_message(sender, user, conversation, message, group)
+        notification_mail(
+          from: sender,
+          to: user,
+          conversation:,
+          message: message.body,
+          action: "new_group_message",
+          third_party: group
+        )
+      end
+
+      def comanagers_new_message(sender, user, conversation, message, manager)
+        notification_mail(
+          from: sender,
+          to: user,
+          conversation:,
+          message: message.body,
+          action: "comanagers_new_message",
+          third_party: manager
+        )
+      end
 
       private
 
       # rubocop:disable Metrics/ParameterLists
-      def send_notification(from:, to:, conversation:, action:, message: nil, third_party: nil)
+      def notification_mail(from:, to:, conversation:, action:, message: nil, third_party: nil)
         with_user(to) do
           @organization = to.organization
           @conversation = conversation
@@ -19,9 +81,16 @@ module Decidim
           @third_party = third_party
           @message = message
           @host = @organization.host
-          subject = get_subject(action: action, sender: @sender, third_party: @third_party)
 
-          mail(to: to.email, subject: subject)
+          subject = I18n.t(
+            "conversation_mailer.#{action}.subject",
+            scope: "decidim.messaging",
+            sender: @sender.name,
+            manager: @third_party&.name,
+            group: @third_party&.name
+          )
+
+          mail(to: to.email, subject:)
         end
       end
       # rubocop:enable Metrics/ParameterLists

data/app/mailers/decidim/notification_mailer.rb

@@ -11,10 +11,10 @@ module Decidim
       with_user(user) do
         @organization = user.organization
         event_class = event_class_name.constantize
-        @event_instance = event_class.new(resource: resource, event_name: event, user: user, extra: extra, user_role: user_role)
+        @event_instance = event_class.new(resource:, event_name: event, user:, extra:, user_role:)
         subject = @event_instance.email_subject
 
-        mail(to: user.email, subject: subject)
+        mail(to: user.email, subject:)
       end
     end
   end

data/app/mailers/decidim/reported_mailer.rb

@@ -18,7 +18,7 @@ module Decidim
         @author = @reportable.try(:creator_identity) || @reportable.try(:author)
         @original_language = original_language(@reportable)
         subject = I18n.t("report.subject", scope: "decidim.reported_mailer")
-        mail(to: user.email, subject: subject)
+        mail(to: user.email, subject:)
       end
     end
 
@@ -29,7 +29,7 @@ module Decidim
         @organization = user.organization
         @user = user
         subject = I18n.t("hide.subject", scope: "decidim.reported_mailer")
-        mail(to: user.email, subject: subject)
+        mail(to: user.email, subject:)
       end
     end
 
@@ -63,7 +63,7 @@ module Decidim
     end
 
     # This is needed to be able to use a cell in an ActionMailer, which is not supported out of the box by cells-rails.
-    # We're are passing the current object as if it was a controller.
+    # We are are passing the current object as if it was a controller.
     # We also need to define a 'current_organization' method, which is expected by Decidim::ViewModel.
     # A similar approach is used in Decidim::NewsletterMailer
     def reported_content_cell

data/app/mailers/decidim/user_update_mailer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  class UserUpdateMailer < ApplicationMailer
+    def notify(user, updates)
+      with_user(user) do
+        @user = user
+        @organization = user.organization
+        @updates = format_array(updates)
+        mail(to: user.email, subject: I18n.t(
+          "decidim.user_update_mailer.subject"
+        ))
+      end
+    end
+
+    private
+
+    def format_array(updates)
+      last_update = updates.last
+      case updates.length
+      when 1
+        updates.first
+      else
+        I18n.t("decidim.user_update_mailer.notify.update_fields", updates: updates[0..-2].join(", "), last_update:, count: updates.length)
+      end
+    end
+  end
+end

data/app/models/decidim/action_log.rb

@@ -85,11 +85,41 @@ module Decidim
       )
     }
 
+    # Accepts a space filter that defines the participatory space manifest name
+    # and ID. E.g. "participatory_processes(123)" where
+    # "participatory_processes" is the manifest name and the number within the
+    # parentheses is the ID.
+    #
+    # For this scope to work, the filter has to follow the given structure and
+    # the participatory space name needs to match one of the registered
+    # manifest names.
+    scope :with_participatory_space, lambda { |space_filter|
+      filter_match = space_filter.match(/([a-z_]+)\(([0-9]+)\)/)
+      return self unless filter_match
+
+      space_name = filter_match[1].to_sym
+      space_id = filter_match[2]
+      space_manifest = Decidim.participatory_space_manifests.find do |manifest|
+        manifest.name == space_name
+      end
+      return self unless space_manifest
+
+      where(
+        participatory_space_type: space_manifest.model_class_name,
+        participatory_space_id: space_id
+      ).or(
+        where(
+          resource_type: space_manifest.model_class_name,
+          resource_id: space_id
+        )
+      )
+    }
+
     validates :action, presence: true
     validates :resource, presence: true, if: ->(log) { log.action != "delete" }
     validates :visibility, presence: true, inclusion: { in: %w(private-only admin-only public-only all) }
 
-    # To ensure records can't be deleted
+    # To ensure records cannot be deleted
     before_destroy { |_record| raise ActiveRecord::ReadOnlyRecord }
 
     # A scope that filters all the logs that should be visible at the admin panel.
@@ -103,13 +133,11 @@ module Decidim
         Decidim::Accountability::Result
         Decidim::Blogs::Post
         Decidim::Comments::Comment
-        Decidim::Consultations::Question
         Decidim::Debates::Debate
         Decidim::Meetings::Meeting
         Decidim::Proposals::Proposal
         Decidim::Surveys::Survey
         Decidim::Assembly
-        Decidim::Consultation
         Decidim::Initiative
         Decidim::ParticipatoryProcess
       ).select do |klass|
@@ -129,8 +157,12 @@ module Decidim
       @publicable_public_resource_types ||= public_resource_types.select { |klass| klass.constantize.column_names.include?("published_at") }
     end
 
-    def self.ransackable_scopes(_auth_object = nil)
-      [:with_resource_type]
+    def self.ransackable_scopes(auth_object = nil)
+      base = [:with_resource_type]
+      return base unless auth_object&.admin?
+
+      # Add extra scopes for admins for the admin panel searches
+      base + [:with_participatory_space]
     end
 
     # Overwrites the method so that records cannot be modified.
@@ -189,12 +221,12 @@ module Decidim
     # Returns a Batchloader for a given class to avoid N+1 queries.
     #
     # Since ActionLogs are related to many different resources, loading a collection
-    # of them would trigger a lot of N+1 queries. We're using BatchLoader to
+    # of them would trigger a lot of N+1 queries. We are using BatchLoader to
     # accumulate and group all the resource by their class and only loading them
-    # when it's necessary.
+    # when it is necessary.
     def self.lazy_relation(id_method, klass_name, cache)
       klass = klass_name.constantize
-      BatchLoader.for(id_method).batch(cache: cache, key: klass.name.underscore) do |relation_ids, loader|
+      BatchLoader.for(id_method).batch(cache:, key: klass.name.underscore) do |relation_ids, loader|
         scope = klass.where(id: relation_ids)
 
         scope = if klass.include?(Decidim::HasComponent)
@@ -219,7 +251,7 @@ module Decidim
         participatory_space_lazy.present? &&
         !resource_lazy.try(:deleted?) &&
         !resource_lazy.try(:hidden?) &&
-        (!resource_lazy.respond_to?(:can_participate?) || resource_lazy.try(:can_participate?, user))
+        (participatory_space_lazy.try(:is_transparent?) || !resource_lazy.respond_to?(:can_participate?) || resource_lazy.try(:can_participate?, user))
     rescue NameError => e
       Rails.logger.warn "Failed resource for #{self.class.name}(id=#{id}): #{e.message}"
 

data/app/models/decidim/amendment.rb

@@ -2,24 +2,21 @@
 
 module Decidim
   class Amendment < ApplicationRecord
-    STATES = %w(draft evaluating accepted rejected withdrawn).freeze
+    STATES = { draft: 0, evaluating: 10, accepted: 20, rejected: 30, withdrawn: -1 }.freeze
 
     belongs_to :amendable, foreign_key: "decidim_amendable_id", foreign_type: "decidim_amendable_type", polymorphic: true
     belongs_to :amender, foreign_key: "decidim_user_id", class_name: "Decidim::User"
     belongs_to :emendation, foreign_key: "decidim_emendation_id", foreign_type: "decidim_emendation_type", polymorphic: true
 
-    validates :state, presence: true, inclusion: { in: STATES }
+    validates :state, presence: true, inclusion: { in: STATES.keys.map(&:to_s) }
 
-    def draft?
-      state == "draft"
-    end
-
-    def evaluating?
-      state == "evaluating"
-    end
+    enum state: STATES, _default: "draft"
 
-    def rejected?
-      state == "rejected"
+    # Reports the mapped resource type for authorization transfers.
+    #
+    # @return [String] The resource type as string (i.e. its class name).
+    def mapped_resource_type
+      decidim_amendable_type
     end
 
     def promoted?

data/app/models/decidim/authorization.rb

@@ -23,6 +23,7 @@ module Decidim
 
     belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
     has_one :organization, through: :user, class_name: "Decidim::Organization"
+    has_many :transfers, class_name: "Decidim::AuthorizationTransfer", dependent: :destroy
 
     validates :name, uniqueness: { scope: :decidim_user_id }
     validates :verification_metadata, absence: true, if: :granted?
@@ -36,10 +37,7 @@ module Decidim
         name: handler.handler_name
       )
 
-      authorization.attributes = {
-        unique_id: handler.unique_id,
-        metadata: handler.metadata
-      }
+      authorization.attributes = handler.authorization_attributes
 
       authorization.grant!
     end
@@ -81,6 +79,18 @@ module Decidim
       expires_at.present? && expires_at < Time.current
     end
 
+    # Transfers the authorization and data bound to the authorization to the
+    # other user provided as an argument.
+    #
+    # @param handler [Decidim::AuthorizationHandler] The authorization handler
+    #   that caused the conflicting situation to happen and which stores the
+    #   authorizing user's information with the latest authorization data.
+    # @return [Decidim::AuthorizationTransfer] The authorization transfer that
+    #   was just processed with its information.
+    def transfer!(handler)
+      Decidim::AuthorizationTransfer.perform!(self, handler)
+    end
+
     private
 
     def active_handler?