decidim-admin 0.29.2 → 0.30.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5369e22c8aa5d1eef8398ca2971c4231fcdda8284df5350ca231b68e47e78cf
-  data.tar.gz: 28d412f0fbd4683f6031784abf212ba6341f0dd803a57eb167b9d1bf186f83a1
+  metadata.gz: 48272c228554c612efad0837403c06e2955c0a5a71df4b1f57ef0b9d12d986c6
+  data.tar.gz: bfd117609106eb1d64f292a6b2e84cc524c7c9dab2bfa3dce05bc8ddfe44408a
 SHA512:
-  metadata.gz: d25815c8206161af6f158106f8258abc3280cb05e03c528fb7e628479bae1c43551a4172014a181a09f66ec6eb24da6f0cfd55e4d3302fb0b8aa0391d0cfd430
-  data.tar.gz: 71a6522e75aed08bbdc65577cd76b2c69741d66f28b350c04dc02c1c92850e96fd50c481a23e02da804316f8eb24e5a1186dad94912eae6b2bb1072774d292fb
+  metadata.gz: 9af4afad6391f293b4b3a1a8fd6b3bb262b1da9bda95b8cbadb0a43236475b0ba3a615315278d7da8e750dbe2a1d9a76e30f513cbb4993c580e83dd08b2123de
+  data.tar.gz: 57fad1f9f4ff5488fd0f5d35d2aff8105f7c7e37cb66dbf6da69a577e74567b11c037a88f82be3b4dc0834d505e2248ec8697ada0a42a02c15f3dbd956789ea6

data/app/cells/decidim/admin/multi_select_picker/show.erb

@@ -0,0 +1,10 @@
+<%= select_tag field_name,
+               options_for_select(
+                 cell_options_for_select.map { |option| [option[0], option[1]] },
+                 selected_values
+               ),
+               id: select_id,
+               class: css_classes,
+               placeholder:,
+               multiple: true,
+               data: { multiselect: true } %>

data/app/cells/decidim/admin/multi_select_picker_cell.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # Universal cell for rendering multi-select pickers
+    class MultiSelectPickerCell < Decidim::ViewModel
+      include ActionView::Helpers::FormOptionsHelper
+
+      def show
+        render :show
+      end
+
+      def cell_options_for_select
+        context[:options_for_select] || []
+      end
+
+      def selected_values
+        context[:selected_values] || []
+      end
+
+      def select_id
+        context[:select_id]
+      end
+
+      def field_name
+        context[:field_name]
+      end
+
+      def placeholder
+        context[:placeholder] || ""
+      end
+
+      def css_classes
+        context[:class] || ""
+      end
+    end
+  end
+end

data/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

data/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

data/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

data/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

data/app/commands/decidim/admin/content_blocks/update_content_block.rb

@@ -70,7 +70,7 @@ module Decidim
 
             if form.images[image_name]
               content_block.images_container.send("#{image_name}=", form.images[image_name])
-            elsif form.images["remove_#{image_name}".to_sym] == "1"
+            elsif form.images[:"remove_#{image_name}"] == "1"
               content_block.images_container.send("#{image_name}=", nil)
             end
           end

data/app/commands/decidim/admin/create_participatory_space_private_user.rb

@@ -53,7 +53,9 @@ module Decidim
         ) do
           Decidim::ParticipatorySpacePrivateUser.find_or_create_by!(
             user:,
-            privatable_to: @private_user_to
+            privatable_to: @private_user_to,
+            role: form.role,
+            published: form.published
           )
         end
       end

