decidim-admin 0.29.1 → 0.30.0.rc1

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command that reorders a collection of components
+    class ReorderComponents < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # components - the components to reorder
+      # order - an Array holding the order of IDs of the components
+      def initialize(components, order)
+        @components = components
+        @order = order
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if the data was not valid and we could not proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) unless valid_params?
+
+        reorder_components
+        broadcast(:ok)
+      end
+
+      private
+
+      attr_reader :components, :order
+
+      def valid_params?
+        order.present? && components.present?
+      end
+
+      def reorder_components
+        transaction do
+          order.each_with_index do |id, index|
+            component = components.find_by(id:)
+            component.update!(weight: index + 1) if component.present?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command that reorders a collection of taxonomies
+    # the ones that might be missing.
+    class ReorderTaxonomies < Decidim::Command
+      # Public: Initializes the command.
+      #
+      # organization - the Organization where the content blocks reside
+      # order - an Array holding the order of IDs of published content blocks.
+      def initialize(organization, order, offset = 0)
+        @organization = organization
+        @order = order
+        @offset = offset
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if the data was not valid and we could not proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if order.blank?
+        return broadcast(:invalid) if collection.empty?
+
+        reorder_steps
+        broadcast(:ok)
+      end
+
+      private
+
+      attr_reader :organization, :offset
+
+      def reorder_steps
+        transaction do
+          reset_weights
+          collection.reload
+          set_new_weights
+        end
+      end
+
+      def reset_weights
+        # rubocop:disable Rails/SkipsModelValidations
+        collection.where.not(weight: nil).where(id: order).update_all(weight: nil)
+        # rubocop:enable Rails/SkipsModelValidations
+      end
+
+      def set_new_weights
+        data = order.each_with_index.inject({}) do |hash, (id, index)|
+          hash.update(id => index + 1 + offset)
+        end
+
+        data.each do |id, weight|
+          item = collection.find_by(id:)
+          item.update!(weight:) if item.present?
+        end
+      end
+
+      def order
+        return nil unless @order.is_a?(Array) && @order.present?
+
+        @order
+      end
+
+      def collection
+        @collection ||= Decidim::Taxonomy.where(organization:, parent_id: first_item.parent_id)
+      end
+
+      def first_item
+        @first_item ||= Decidim::Taxonomy.where(organization:).find(order.first)
+      end
+    end
+  end
+end

data/app/commands/decidim/admin/unhide_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 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 @@ module Decidim
       def call
         return broadcast(:invalid) unless unhideable?
 
-        unhide!
+        @with_admin_log ? unhide_with_admin_log! : unhide!
         broadcast(:ok, @reportable)
       end
 
@@ -32,7 +34,7 @@ module Decidim
         @reportable.hidden? && @reportable.reported?
       end
 
