decidim-admin 0.29.2 → 0.30.0.rc2

data/app/forms/concerns/decidim/has_taxonomy_form_attributes.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module HasTaxonomyFormAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :taxonomies, Array[Integer]
+
+      validate :taxonomies_belong_to_current_organization
+
+      # Returns the participatory space manifest for search the available filters (ie: participatory_processes, assemblies, etc)
+      # To implement where this concern is included.
+      def participatory_space_manifest
+        raise NotImplementedError
+      end
+
+      def taxonomizations
+        @taxonomizations ||= compact_taxonomies.map do |taxonomy_id|
+          Decidim::Taxonomization.new(taxonomy_id:)
+        end
+      end
+
+      def taxonomy_filters
+        @taxonomy_filters ||= if defined?(current_component) && current_component&.settings.respond_to?(:taxonomy_filters)
+                                all_taxonomy_filters.where(id: current_component.settings.taxonomy_filters)
+                              else
+                                all_taxonomy_filters.for_manifest(participatory_space_manifest)
+                              end
+      end
+
+      def all_taxonomy_filters
+        @all_taxonomy_filters ||= TaxonomyFilter.where(root_taxonomy: root_taxonomies)
+      end
+
+      def root_taxonomies
+        @root_taxonomies ||= current_organization.taxonomies.roots
+      end
+
+      private
+
+      def taxonomies_belong_to_current_organization
+        return if compact_taxonomies.empty?
+
+        Decidim::Taxonomy.where(id: compact_taxonomies).find_each do |taxonomy|
+          next if taxonomy.decidim_organization_id == current_organization.id
+
+          errors.add(:taxonomies, :invalid)
+        end
+      end
+
+      def compact_taxonomies
+        @compact_taxonomies ||= taxonomies.compact
+      end
+    end
+  end
+end

data/app/forms/decidim/admin/block_users_form.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A form object used to block users or user groups on the admin dashboard.
+    class BlockUsersForm < Form
+      attribute :user_ids, Array[Integer]
+      attribute :justification, String
+      attribute :hide, Boolean, default: false
+
+      validates :justification, presence: true, length: { minimum: UserBlock::MINIMUM_JUSTIFICATION_LENGTH }
+
+      def users
+        @users ||= Decidim::UserBaseEntity.where(
+          id: user_ids,
+          organization: current_organization
+        )
+      end
+    end
+  end
+end

data/app/forms/decidim/admin/import_example_form.rb

@@ -35,7 +35,7 @@ module Decidim
       end
 
       def reader
-        @reader ||= reader_klass ? reader_klass.new("/dev/null") : nil
+        @reader ||= reader_klass ? reader_klass.new(File::NULL) : nil
       end
 
       def reader_klass

data/app/forms/decidim/admin/newsletter_form.rb

@@ -12,7 +12,7 @@ module Decidim
       validates :subject, translatable_presence: true
 
       def map_model(content_block)
-        super(content_block)
+        super
         self.subject = newsletter_for(content_block).try(:subject)
       end
 

data/app/forms/decidim/admin/participatory_space_private_user_form.rb

@@ -6,10 +6,15 @@ module Decidim
     # admin dashboard.
     #
     class ParticipatorySpacePrivateUserForm < Form
+      include TranslatableAttributes
+
       mimic :participatory_space_private_user
 
       attribute :name, String
       attribute :email, String
+      attribute :published, Boolean
+
+      translatable_attribute :role, String
 
       validates :name, :email, presence: true
 

data/app/forms/decidim/admin/selective_newsletter_form.rb

@@ -7,33 +7,33 @@ module Decidim
       mimic :newsletter
 
       attribute :participatory_space_types, Array[SelectiveNewsletterParticipatorySpaceTypeForm]
-      attribute :scope_ids, Array
+      attribute :verification_types, Array[String]
       attribute :send_to_all_users, Boolean