data/app/commands/decidim/admin/create_share_token.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic to create a share token.
+    # This command is called from the controller.
+    class CreateShareToken < Decidim::Commands::CreateResource
+      fetch_form_attributes :token, :expires_at, :registered_only, :organization, :user, :token_for
+
+      protected
+
+      def resource_class = Decidim::ShareToken
+
+      def extra_params
+        {
+          participatory_space: {
+            title: participatory_space&.title
+          },
+          resource: {
+            title: component&.name
+          }
+        }
+      end
+
+      def participatory_space
+        return form.token_for if form.token_for.try(:manifest).is_a?(Decidim::ParticipatorySpaceManifest)
+        return current_participatory_space if respond_to?(:current_participatory_space)
+
+        component&.participatory_space
+      end
+
+      def component
+        return form.token_for if form.token_for.is_a?(Decidim::Component)
+
+        form.token_for.try(:component)
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/create_taxonomy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic to create a taxonomy.
+    # This command is called from the controller.
+    class CreateTaxonomy < Decidim::Commands::CreateResource
+      fetch_form_attributes :name, :organization, :parent_id
+
+      protected
+
+      def resource_class = Decidim::Taxonomy
+
+      def extra_params
+        {
+          extra: {
+            parent_name: form.try(:parent).try(:name)
+          }
+        }
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/create_taxonomy_filter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic to create a new taxonomy filter in the
+    # system.
+    class CreateTaxonomyFilter < Decidim::Commands::CreateResource
+      fetch_form_attributes :root_taxonomy_id, :filter_items, :internal_name, :name, :participatory_space_manifests
+
+      protected
+
+      def resource_class = Decidim::TaxonomyFilter
+
+      def extra_params
+        {
+          extra: {
+            taxonomy_name: form.root_taxonomy.name,
+            filter_items_count: form.filter_items.count
+          }
+        }
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/destroy_share_token.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic to destroy a share token.
+    # This command is called from the controller.
+    class DestroyShareToken < Decidim::Commands::DestroyResource
+      delegate :participatory_space, :component, to: :resource
+
+      def extra_params
+        {
+          participatory_space: {
+            title: participatory_space&.title
+          },
+          resource: {
+            title: component&.name
+          }
+        }
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/destroy_taxonomy.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic to destroy a taxonomy.
+    class DestroyTaxonomy < Decidim::Commands::DestroyResource
+      private
+
+      def extra_params
+        {
+          extra: {
+            parent_name: resource.parent.try(:name)
+          }
+        }
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/destroy_taxonomy_filter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic to destroy a taxonomy in the
+    # system.
+    class DestroyTaxonomyFilter < Decidim::Commands::DestroyResource
+      private
+
+      def extra_params
+        {
+          extra: {
+            taxonomy_name: resource.root_taxonomy.name,
+            filter_items_count: resource.try(:filter_items_count)
+          }
+        }
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/hide_menu_component.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # This command gets called when a component is marked as not visible (hidden) in the menu from the admin panel.
+    class HideMenuComponent < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # component - The component to publish.
+      # current_user - the user performing the action
+      def initialize(component, current_user)
+        @component = component
+        @current_user = current_user
+      end
+
+      # Public: Publishes the Component.
+      #
+      # Broadcasts :ok if disabled visibility, :invalid otherwise.
+      def call
+        Decidim.traceability.perform_action!(
+          :menu_hidden,
+          component,
+          current_user,
+          visibility: "all"
+        ) do
+          component.update!(visible: false)
+        end
+
+        broadcast(:ok)
+      end
+
+      private
+
+      attr_reader :component, :current_user
+    end
+  end
+end

data/app/commands/decidim/admin/hide_resource.rb

@@ -8,9 +8,11 @@ module Decidim
       #
       # 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 @@ module Decidim
 
         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
 

data/app/commands/decidim/admin/publish_all_participatory_space_private_users.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    class PublishAllParticipatorySpacePrivateUsers < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # participatory_space - the participatory space
+      # current_user - the current user
+      def initialize(participatory_space, current_user)
+        @participatory_space = participatory_space
+        @current_user = current_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if the form was not valid and we could not proceed.
+      #
+      # Returns nothing.
+      def call
+        publish_all
+        create_action_log
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :participatory_space, :current_user
+
+      def publish_all
+        # rubocop:disable Rails/SkipsModelValidations
+        # Using update_all for performance reasons
+        participatory_space.participatory_space_private_users.update_all(published: true)
+        # rubocop:enable Rails/SkipsModelValidations
+      end
+
+      def create_action_log
+        Decidim.traceability.perform_action!(
+          "publish_all_members",
+          participatory_space,
+          current_user,
+          private_users_ids: participatory_space.participatory_space_private_users.pluck(:id)
+        )
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/publish_component.rb

@@ -35,6 +35,9 @@ module Decidim
           visibility: "all"
         ) do
           component.publish!
+          component.update!(
+            visible: true
+          )
           component
         end
       end