decidim-core 0.29.4 → 0.30.0.rc1

data/app/presenters/decidim/admin_log/share_token_presenter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AdminLog
+    # This class extends the default resource presenter for logs, so that
+    # it can properly link to the static page.
+    class ShareTokenPresenter < Decidim::Log::BasePresenter
+      private
+
+      def diff_fields_mapping
+        {
+          token: :string,
+          expires_at: :date,
+          registered_only: :boolean,
+          token_for: :string
+        }
+      end
+
+      def action_string
+        case action
+        when "create", "delete", "update"
+          "decidim.admin_log.share_token.#{action}#{suffix}"
+        else
+          super
+        end
+      end
+
+      def suffix
+        return "_with_space" if action_log.extra.dig("component", "title").present?
+
+        ""
+      end
+
+      def diff_actions
+        %w(update create delete)
+      end
+    end
+  end
+end

data/app/presenters/decidim/admin_log/taxonomy_filter_presenter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AdminLog
+    # This class holds the logic to present a `Decidim::Taxonomy`
+    # for the `AdminLog` log.
+    #
+    # Usage should be automatic and you should not need to call this class
+    # directly, but here is an example:
+    #
+    #    action_log = Decidim::ActionLog.last
+    #    view_helpers # => this comes from the views
+    #    TaxonomyFilterPresenter.new(action_log, view_helpers).present
+    class TaxonomyFilterPresenter < Decidim::Log::BasePresenter
+      include Decidim::SanitizeHelper
+
+      private
+
+      def diff_fields_mapping
+        {
+          name: :i18n,
+          internal_name: :i18n,
+          root_taxonomy_id: :taxonomy,
+          participatory_space_manifests: :array
+        }
+      end
+
+      def action_string
+        case action
+        when "create", "delete", "update"
+          if filter_items_count.present? && taxonomy_name.present?
+            "decidim.admin_log.taxonomy_filter.#{action}_with_filter_info"
+          else
+            "decidim.admin_log.taxonomy_filter.#{action}"
+          end
+        else
+          super
+        end
+      end
+
+      def i18n_params
+        super.merge(
+          filter_items_count:,
+          taxonomy_name: decidim_escape_translated(taxonomy_name)
+        )
+      end
+
+      def filter_items_count
+        action_log.extra.dig("extra", "filter_items_count")
+      end
+
+      def taxonomy_name
+        action_log.extra.dig("extra", "taxonomy_name")
+      end
+    end
+  end
+end

data/app/presenters/decidim/admin_log/taxonomy_presenter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AdminLog
+    # This class holds the logic to present a `Decidim::Taxonomy`
+    # for the `AdminLog` log.
+    #
+    # Usage should be automatic and you should not need to call this class
+    # directly, but here is an example:
+    #
+    #    action_log = Decidim::ActionLog.last
+    #    view_helpers # => this comes from the views
+    #    TaxonomyPresenter.new(action_log, view_helpers).present
+    class TaxonomyPresenter < Decidim::Log::BasePresenter
+      private
+
+      def diff_fields_mapping
+        {
+          name: :i18n,
+          parent_id: :taxonomy
+        }
+      end
+
+      def action_string
+        case action
+        when "create", "delete", "update"
+          if parent_name.present?
+            "decidim.admin_log.taxonomy.#{action}_with_parent"
+          else
+            "decidim.admin_log.taxonomy.#{action}"
+          end
+        else
+          super
+        end
+      end
+
+      def i18n_params
+        super.merge(
+          parent_taxonomy: h.translated_attribute(parent_name)
+        )
+      end
+
+      def parent_name
+        action_log.extra.dig("extra", "parent_name")
+      end
+    end
+  end
+end

data/app/presenters/decidim/admin_log/user_group_presenter.rb

@@ -11,21 +11,21 @@ module Decidim
     #    action_log = Decidim::ActionLog.last
     #    view_helpers # => this comes from the views
     #    UserGroupPresenter.new(action_log, view_helpers).present
-    class UserGroupPresenter < Decidim::Log::BasePresenter
+    class UserGroupPresenter < BaseUserPresenter
       private
 