-      def unhide!
+      def unhide_with_admin_log!
         Decidim.traceability.perform_action!(
           "unhide",
           @reportable.moderation,
@@ -41,6 +43,12 @@ module Decidim
             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

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    class UnpublishAllParticipatorySpacePrivateUsers < 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
+        unpublish_all
+        create_action_log
+        broadcast(:ok)
+      rescue ActiveRecord::RecordInvalid
+        broadcast(:invalid)
+      end
+
+      private
+
+      attr_reader :participatory_space, :current_user
+
+      def unpublish_all
+        # rubocop:disable Rails/SkipsModelValidations
+        # Using update_all for performance reasons
+        participatory_space.participatory_space_private_users.update_all(published: false)
+        # rubocop:enable Rails/SkipsModelValidations
+      end
+
+      def create_action_log
+        Decidim.traceability.perform_action!(
+          "unpublish_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/unreport_resource.rb

@@ -8,9 +8,11 @@ module Decidim
       #
       # reportable - A Decidim::Reportable
       # current_user - the user performing the action
-      def initialize(reportable, current_user)
+      # with_admin_log Boolean - determines whether to log the action of unreport 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,13 +24,13 @@ module Decidim
       def call
         return broadcast(:invalid) unless @reportable.reported?
 
-        unreport!
+        @with_admin_log ? unreport_with_admin_log! : unreport!
         broadcast(:ok, @reportable)
       end
 
       private
 
-      def unreport!
+      def unreport_with_admin_log!
         Decidim.traceability.perform_action!(
           "unreport",
           @reportable.moderation,
@@ -37,6 +39,12 @@ module Decidim
             reportable_type: @reportable.class.name
           }
         ) do
+          unreport!
+        end
+      end
+
+      def unreport!
+        Decidim.traceability.perform_action_without_log!(@current_user) do
           @reportable.moderation.destroy!
         end
       end

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

@@ -25,7 +25,10 @@ module Decidim
 
         Decidim.traceability.perform_action!("update_permissions", @component, current_user) do
           transaction do
+            permissions_with_changes_in_ephemeral_handlers
             update_permissions
+            raise ActiveRecord::Rollback unless clean_ephemeral_authorizations
+
             run_hooks
           end
         end
@@ -44,7 +47,36 @@ module Decidim
       end
 
       def update_permissions
-        permissions = configured_permissions.inject({}) do |result, (key, value)|
+        if resource
+          resource_permissions.update!(permissions: permissions_with_differences(component.permissions, selected_permissions))
+        else
+          component.update!(permissions: selected_permissions)
+        end
+      end
+
+      def clean_ephemeral_authorizations
+        handler_names = permissions_with_changes_in_ephemeral_handlers.values.map { |config| config["authorization_handlers"].keys }.flatten.uniq
+        ephemeral_handler_names = handler_names.select { |handler_name| Decidim::Verifications::Adapter.from_element(handler_name).ephemeral? }
+
+        ephemeral_handler_names.each do |name|
+          Decidim::Verifications::RevokeByNameAuthorizations.call(current_user.organization, name, current_user) do
+            on(:ok) do
+              return true
+            end
+
+            on(:invalid) do
+              return false
+            end
+          end
+        end
+      end
+
+      def run_hooks
+        component.manifest.run_hooks(:permission_update, component:, resource:)
+      end
+
+      def selected_permissions
+        @selected_permissions ||= configured_permissions.inject({}) do |result, (key, value)|
           handlers_content = {}
 
           selected_handlers(value).each do |handler_key|
@@ -58,27 +90,35 @@ module Decidim
 
           result.update(key => selected_handlers(value).any? ? serialized : {})
         end
-
-        if resource
-          resource_permissions.update!(permissions: different_from_component_permissions(permissions))
-        else
-          component.update!(permissions:)
-        end
       end
 
-      def run_hooks
-        component.manifest.run_hooks(:permission_update, component:, resource:)
+      def permissions_with_changes_in_ephemeral_handlers
+        @permissions_with_changes_in_ephemeral_handlers ||= begin
+          old_permissions = ((resource.present? ? resource_permissions.permissions : component.permissions) || {}).deep_stringify_keys
+
+          selected_permissions.deep_stringify_keys.reject do |action, config|
+            old_config = old_permissions[action] || { "authorization_handlers" => {} }
+            Hashdiff.diff(config, old_config).none? do |_, key, _|
+              handler_name = key.split(".")[1]
+              next if handler_name.blank?
+
+              Decidim::Verifications::Adapter.from_element(handler_name).ephemeral? && config["authorization_handlers"].keys.include?(handler_name)
+            end
+          end
+        end
       end
 
       def resource_permissions
         @resource_permissions ||= resource.resource_permission || resource.build_resource_permission
       end
 
-      def different_from_component_permissions(permissions)
-        return permissions unless component.permissions
+      def permissions_with_differences(old_permissions, new_permissions)
+        return new_permissions unless old_permissions
+
+        old_permissions = old_permissions.deep_stringify_keys
 
-        permissions.deep_stringify_keys.reject do |action, config|
-          Hashdiff.diff(config, component.permissions[action]).empty?
+        new_permissions.deep_stringify_keys.reject do |action, config|
+          Hashdiff.diff(old_permissions[action], config).empty?
         end
       end
 

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic when updating a participatory space
+    # private user.
+    class UpdateParticipatorySpacePrivateUser < Decidim::Commands::UpdateResource
+      fetch_form_attributes :role, :published
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command with all the business logic to update a share token.
+    # This command is called from the controller.
+    class UpdateShareToken < Decidim::Commands::UpdateResource
+      fetch_form_attributes :expires_at, :registered_only
+
+      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/update_taxonomy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A command to update a taxonomy.
+    class UpdateTaxonomy < Decidim::Commands::UpdateResource
+      fetch_form_attributes :name, :parent_id
+
+      protected
+
+      def extra_params
+        {
+          extra: {
+            parent_name: resource.parent.try(:name)
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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 UpdateTaxonomyFilter < Decidim::Commands::UpdateResource
+      fetch_form_attributes :filter_items, :internal_name, :name, :participatory_space_manifests
+
+      protected
+
+      def resource_class = Decidim::TaxonomyFilter
+
+      def run_before_hooks
+        resource.filter_items.destroy_all
+      end
+
+      def extra_params
+        {
+          extra: {
+            taxonomy_name: resource.root_taxonomy.name,
+            filter_items_count: form.filter_items.count
+          }
+        }
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/admin/component_taxonomies_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    module ComponentTaxonomiesHelper
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :current_component_taxonomy_filters
+      end
+
+      def current_component_taxonomy_filters
+        @current_component_taxonomy_filters ||= TaxonomyFilter.for(current_organization)
+                                                              .for_manifest(current_participatory_space.manifest.name)
+                                                              .where(id: current_component.settings.taxonomy_filters)
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/admin/filterable.rb

@@ -30,8 +30,9 @@ module Decidim
                       :search_field_predicate,
                       :adjacent_items
 
-        delegate :categories, to: :current_component
-        delegate :scopes, to: :current_organization
+        delegate :taxonomies, to: :current_organization
+        delegate :available_root_taxonomies, to: :current_component
+        delegate :available_taxonomy_ids, to: :current_component
 
         def query
           @query ||= base_query.ransack(ransack_params, search_context: :admin, auth_object: current_user)
@@ -188,36 +189,32 @@ module Decidim
           query.klass.model_name.human(count: 2)
         end
 
-        # A tree of Category IDs. Leaves are `nil`.
-        def category_ids_hash(categories)
-          categories.each_with_object({}) do |category, hash|
-            hash[category.id] = category.subcategories.any? ? category_ids_hash(category.subcategories) : nil
-          end
+        def taxonomy_order_or_search?
+          ransack_params[:taxonomies_part_of_contains].present? || ransack_params[:s]&.include?("taxonomies_name")
         end
 
-        # A tree of Scope IDs. Leaves are `nil`.
-        def scope_ids_hash(scopes)
-          scopes.each_with_object({}) do |scope, hash|
-            hash[scope.id] = scope.children.any? ? scope_ids_hash(scope.children) : nil
+        # A tree of Taxonomy IDs. Leaves are `nil`.
+        def taxonomy_ids_hash(taxonomies)
+          filtered_taxonomies = taxonomies.roots.or(taxonomies.where(id: available_taxonomy_ids))
+          return nil if filtered_taxonomies.blank?
+
+          filtered_taxonomies.each_with_object({}) do |taxonomy, hash|
+            hash[taxonomy.id] = taxonomy_ids_hash(taxonomy.children)
           end
         end
 
         # Array<Symbol> of filters that implement a method to find translations.
         # Useful when translations cannot be found in i18n or come from a Model.
         def dynamically_translated_filters
-          [:scope_id_eq, :category_id_eq]
+          [:taxonomies_part_of_contains]
         end
 
         def find_dynamic_translation(filter, value)
           send("translated_#{filter}", value) if filter.in?(dynamically_translated_filters)
         end
 
-        def translated_scope_id_eq(id)
-          translated_attribute(scopes.find_by(id:).name)
-        end
-
-        def translated_category_id_eq(id)
-          translated_attribute(categories.find_by(id:).name)
+        def translated_taxonomies_part_of_contains(id)
+          translated_attribute(taxonomies.find_by(id:).name)
         end
       end
     end