decidim · alecslupu · Dec 17, 2024 · Nov 19, 2024 · Nov 19, 2024 · Nov 20, 2024
diff --git a/config/i18n-tasks.yml b/config/i18n-tasks.yml
@@ -134,6 +134,7 @@ ignore_unused:
   - '{date,time.formats}.*'
   - datetime.distance_in_words.*
   - decidim.admin.participatory_process_steps.default_title
+  - decidim.admin.admin_log.changeset.*
   - decidim.authorization_handlers.{direct,multistep}
   - decidim.admin.models.assembly_member.positions.*
   - decidim.application.documents.component_documents.*

diff --git a/decidim-admin/app/commands/decidim/admin/bulk_action.rb b/decidim-admin/app/commands/decidim/admin/bulk_action.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    class BulkAction < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # current_user - the user that performs the action
+      # action - can be hide, unhide and unreport resources
+      # selected_moderations - all resources selected by current_user
+      def initialize(current_user, action, selected_moderations)
+        @current_user = current_user
+        @action = action
+        @selected_moderations = selected_moderations
+        @result = { ok: [], ko: [] }
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the resource.
+      # - :invalid if the resource is not reported
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if selected_moderations.blank?
+
+        process_reportables
+        create_action_log if selected_moderations.first.reportable
+
+        broadcast(:ok, **result)
+      end
+
+      private
+
+      attr_reader :action, :selected_moderations, :current_user, :result, :with_admin_log
+
+      def create_action_log
+        action_log_type = "bulk_#{action}"
+
+        Decidim::ActionLogger.log(
+          action_log_type,
+          current_user,
+          selected_moderations.first,
+          nil,
+          extra: {
+            reported_content:,
+            reported_count: result[:ok].count
+          }
+        )
+      end
+
+      def reported_content
+        @reported_content ||= result[:ok].group_by(&:decidim_reportable_type).to_h do |klass, moderations|
+          [
+            klass.split("::").last.downcase.pluralize,
+            moderations.to_h { |moderation| [moderation.reportable.id, moderation.title] }
+          ]
+        end
+      end
+
+      def process_reportables
+        selected_moderations.each do |moderation|
+          next unless moderation
+
+          if moderation.respond_to?(:organization) && moderation.organization != current_user.organization
+            result[:ko] << moderation
+            next
+          end
+          command.call(moderation.reportable, current_user, with_admin_log: false) do
+            on(:ok) do
+              result[:ok] << moderation
+            end
+            on(:invalid) do
+              result[:ko] << moderation
+            end
+          end
+        end
+      end
+
+      def command
+        case action
+        when "hide"
+          Admin::HideResource
+        when "unreport"
+          Admin::UnreportResource
+        when "unhide"
+          Admin::UnhideResource
+        end
+      end
+    end
+  end
+end
diff --git a/decidim-admin/app/commands/decidim/admin/bulk_block_users.rb b/decidim-admin/app/commands/decidim/admin/bulk_block_users.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    class BulkBlockUsers < Decidim::Command
+      # Public: Initializes the command.
+      def initialize(form)
+        @form = form
+        @result = { ok: [], ko: [] }
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the resource.
+      # - :invalid if the resource is not reported
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless form.valid?
+
+        block_all_users!
+        create_action_log if first_blocked
+
+        broadcast(:ok, **result)
+      end
+
+      private
+
+      attr_reader :form, :result, :first_blocked
+
+      def create_action_log
+        Decidim::ActionLogger.log(
+          "bulk_block",
+          form.current_user,
+          first_blocked,
+          nil,
+          extra: {
+            blocked:,
+            reportable_type: first_blocked.class.name,
+            current_justification: form.justification
+          }
+        )
+      end
+
+      def blocked
+        @blocked ||= result[:ok].to_h { |user| [user.id, user.extended_data["user_name"]] }
+      end
+
+      def block_all_users!
+        form.users.each do |user|
+          transaction do
+            Decidim::UserModeration.find_or_create_by!(user:)
+
+            @current_blocking = UserBlock.create!(
+              justification: form.justification,
+              user:,
+              blocking_user: form.current_user
+            )
+
+            user.blocked = true
+            user.blocked_at = Time.current
+            user.block_id = @current_blocking.id
+            user.extended_data["user_name"] = user.name
+            user.name = "Blocked user"
+            user.save!
+          end
+          result[:ok] << user
+          @first_blocked ||= user
+        rescue ActiveRecord::RecordInvalid
+          result[:ko] << user
+        end
+      end
+    end
+  end
+end
diff --git a/decidim-admin/app/commands/decidim/admin/bulk_unblock_users.rb b/decidim-admin/app/commands/decidim/admin/bulk_unblock_users.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    class BulkUnblockUsers < Decidim::Command
+      # Public: Initializes the command.
+      def initialize(blocked_users, current_user)
+        @blocked_users = blocked_users
+        @current_user = current_user
+        @result = { ok: [], ko: [] }
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the resource.
+      # - :invalid if the resource is not reported
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if blocked_users.blank?
+
+        unblock_users!
+        create_action_log if first_unblocked
+
+        broadcast(:ok, **result)
+      end
+
+      private
+
+      attr_reader :current_user, :blocked_users, :result, :first_unblocked
+
+      def create_action_log
+        Decidim::ActionLogger.log(
+          "bulk_unblock",
+          current_user,
+          first_unblocked,
+          nil,
+          extra: {
+            unblocked:,
+            reportable_type: first_unblocked.class.name
+          }
+        )
+      end
+
+      def unblocked
+        @unblocked ||= result[:ok].to_h { |blocked_user| [blocked_user.id, blocked_user.extended_data["user_name"]] }
+      end
+
+      def unblock_users!
+        blocked_users.each do |blocked_user|
+          transaction do
+            blocked_user.blocked = false
+            blocked_user.blocked_at = nil
+            blocked_user.block_id = nil
+            blocked_user.name = blocked_user.extended_data["user_name"]
+            blocked_user.save!
+          end
+          result[:ok] << blocked_user
+          @first_unblocked ||= blocked_user
+        rescue ActiveRecord::RecordInvalid
+          result[:ko] << blocked_user
+        end
+      end
+    end
+  end
+end
diff --git a/decidim-admin/app/commands/decidim/admin/bulk_unreport_users.rb b/decidim-admin/app/commands/decidim/admin/bulk_unreport_users.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    class BulkUnreportUsers < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # current_user - the user that performs the action
+      # reportables - all Decidim::Reportable selected by current_user
+      def initialize(current_user, reportables)
+        @current_user = current_user
+        @reportables = reportables
+        @result = { ok: [], ko: [] }
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid, together with the resource.
+      # - :invalid if the resource is not reported
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if reportables.blank?
+
+        bulk_unreport_users!
+        create_action_log if first_unreported
+
+        broadcast(:ok, **result)
+      end
+
+      private
+
+      attr_reader :reportables, :current_user, :result, :first_unreported
+
+      def create_action_log
+        Decidim::ActionLogger.log(
+          "bulk_ignore",
+          current_user,
+          first_unreported,
+          nil,
+          extra: {
+            unreported:,
+            reportable_type: first_unreported.class.name
+          }
+        )
+      end
+
+      def unreported
+        @unreported ||= result[:ok].to_h { |reportable| [reportable.id, reportable.name] }
+      end
+
+      def bulk_unreport_users!
+        reportables.each do |reportable|
+          next unless reportable
+
+          if reportable.respond_to?(:organization) && reportable.organization != current_user.organization
+            result[:ok] << reportable
+            next
+          end
+          reportable.user_moderation.destroy!
+          result[:ok] << reportable
+          @first_unreported ||= reportable
+        rescue ActiveRecord::RecordInvalid
+          result[:ko] << reportable
+        end
+      end
+    end
+  end
+end
diff --git a/decidim-admin/app/commands/decidim/admin/hide_resource.rb b/decidim-admin/app/commands/decidim/admin/hide_resource.rb
@@ -8,9 +8,11 @@ class HideResource < Decidim::Command
       #
       # reportable - A Decidim::Reportable
       # current_user - the user that performs the action