-      def has_diff?
-        false
-      end
-
       def action_string
         case action
-        when "verify", "verify_via_csv", "reject", "block", "unblock"
+        when "verify", "verify_via_csv", "reject", "block", "unblock", "bulk_block", "bulk_unblock", "bulk_ignore"
           "decidim.admin_log.user_group.#{action}"
         else
           super
         end
       end
+
+      def diff_actions
+        %w(bulk_block bulk_unblock bulk_ignore)
+      end
     end
   end
 end

data/app/presenters/decidim/admin_log/user_presenter.rb

@@ -11,12 +11,13 @@ module Decidim
     #    action_log = Decidim::ActionLog.last
     #    view_helpers # => this comes from the views
     #    UserPresenter.new(action_log, view_helpers).present
-    class UserPresenter < Decidim::Log::BasePresenter
+    class UserPresenter < BaseUserPresenter
       private
 
       def action_string
         case action
-        when "grant_id_documents_offline_verification", "invite", "officialize", "remove_from_admin", "show_email", "unofficialize", "block", "unblock", "promote", "transfer"
+        when "grant_id_documents_offline_verification", "invite", "officialize", "remove_from_admin",
+              "show_email", "unofficialize", "block", "unblock", "bulk_block", "bulk_unblock", "promote", "transfer", "bulk_ignore"
           "decidim.admin_log.user.#{action}"
         else
           super
@@ -45,23 +46,8 @@ module Decidim
         action_log.extra.dig("extra", "previous_justification") || ""
       end
 
-      def current_justification
-        action_log.extra.dig("extra", "current_justification") || Hash.new("")
-      end
-
-      # Overwrite the changeset for officialization and block actions.
-      def changeset
-        original = { badge: [previous_user_badge, user_badge] }
-        fields = { badge: :i18n }
-        if action.to_s == "block"
-          original = { justification: [previous_justification, current_justification] }
-          fields = { justification: :string }
-        end
-        Decidim::Log::DiffChangesetCalculator.new(original, fields, i18n_labels_scope).changeset
-      end
-
       def diff_actions
-        %w(officialize unofficialize block)
+        %w(officialize unofficialize block bulk_block bulk_unblock bulk_ignore)
       end
     end
   end

data/app/presenters/decidim/log/user_presenter.rb

@@ -46,7 +46,6 @@ module Decidim
       # Returns an HTML-safe String.
       def present_user
         return h.content_tag(:span, present_user_name, class: "logs__log__author") if user.blank?