+      attribute :send_to_verified_users, Boolean
       attribute :send_to_participants, Boolean
       attribute :send_to_followers, Boolean
+      attribute :send_to_private_members, Boolean
 
-      validates :send_to_all_users, presence: true, unless: ->(form) { form.send_to_participants.present? || form.send_to_followers.present? }
-      validates :send_to_followers, presence: true, if: ->(form) { form.send_to_all_users.blank? && form.send_to_participants.blank? }
-      validates :send_to_participants, presence: true, if: ->(form) { form.send_to_all_users.blank? && form.send_to_followers.blank? }
+      validates :send_to_all_users, presence: true, unless: :other_groups_selected_for_all_users?
+      validates :send_to_verified_users, presence: true, unless: :other_groups_selected_for_verified_users?
+      validates :send_to_followers, presence: true, if: :only_followers_selected?
+      validates :send_to_participants, presence: true, if: :only_participants_selected?
+      validates :send_to_private_members, presence: true, if: :only_private_members_selected?
 
       validate :at_least_one_participatory_space_selected
 
-      def map_model(_newsletter)
+      def map_model(newsletter)
         self.participatory_space_types = Decidim.participatory_space_manifests.map do |manifest|
           SelectiveNewsletterParticipatorySpaceTypeForm.from_model(manifest:)
         end
-      end
 
-      # Make sure the empty scope is not passed because then some logic could
-      # assume erroneously that some scope is selected.
-      def scope_ids
-        super.select(&:presence)
+        self.verification_types = newsletter.organization.available_authorizations
       end
 
       private
 
       def at_least_one_participatory_space_selected
-        return if send_to_all_users && current_user.admin?
+        return if (send_to_all_users || send_to_verified_users) && current_user.admin?
 
         errors.add(:base, :at_least_one_space) if spaces_selected.blank?
       end
@@ -44,6 +44,41 @@ module Decidim
           [type.manifest_name, spaces] if spaces.present?
         end.compact
       end
+
+      def other_groups_selected_for_all_users?
+        send_to_verified_users.present? ||
+          send_to_participants.present? ||
+          send_to_followers.present? ||
+          send_to_private_members.present?
+      end
+
+      def other_groups_selected_for_verified_users?
+        send_to_all_users.present? ||
+          send_to_participants.present? ||
+          send_to_followers.present? ||
+          send_to_private_members.present?
+      end
+
+      def only_followers_selected?
+        send_to_all_users.blank? &&
+          send_to_participants.blank? &&
+          send_to_private_members.blank? &&
+          send_to_verified_users.blank?
+      end
+
+      def only_participants_selected?
+        send_to_all_users.blank? &&
+          send_to_followers.blank? &&
+          send_to_private_members.blank? &&
+          send_to_verified_users.blank?
+      end
+
+      def only_private_members_selected?
+        send_to_all_users.blank? &&
+          send_to_followers.blank? &&
+          send_to_participants.blank? &&
+          send_to_verified_users.blank?
+      end
     end
   end
 end

data/app/forms/decidim/admin/share_token_form.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    class ShareTokenForm < Decidim::Form
+      mimic :share_token
+
+      attribute :token, String
+      attribute :automatic_token, Boolean, default: true
+      attribute :expires_at, Decidim::Attributes::TimeWithZone
+      attribute :no_expiration, Boolean, default: true
+      attribute :registered_only, Boolean, default: false
+
+      validates :token, presence: true, if: ->(form) { form.automatic_token.blank? }
+      validate :token_uniqueness, if: ->(form) { form.automatic_token.blank? }
+
+      validates_format_of :token, with: /\A[a-zA-Z0-9_-]+\z/, allow_blank: true
+      validates :expires_at, presence: true, if: ->(form) { form.no_expiration.blank? }
+
+      def map_model(model)
+        self.no_expiration = model.expires_at.blank?
+      end
+
+      def token
+        super.strip.upcase.gsub(/\s+/, "-") if super.present?
+      end
+
+      def expires_at
+        return nil if no_expiration.present?
+
+        super
+      end
+
+      def token_for
+        context[:resource]
+      end
+
+      def organization
+        context[:current_organization]
+      end
+
+      def user
+        context[:current_user]
+      end
+
+      private
+
+      def token_uniqueness
+        return unless Decidim::ShareToken.where(organization:, token_for:, token:).where.not(id:).any?
+
+        errors.add(:token, :taken)
+      end
+    end
+  end
+end