-      def initialize(reportable, current_user)
+      # with_admin_log Boolean - determines whether to log the action of hiding a resource in the admin log
+      def initialize(reportable, current_user, with_admin_log: true)
         @reportable = reportable
         @current_user = current_user
+        @with_admin_log = with_admin_log
       end
 
       # Executes the command. Broadcasts these events:
@@ -24,7 +26,7 @@ def call
 
         with_events do
           tool = Decidim::ModerationTools.new(@reportable, @current_user)
-          tool.hide!
+          @with_admin_log ? tool.hide_with_admin_log! : tool.hide!
           tool.send_notification_to_author
         end
 

diff --git a/decidim-admin/app/commands/decidim/admin/unhide_resource.rb b/decidim-admin/app/commands/decidim/admin/unhide_resource.rb
@@ -8,9 +8,11 @@ class UnhideResource < Decidim::Command
       #
       # reportable - A Decidim::Reportable
       # current_user - the user that performs the action
-      def initialize(reportable, current_user)
+      # with_admin_log Boolean - determines whether to log the action of unhide a resource in the admin log
+      def initialize(reportable, current_user, with_admin_log: true)
         @reportable = reportable
         @current_user = current_user
+        @with_admin_log = with_admin_log
       end
 
       # Executes the command. Broadcasts these events:
@@ -22,7 +24,7 @@ def initialize(reportable, current_user)
       def call
         return broadcast(:invalid) unless unhideable?
 
-        unhide!
+        @with_admin_log ? unhide_with_admin_log! : unhide!
         broadcast(:ok, @reportable)
       end
 
@@ -32,7 +34,7 @@ def unhideable?
         @reportable.hidden? && @reportable.reported?
       end
 
-      def unhide!
+      def unhide_with_admin_log!
         Decidim.traceability.perform_action!(
           "unhide",
           @reportable.moderation,
@@ -41,6 +43,12 @@ def unhide!
             reportable_type: @reportable.class.name
           }
         ) do
+          unhide!
+        end
+      end
+
+      def unhide!
+        Decidim.traceability.perform_action_without_log!(@current_user) do
           @reportable.moderation.update!(hidden_at: nil)
         end
       end