-        return I18n.t("decidim.profile.deleted") if user.respond_to?(:deleted?) && user.deleted?
 
         h.link_to(
           present_user_name,

data/app/presenters/decidim/log/value_types/date_presenter.rb

@@ -12,6 +12,7 @@ module Decidim
         # Returns an HTML-safe String.
         def present
           return unless value
+          return h.l(Date.parse(value), format: :long) if value.is_a?(::String)
 
           h.l(value, format: :long)
         end

data/app/presenters/decidim/log/value_types/taxonomy_presenter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Log
+    module ValueTypes
+      # This class presents the given value as a Decidim::Taxonomy. Check
+      # the `DefaultPresenter` for more info on how value
+      # presenters work.
+      class TaxonomyPresenter < DefaultPresenter
+        # Public: Presents the value as a Decidim::Taxonomy. If the taxonomy can
+        # be found, it shows its title. Otherwise it shows its ID.
+        #
+        # Returns an HTML-safe String.
+        def present
+          return unless value
+          return h.translated_attribute(taxonomy.name) if taxonomy
+
+          I18n.t("not_found", id: value, scope: "decidim.log.value_types.taxonomy_presenter")
+        end
+
+        private
+
+        def taxonomy
+          @taxonomy ||= Decidim::Taxonomy.find_by(id: value)
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/notification_to_mailer_presenter.rb

@@ -14,19 +14,15 @@ module Decidim
     delegate :url_helpers, to: "Decidim::Core::Engine.routes"
     delegate :resource_title, to: :event
     delegate :resource_url, to: :event
+    delegate :email_intro, to: :event
     delegate :resource_path, to: :event
     delegate :safe_resource_text, to: :event
 
-    def email_intro
-      event.email_intro if event.respond_to?(:email_intro)
-    end
-
     def date_time
-      created_at_in_time_zone = created_at.in_time_zone(resource.organization.time_zone)
       if frequency == :daily
-        I18n.l(created_at_in_time_zone, format: :time_of_day)
+        created_at.strftime("%H:%M")
       else
-        I18n.l(created_at_in_time_zone, format: :decidim_short)
+        I18n.l(created_at, format: :decidim_short)
       end
     end
 

data/app/presenters/decidim/participatory_space_private_user_presenter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # Decorator for assembly members
+  #
+  class ParticipatorySpacePrivateUserPresenter < SimpleDelegator
+    delegate :profile_url, to: :user, allow_nil: true
+
+    def name
+      user ? user.name : full_name
+    end
+
+    def nickname
+      user.nickname if user
+    end
+
+    def avatar_url(variant = nil)
+      return user.avatar_url(variant) if user.present?
+
+      non_user_avatar_path(variant)
+    end
+
+    def non_user_avatar_path(variant = nil)
+      return non_user_avatar.default_url(variant) unless non_user_avatar.attached?
+
+      non_user_avatar.path(variant:)
+    end
+
+    def non_user_avatar
+      attached_uploader(:non_user_avatar)
+    end
+
+    def has_tooltip?
+      false
+    end
+
+    def deleted?
+      false
+    end
+
+    private
+
+    def user
+      @user ||= if (user = __getobj__.user.presence)
+                  Decidim::UserPresenter.new(user)
+                end
+    end
+  end
+end

data/app/presenters/decidim/taxonomy_filter_presenter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # Decorator for taxonomies.
+  #
+  class TaxonomyFilterPresenter < SimpleDelegator
+    include Decidim::TranslationsHelper
+    include Decidim::SanitizeHelper
+
+    def translated_name
+      @translated_name ||= decidim_sanitize_translated(name)
+    end
+
+    def translated_internal_name
+      @translated_internal_name ||= decidim_sanitize_translated(internal_name)
+    end
+  end
+end

data/app/presenters/decidim/taxonomy_presenter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # Decorator for taxonomies.
+  #
+  class TaxonomyPresenter < SimpleDelegator
+    include Decidim::TranslationsHelper
+
+    def translated_name
+      @translated_name ||= translated_attribute name
+    end
+  end
+end

data/app/presenters/decidim/user_presenter.rb

@@ -37,7 +37,7 @@ module Decidim
       return default_avatar_url if __getobj__.blocked?
       return default_avatar_url unless avatar.attached?
 
-      avatar.url(variant:)
+      avatar.path(variant:)
     end
 
     def default_avatar_url

data/app/queries/decidim/last_activity.rb

@@ -18,7 +18,6 @@ module Decidim
         query = filter_moderated(query)
         query = filter_spaces(query)
         query = filter_deleted(query)
-        query = filter_withdrawn(query)
         query.with_new_resource_type("all")
       end
     end
@@ -49,30 +48,6 @@ module Decidim
       ).where(decidim_moderations: { id: nil })
     end
 
-    def filter_withdrawn(query)
-      # Filter out the items that have been withdrawn.
-      conditions = []
-
-      ActionLog.public_resource_types.each do |resource_type|
-        klass = resource_type.constantize
-
-        condition = if klass.respond_to?(:not_withdrawn)
-                      Arel.sql(
-                        [
-                          "decidim_action_logs.resource_type = '#{resource_type}'",
-                          "decidim_action_logs.resource_id IN (#{Arel.sql(klass.not_withdrawn.select(:id).to_sql)})"
-                        ].join(" AND ")
-                      ).to_s
-                    else
-                      Arel.sql("decidim_action_logs.resource_type = '#{resource_type}'").to_s
-                    end
-
-        conditions << "(#{condition})"
-      end
-
-      query.where(Arel.sql(conditions.join(" OR ")).to_s)
-    end
-
     def filter_spaces(query)
       conditions = []
 

data/app/queries/decidim/metrics/blocked_users_metric_manage.rb

@@ -14,12 +14,12 @@ module Decidim
         return @query if @query
 
         @query = Decidim::User.blocked.where(organization: @organization)