data/app/forms/decidim/admin/taxonomy_filter_form.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A form object to create or update areas.
+    class TaxonomyFilterForm < Form
+      include TranslatableAttributes
+      Item = Struct.new(:name, :value, :children)
+      Manifest = Struct.new(:id, :name)
+
+      attribute :root_taxonomy_id, Integer
+      translatable_attribute :name, String
+      translatable_attribute :internal_name, String
+      attribute :participatory_space_manifests, Array, default: []
+      attribute :taxonomy_items, Array
+
+      mimic :taxonomy_filter
+
+      validates :root_taxonomy_id, :taxonomy_items, presence: true
+      validate :valid_taxonomy_items
+
+      def map_model(model)
+        self.root_taxonomy_id = model.root_taxonomy_id
+        self.taxonomy_items = model.filter_items.map(&:taxonomy_item_id)
+        self.name = {} if model.attributes["name"]&.compact_blank.blank?
+        self.internal_name = {} if model.attributes["internal_name"]&.compact_blank.blank?
+      end
+
+      def taxonomy_items
+        super.compact_blank
+      end
+
+      def participatory_space_manifests
+        super.compact_blank
+      end
+
+      def filter_items
+        taxonomy_items.map do |item|
+          Decidim::TaxonomyFilterItem.new(taxonomy_item_id: item)
+        end
+      end
+
+      def items_collection
+        return [] unless root_taxonomy
+
+        @items_collection ||= map_items_collection(root_taxonomy)
+      end
+
+      def root_taxonomy
+        @root_taxonomy ||= current_organization.taxonomies.find_by(id: root_taxonomy_id)
+      end
+
+      def available_participatory_space_manifests
+        @participatory_space_manifests ||= Decidim.participatory_space_manifests.map do |manifest|
+          Manifest.new(
+            id: manifest.name.to_s,
+            name: I18n.t("decidim.admin.taxonomy_filters.space_filter_for.#{manifest.name}")
+          )
+        end
+      end
+
+      private
+
+      def map_items_collection(taxonomy)
+        taxonomy.children.map do |item|
+          Item.new(
+            name: translated_attribute(item.name),
+            value: item.id,
+            children: map_items_collection(item)
+          )
+        end
+      end
+
+      def valid_taxonomy_items
+        return if taxonomy_items.all? do |item|
+          next unless root_taxonomy
+
+          root_taxonomy.all_children.map(&:id).include?(item.to_i)
+        end
+
+        errors.add(:taxonomy_items, :invalid)
+      end
+    end
+  end
+end

data/app/forms/decidim/admin/taxonomy_form.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A form object to be used when creating or updating a taxonomy.
+    class TaxonomyForm < Decidim::Form
+      include Decidim::TranslatableAttributes
+
+      mimic :taxonomy
+
+      translatable_attribute :name, String
+
+      validates :name, translatable_presence: true
+
+      alias organization current_organization
+
+      def parent_id = nil
+    end
+  end
+end

data/app/forms/decidim/admin/taxonomy_item_form.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # A form object to be used when creating or updating a taxonomy.
+    class TaxonomyItemForm < Decidim::Form
+      include Decidim::TranslatableAttributes
+
+      mimic :taxonomy
+
+      # we do not use "name" here to avoid collisions when using foundation tabs for multilingual fields tabs
+      # as this is used in a modal and the name identifier is used for the root taxonomy
+      translatable_attribute :item_name, String
+      attribute :parent_id, Integer
+
+      validates :item_name, translatable_presence: true
+      validate :validate_parent_id_within_same_root_taxonomy
+
+      alias name item_name
+
+      def map_model(model)
+        self.item_name = model.name
+      end
+
+      def self.from_params(params, additional_params = {})
+        additional_params[:taxonomy] = {}
+        if params[:taxonomy]
+          params[:taxonomy].each do |key, value|
+            additional_params[:taxonomy][key[8..]] = value if key.start_with?("item_name_")
+          end
+        end
+        super
+      end
+
+      def validate_parent_id_within_same_root_taxonomy
+        if parent
+          current_root_taxonomy = if parent.root?
+                                    parent
+                                  else
+                                    parent.root_taxonomy
+                                  end
+
+          errors.add(:parent_id, :invalid) unless parent.root_taxonomy.id == current_root_taxonomy.id
+        else
+          errors.add(:parent_id, :invalid)
+        end
+      end
+
+      def parent
+        @parent ||= Decidim::Taxonomy.find_by(id: parent_id)
+      end
+    end
+  end
+end

data/app/helpers/decidim/admin/application_helper.rb

@@ -13,7 +13,6 @@ module Decidim
       include Decidim::MapHelper
       include Decidim::Admin::LogRenderHelper
       include Decidim::Admin::UserRolesHelper
-      include Decidim::Admin::ResourceScopeHelper
       include Decidim::Admin::SearchFormHelper
 
       # Public: Overwrites the `cell` helper method to automatically set some

data/app/helpers/decidim/admin/bulk_actions_helper.rb

@@ -3,37 +3,6 @@
 module Decidim
   module Admin
     module BulkActionsHelper
-      # Public: Generates a select field with the categories. Only leaf categories can be set as selected.
-      #
-      # categories - A collection of categories.
-      #
-      # Returns a String.
-      def bulk_categories_select(collection)
-        categories = bulk_categories_for_select collection
-        prompt = t("decidim.proposals.admin.proposals.index.change_category")
-        select(:category, :id, options_for_select(categories, selected: []), prompt:)
-      end
-
-      def bulk_categories_for_select(scope)
-        sorted_main_categories = scope.first_class.includes(:subcategories).sort_by do |category|
-          translated_attribute(category.name, category.participatory_space.organization)
-        end
-
-        sorted_main_categories.flat_map do |category|
-          parent = [[translated_attribute(category.name, category.participatory_space.organization), category.id]]
-
-          sorted_subcategories = category.subcategories.sort_by do |subcategory|
-            translated_attribute(subcategory.name, subcategory.participatory_space.organization)
-          end
-
-          sorted_subcategories.each do |subcategory|
-            parent << ["- #{translated_attribute(subcategory.name, subcategory.participatory_space.organization)}", subcategory.id]
-          end
-
-          parent
-        end
-      end
-
       # Public: Generates a select field with the components.
       #
       # siblings - A collection of components.

data/app/helpers/decidim/admin/moderations/reports_helper.rb

@@ -14,7 +14,7 @@ module Decidim
         def reportable_author_name(reportable)
           reportable_authors = reportable.try(:authors) || [reportable.try(:normalized_author)]
           content_tag :ul, class: "reportable-authors" do
-            reportable_authors.select(&:present?).map do |author|
+            reportable_authors.compact_blank.map do |author|
               case author
               when User
                 content_tag :li do

data/app/helpers/decidim/admin/moderations_helper.rb

@@ -13,7 +13,7 @@ module Decidim
 
             attribute_value
           end
-          reportable_content.filter(&:present?).join(". ").truncate(options.fetch(:limit, 100))
+          reportable_content.compact_blank.join(". ").truncate(options.fetch(:limit, 100))
         end
       end
 

data/app/helpers/decidim/admin/newsletters_helper.rb

@@ -4,6 +4,13 @@ module Decidim
   module Admin
     # This module includes helpers to manage newsletters in admin layout
     module NewslettersHelper