-        @query = @query.where("blocked_at <= ?", end_time)
+        @query = @query.where(blocked_at: ..end_time)
         @query
       end
 
       def quantity
-        @quantity ||= @query.where("blocked_at >= ?", start_time).count
+        @quantity ||= @query.where(blocked_at: start_time..).count
       end
     end
   end

data/app/queries/decidim/metrics/users_metric_manage.rb

@@ -15,11 +15,11 @@ module Decidim
                                 .where("deleted_at IS NULL OR deleted_at > ?", end_time)
                                 .where("blocked_at IS NULL OR blocked_at > ?", end_time)
                                 .confirmed
-                                .where("created_at <= ?", end_time)
+                                .where(created_at: ..end_time)
       end
 
       def quantity
-        @quantity ||= query.where("created_at >= ?", start_time).count
+        @quantity ||= query.where(created_at: start_time..).count
       end
     end
   end

data/app/queries/decidim/public_activities.rb

@@ -20,8 +20,6 @@ module Decidim
   # :follows - a collection of `Decidim::Follow` resources. It will return any
   #   activity affecting any of these resources, performed by any of them or
   #   contained in any of them as spaces.
-  # :scopes - a collection of `Decidim::Scope`. It will return any activity that
-  #   took place in any of those scopes.
   class PublicActivities < LastActivity
     def initialize(organization, options = {})
       @organization = organization
@@ -29,7 +27,6 @@ module Decidim
       @user = options[:user]
       @current_user = options[:current_user]
       @follows = options[:follows]
-      @scopes = options[:scopes]
     end
 
     def query
@@ -45,7 +42,7 @@ module Decidim
 
     private
 
-    attr_reader :resource_name, :user, :follows, :scopes
+    attr_reader :resource_name, :user, :follows
 
     def filter_follows(query)
       conditions = []
@@ -61,8 +58,6 @@ module Decidim
         conditions += followed_spaces_conditions(follows)
       end
 
-      conditions += interesting_scopes_conditions(scopes)
-
       return query if conditions.empty?
 
       chained_conditions = conditions.inject do |previous_condition, condition|
@@ -90,12 +85,6 @@ module Decidim
       end
     end
 
-    def interesting_scopes_conditions(interesting_scopes)
-      return [] if interesting_scopes.blank?
-
-      [Decidim::ActionLog.arel_table[:decidim_scope_id].in(interesting_scopes.map(&:id))]
-    end
-
     def participatory_space_classes
       Decidim.participatory_space_manifests.map(&:model_class_name)
     end

data/app/queries/decidim/stats_users_count.rb

@@ -16,8 +16,8 @@ module Decidim
 
     def query
       users = Decidim::User.where(organization: @organization).not_deleted.not_blocked.confirmed
-      users = users.where("created_at >= ?", @start_at) if @start_at.present?
-      users = users.where("created_at <= ?", @end_at) if @end_at.present?
+      users = users.where(created_at: @start_at..) if @start_at.present?
+      users = users.where(created_at: ..@end_at) if @end_at.present?
       users.count
     end
   end