+      def find_verification_types_for_select(organization)
+        available_verifications = organization.available_authorizations
+        available_verifications.map do |verification_type|
+          [t("decidim.authorization_handlers.#{verification_type}.name"), verification_type]
+        end
+      end
+
       def participatory_spaces_for_select(form_object)
         content_tag :div do
           @form.participatory_space_types.each do |space_type|
@@ -17,22 +24,32 @@ module Decidim
 
         html = ""
         form_object.fields_for "participatory_space_types[#{space_type.manifest_name}]", space_type do |ff|
+          html += participatory_space_title(space_type)
           html += ff.hidden_field :manifest_name, value: space_type.manifest_name
           html += select_tag_participatory_spaces(space_type.manifest_name, spaces_for_select(space_type.manifest_name.to_sym), ff)
         end
         html.html_safe
       end
 
+      def participatory_space_title(space_type)
+        return unless space_type
+
+        content_tag :h4 do
+          t("activerecord.models.decidim/#{space_type.manifest_name.singularize}.other")
+        end
+      end
+
       def select_tag_participatory_spaces(manifest_name, spaces, child_form)
         return unless spaces
 
-        content_tag :div, class: "#{manifest_name}-block spaces-block-tag cell small-12 medium-6" do
-          child_form.select :ids, options_for_select(spaces),
-                            { prompt: t("select_recipients_to_deliver.none", scope: "decidim.admin.newsletters"),
-                              label: t("activerecord.models.decidim/#{manifest_name.singularize}.other"),
-                              include_hidden: false },
-                            multiple: true, size: [spaces.size, 10].min, class: "chosen-select"
-        end
+        raw(cell("decidim/admin/multi_select_picker", nil, context: {
+                   select_id: "#{manifest_name}-spaces-select",
+                   field_name: "#{child_form.object_name}[ids][]",
+                   options_for_select: spaces,
+                   selected_values: selected_options(:participatory_space_types)[manifest_name] || [],
+                   placeholder: t("select_recipients_to_deliver.select_#{manifest_name}", scope: "decidim.admin.newsletters"),
+                   class: "mb-2"
+                 }))
       end
 
       def spaces_for_select(manifest_name)
@@ -45,21 +62,35 @@ module Decidim
       def selective_newsletter_to(newsletter)
         return content_tag(:strong, t("index.not_sent", scope: "decidim.admin.newsletters"), class: "text-warning") unless newsletter.sent?
         return content_tag(:strong, t("index.all_users", scope: "decidim.admin.newsletters"), class: "text-success") if newsletter.sent? && newsletter.extended_data.blank?
+        return sent_to_verified_users(newsletter) if newsletter.sent_to_verified_users?
 
         content_tag :div do
           concat sent_to_users newsletter
           concat sent_to_spaces newsletter
-          concat sent_to_scopes newsletter
         end
       end
 
       def sent_to_users(newsletter)
         content_tag :p, style: "margin-bottom:0;" do
           concat content_tag(:strong, t("index.has_been_sent_to", scope: "decidim.admin.newsletters"), class: "text-success")
-          concat content_tag(:strong, t("index.all_users", scope: "decidim.admin.newsletters")) if newsletter.sended_to_all_users?
-          concat content_tag(:strong, t("index.followers", scope: "decidim.admin.newsletters")) if newsletter.sended_to_followers?
-          concat t("index.and", scope: "decidim.admin.newsletters") if newsletter.sended_to_followers? && newsletter.sended_to_participants?
-          concat content_tag(:strong, t("index.participants", scope: "decidim.admin.newsletters")) if newsletter.sended_to_participants?
+
+          recipients = []
+
+          recipients << content_tag(:strong, t("index.all_users", scope: "decidim.admin.newsletters")) if newsletter.sent_to_all_users?
+          recipients << content_tag(:strong, t("index.verified_users", scope: "decidim.admin.newsletters")) if newsletter.sent_to_verified_users?
+          recipients << content_tag(:strong, t("index.followers", scope: "decidim.admin.newsletters")) if newsletter.sent_to_followers?
+          recipients << content_tag(:strong, t("index.participants", scope: "decidim.admin.newsletters")) if newsletter.sent_to_participants?
+          recipients << content_tag(:strong, t("index.private_members", scope: "decidim.admin.newsletters")) if newsletter.sent_to_private_members?
+
+          concat recipients.join(t("index.and", scope: "decidim.admin.newsletters")).html_safe
+        end
+      end
+
+      def sent_to_verified_users(newsletter)
+        content_tag :p, style: "margin-bottom:0;" do
+          concat content_tag(:strong, t("index.has_been_sent_to", scope: "decidim.admin.newsletters"), class: "text-success")
+          concat content_tag(:strong, t("index.verified_users", scope: "decidim.admin.newsletters"))
+          concat content_tag(:p, t("index.verification_types", scope: "decidim.admin.newsletters", types: selected_verification_types(newsletter)))
         end
       end
 
@@ -68,12 +99,14 @@ module Decidim
         newsletter.sent_to_participatory_spaces.try(:each) do |type|
           next if type["ids"].blank?
 
+          ids = parse_ids(type["ids"])
+
           html += t("index.segmented_to", scope: "decidim.admin.newsletters", subject: t("activerecord.models.decidim/#{type["manifest_name"].singularize}.other"))
-          if type["ids"].include?("all")
+          if ids.include?("all")
             html += "<strong> #{t("index.all", scope: "decidim.admin.newsletters")} </strong>"
           else
             Decidim.find_participatory_space_manifest(type["manifest_name"].to_sym)
-                   .participatory_spaces.call(current_organization).where(id: type["ids"]).each do |space|
+                   .participatory_spaces.call(current_organization).where(id: ids).each do |space|
               html += "<strong>#{decidim_escape_translated(space.title)}</strong>"
             end
           end
@@ -83,19 +116,6 @@ module Decidim
         html.html_safe
       end
 
-      def sent_to_scopes(newsletter)
-        content_tag :p, style: "margin-bottom:0;" do
-          concat t("index.segmented_to", scope: "decidim.admin.newsletters", subject: nil)
-          if newsletter.sent_scopes.any?
-            newsletter.sent_scopes.each do |scope|
-              concat content_tag(:strong, decidim_escape_translated(scope.name).to_s)
-            end
-          else
-            concat content_tag(:strong, t("index.no_scopes", scope: "decidim.admin.newsletters"))
-          end
-        end
-      end
-
       def organization_participatory_space(manifest_name)
         @organization_participatory_spaces ||= {}
         @organization_participatory_spaces[manifest_name] ||= Decidim
@@ -144,6 +164,16 @@ module Decidim
           body:
         }
       end
+
+      def parse_ids(ids)
+        ids.size == 1 && ids.first.is_a?(String) ? ids.first.split.map(&:strip) : ids
+      end
+
+      def selected_verification_types(newsletter)
+        newsletter.sent_to_users_with_verification_types&.map do |type|
+          I18n.t("decidim.authorization_handlers.#{type}.name")
+        end&.join(", ")
+      end
     end
   end
 end

data/app/helpers/decidim/admin/scopes_helper.rb

@@ -32,12 +32,6 @@ module Decidim
             Option.new(scope_type.id, translated_attribute(scope_type.name))
           end
       end
-
-      def organization_scope_depths(organization = current_organization)
-        organization.scope_types.map do |scope_type|
-          Option.new(scope_type.id, translated_attribute(scope_type.name))
-        end.reverse
-      end
     end
   end
 end

data/app/helpers/decidim/admin/search_form_helper.rb

@@ -12,7 +12,7 @@ module Decidim
       def search_form_for(record, options = {}, &)
         options[:builder] ||= SearchFormBuilder
 
-        super(record, options, &)
+        super
       end
     end
   end