data/app/resolvers/decidim/meta_image_url_resolver.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Resolves the most appropriate image URL for meta tags from a given resource within an organization.
+  # Searches in the following order: attachment images, images in resource description, participatory space images, and default content block images.
+  # Ensures the selected image is resized to 1200x630 pixels.
+  class MetaImageUrlResolver
+    include TranslatableAttributes
+
+    IMAGE_FIELDS = [:hero_image, :banner_image, :avatar].freeze
+    DESCRIPTION_FIELDS = [:body, :description, :short_description, :content, :additional_info].freeze
+    CONTENT_BLOCK_TYPES = {
+      { manifest_name: :hero, scope_name: :homepage } => [:background_image]
+    }.freeze
+
+    def initialize(resource, organization)
+      @resource = resource
+      @organization = organization
+    end
+
+    attr_reader :resource, :organization
+
+    # Resolves the image blob to be used for meta tags.
+    #
+    # @return [String, nil] - The resolved image blob or nil if no image is found.
+    def resolve
+      return unless blob
+
+      resized_variant = blob.variant(resize_to_limit: [1200, 630]).processed
+      Rails.application.routes.url_helpers.rails_representation_url(resized_variant, only_path: true)
+    end
+
+    # Determines the image blob to be used for meta tags by following a hierarchy.
+    #
+    # @return [ActiveStorage::Blob, nil] - The image blob or nil if no image is found.
+    def blob
+      @blob ||= blob_from_image_fields || blob_from_attachments || blob_from_description || blob_from_participatory_space || blob_from_content_blocks
+    end
+
+    private
+
+    # Fetches the image blob from the resource's attached image fields.
+    #
+    # @return [ActiveStorage::Blob, nil] - The image blob or nil if not found.
+    def blob_from_image_fields
+      IMAGE_FIELDS.each do |image_name|
+        next unless resource.respond_to?(image_name) && resource.respond_to?(:attached_uploader)
+
+        blob = blob_from_attached_file(resource.send(image_name))
+        return blob if blob.present?
+      end
+
+      nil
+    end
+
+    # Fetches the first attachment image blob.
+    #
+    # @return [ActiveStorage::Blob, nil] - The image blob or nil if not found.
+    def blob_from_attachments
+      attachment = resource.try(:attachments)&.find { |a| a.content_type.in?(%w(image/jpeg image/png image/webp)) }
+      blob_from_attached_file(attachment&.file)
+    end
+
+    # Extracts the first image blob from the resource description.
+    #
+    # @return [ActiveStorage::Blob, nil] - The image blob or nil if not found.
+    def blob_from_description
+      DESCRIPTION_FIELDS.each do |field|
+        html = resource.try(field)
+        next unless html
+
+        html = translated_attribute(html).strip if html.is_a?(Hash)
+        next if html.blank?
+
+        image_element = Nokogiri::HTML(html).css("img").first
+        next unless image_element
+
+        image_url = image_element["src"]
+        next if image_url.blank?
+
+        blob = find_blob_by_key(image_url.split("/").second_to_last)
+        return blob if blob.present?
+      end
+
+      nil
+    end
+
+    # Fetches the image blob from the participatory space.
+    #
+    # @return [ActiveStorage::Blob, nil] - The image blob or nil if not found.
+    def blob_from_participatory_space
+      participatory_space = resource.try(:participatory_space)
+      return unless participatory_space
+
+      MetaImageUrlResolver.new(participatory_space, organization).blob
+    end
+
+    # Fetches the default homepage image blob.
+    #
+    # @return [ActiveStorage::Blob, nil] - The image blob or nil if not found.
+    def blob_from_content_blocks
+      CONTENT_BLOCK_TYPES.each do |type, image_names|
+        Decidim::ContentBlock.where(type.merge(organization:)).find_each do |content_block|
+          next unless content_block.respond_to?(:images_container)
+
+          image_names.each do |image_name|
+            next unless content_block.images_container.respond_to?(image_name)
+
+            blob = blob_from_attached_file(content_block.images_container.send(image_name))
+            return blob if blob.present?
+          end
+        end
+      end
+
+      nil
+    end
+
+    def find_blob_by_key(blob_key)
+      ActiveStorage::Blob.find_signed(blob_key) if blob_key.present?
+    end
+
+    def blob_from_attached_file(file)
+      return unless file.respond_to?(:attached?) && file.attached?
+
+      file.blob
+    end
+  end
+end

data/app/serializers/decidim/exporters/open_data_blocked_user_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    class OpenDataBlockedUserSerializer < Decidim::Exporters::Serializer
+      # Public: Initializes the serializer with a resource
+      def initialize(resource)
+        @resource = resource
+      end
+
+      # Public: Exports a hash with the serialized data for this resource.
+      def serialize
+        {
+          user_id: resource.user.id,
+          blocked_at: resource.user.blocked_at,
+          about: resource.user.about,
+          reasons: resource.reports.map(&:reason),
+          details: resource.reports.map(&:details),
+          block_reasons: resource.blocking.justification,
+          blocking_user: resource.blocking.blocking_user.presenter.name
+        }
+      end
+    end
+  end
+end