decidim-core 0.29.1 → 0.30.0.rc1

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    class OpenDataMetricSerializer < 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
+        {
+          day: resource.day,
+          metric_type: resource.metric_type,
+          cumulative: resource.cumulative,
+          quantity: resource.quantity
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    class OpenDataModerationSerializer < 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
+        {
+          id: resource.id,
+          hidden_at: resource.hidden_at,
+          report_count: resource.report_count,
+          reported_url: resource.reportable.reported_content_url,
+          reportable_type: resource.decidim_reportable_type,
+          reportable_id: resource.decidim_reportable_id,
+          reported_content: resource.reported_content,
+          reports: {
+            reasons: resource.reports.map(&:reason),
+            locale: resource.reports.map(&:locale),
+            details: resource.reports.map(&:details)
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    class OpenDataTaxonomySerializer < 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
+        {
+          id: resource.id,
+          name: resource.name,
+          parent_id: resource.parent_id,
+          weight: resource.weight,
+          children_count: resource.children_count,
+          taxonomizations_count: resource.taxonomizations_count,
+          created_at: resource.created_at,
+          updated_at: resource.updated_at,
+          filters_count: resource.filters_count,
+          filter_items_count: resource.filter_items_count,
+          part_of: resource.part_of,
+          is_root: resource.root?
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    class OpenDataUserGroupSerializer < 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
+        {
+          id: resource.id,
+          name: presented.name,
+          nickname: presented.nickname,
+          avatar_url: presented.avatar_url(:thumb),
+          profile_url: presented.profile_url,
+          deleted: presented.deleted?,
+          badge: presented.badge,
+          members_count: resource.accepted_memberships.count,
+          members: {
+            id: resource.accepted_users.collect(&:id),
+            name: resource.accepted_users.collect(&:name)
+          }
+        }
+      end
+
+      private
+
+      attr_reader :resource
+
+      def presented
+        @presented ||= resource.presenter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    class OpenDataUserSerializer < 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
+        {
+          id: resource.id,
+          name: presented.name,
+          nickname: presented.nickname,
+          about: presented.about,
+          avatar_url: presented.avatar_url(:thumb),
+          profile_url: presented.profile_url,
+          direct_messages_enabled: (resource.direct_message_types != "followed-only"),
+          deleted: presented.deleted?,
+          badge: presented.badge,
+          groups: {
+            id: resource.accepted_user_groups.collect(&:id),
+            name: resource.accepted_user_groups.collect(&:name)
+          }
+        }
+      end
+
+      private
+
+      attr_reader :resource
+
+      def presented
+        @presented ||= resource.presenter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Exporters
+    # This class serves as the base class for the serializers that export
+    # participatory spaces.
+    class ParticipatorySpaceSerializer < Decidim::Exporters::Serializer
+      include Decidim::ApplicationHelper
+      include Decidim::ResourceHelper
+      include Decidim::TranslationsHelper
+
+      # 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
+        {
+          id: resource.id,
+          title: resource.title,
+          slug: resource.slug,
+          reference: resource.reference,
+          created_at: resource.created_at,
+          updated_at: resource.updated_at,
+          published_at: resource.published_at,
+          follows_count: resource.follows_count,
+          hashtag: resource.hashtag,
+          short_description: resource.short_description,
+          description: resource.description,
+          promoted: resource.promoted
+        }
+      end
+
+      private
+
+      attr_reader :resource
+
+      def serialize_categories
+        return unless resource.categories.first_class.any?
+
+        resource.categories.first_class.map do |category|
+          {
+            id: category.try(:id),
+            name: category.try(:name),
+            description: category.try(:description),
+            parent_id: category.try(:parent_id),
+            subcategories: serialize_subcategories(category.subcategories)
+          }
+        end
+      end
+
+      def serialize_subcategories(subcategories)
+        return unless subcategories.any?
+
+        subcategories.map do |subcategory|
+          {
+            id: subcategory.try(:id),
+            name: subcategory.try(:name),
+            description: subcategory.try(:description),
+            parent_id: subcategory.try(:parent_id)
+          }
+        end
+      end
+
+      def serialize_attachment_collections
+        return unless resource.attachment_collections.any?
+
+        resource.attachment_collections.map do |collection|
+          {
+            id: collection.try(:id),
+            name: collection.try(:name),
+            weight: collection.try(:weight),
+            description: collection.try(:description)
+          }
+        end
+      end
+
+      def serialize_attachments
+        return unless resource.attachments.any?
+
+        resource.attachments.map do |attachment|
+          {
+            id: attachment.try(:id),
+            title: attachment.try(:title),
+            weight: attachment.try(:weight),
+            description: attachment.try(:description),
+            attachment_collection: {
+              name: attachment.attachment_collection.try(:name),
+              weight: attachment.attachment_collection.try(:weight),
+              description: attachment.attachment_collection.try(:description)
+            },
+            remote_file_url: Decidim::AttachmentPresenter.new(attachment).attachment_file_url
+          }
+        end
+      end
+
+      def serialize_components
+        serializer = Decidim::Exporters::ParticipatorySpaceComponentsSerializer.new(resource)
+        serializer.run
+      end
+    end
+  end
+end

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

@@ -54,6 +54,31 @@ module Decidim
       def event_name
         ActiveSupport::Inflector.underscore(self.class.to_s).sub("/", ".serialize.").gsub("/", ".")
       end
+
+      protected
+
+      delegate :component, to: :resource
+
+      def profile_url(user)
+        return "" if user.respond_to?(:deleted?) && user.deleted?
+
+        EngineRouter.new("decidim", { host: }).profile_url(user.nickname)
+      end
+
+      def root_url
+        Decidim::Core::Engine.routes.url_helpers.root_url(host:)
+      end
+
+      def host
+        resource.organization.host
+      end
+
+      # helper method to serialize taxonomies for any resource
+      def taxonomies
+        {
+          ids: resource.taxonomies.map(&:id)
+        }.merge(resource.taxonomies.to_h { |taxonomy| [taxonomy.id, taxonomy.name] })
+      end
     end
   end
 end

data/app/serializers/decidim/schema_org_breadcrumb_list_serializer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Decidim
+  class SchemaOrgBreadcrumbListSerializer < Decidim::Exporters::Serializer
+    include Decidim::SanitizeHelper
+
+    # Public: Initializes the serializer with a list of breadcrumb items.
+    def initialize(options)
+      @breadcrumb_items = options[:breadcrumb_items]
+      @base_url = options[:base_url]
+      @organization_name = options[:organization_name]
+    end
+
+    # Serializes a breadcrumb items list for the Schema.org BreadcrumbList type
+    #
+    # @see https://schema.org/BreadcrumbList
+    # @see https://developers.google.com/search/docs/appearance/structured-data/breadcrumb?hl=en
+    def serialize
+      return {} if breadcrumb_items.none? { |item| item.has_key?(:url) }
+
+      {
+        "@context": "https://schema.org",
+        "@type": "BreadcrumbList",
+        name: "#{organization_name} breadcrumb",
+        itemListElement: breadcrumb_items_serialized
+      }
+    end
+
+    private
+
+    attr_reader :breadcrumb_items, :base_url, :organization_name
+
+    def breadcrumb_items_serialized
+      all_items = []
+
+      breadcrumb_items.each_with_index do |item, index|
+        next if item.empty?
+
+        all_items << {
+          "@type": "ListItem",
+          position: index + 1,
+          name: decidim_sanitize_translated(item[:label]),
+          item: URI.join(base_url, item[:url]).to_s
+        }
+      end
+
+      all_items
+    end
+  end
+end

data/app/services/decidim/action_authorizer.rb

@@ -88,23 +88,32 @@ module Decidim
       def unauthorized?
         @code == :unauthorized
       end
+
+      def ephemeral?
+        @authorization_handler.ephemeral?
+      end
     end
 
     class AuthorizationStatusCollection
       attr_reader :statuses
 
       def initialize(authorization_handlers, user, component, resource)
+        @ephemeral_user = user&.ephemeral?
         @authorization_handlers = authorization_handlers
-        @statuses = authorization_handlers&.map do |name, opts|
+        @statuses = authorization_handlers&.filter_map do |name, opts|
           handler = Verifications::Adapter.from_element(name)
+          next if @ephemeral_user && !handler.ephemeral?
+
           authorization = user ? Verifications::Authorizations.new(organization: user.organization, user:, name:).first : nil
           status_code, data = handler.authorize(authorization, opts["options"], component, resource)
           AuthorizationStatus.new(status_code, handler, data)
-        end
+        end || []
       end
 
       def ok?
-        return true if statuses.blank?
+        # When no statuses are present for the action ephemeral users
+        # are not allowed to perform the action
+        return !@ephemeral_user if statuses.blank?
 
         statuses.all?(&:ok?)
       end
@@ -126,6 +135,26 @@ module Decidim
       def codes
         @codes ||= statuses.map(&:code)
       end
+
+      def pending_authorizations_count
+        return 0 if @statuses.blank?
+
+        @statuses.count
+      end
+
+      def single_authorization_required?
+        pending_authorizations_count == 1 && [:ok, :unauthorized].exclude?(global_code)
+      end
+
+      def ephemeral?
+        return if statuses.blank?
+
+        statuses.all?(&:ephemeral?)
+      end
+
+      def user_pending?
+        !global_code && statuses.any? { |status| [:missing, :expired, :incomplete].include?(status.code) }
+      end
     end
 
     class AuthorizationError < StandardError; end

data/app/services/decidim/base_diff_renderer.rb

@@ -41,12 +41,12 @@ module Decidim
     end
 
     def parse_i18n_changeset(attribute, values, type, diff)
-      values.last.keys.each do |locale, _value|
+      (values.last.keys - ["machine_translations"]).each do |locale, _value|
         first_value = values.first.try(:[], locale)
         last_value = values.last.try(:[], locale)
         next if first_value == last_value
 
-        attribute_locale = "#{attribute}_#{locale}".to_sym
+        attribute_locale = :"#{attribute}_#{locale}"
         diff.update(
           attribute_locale => {
             type:,
@@ -56,6 +56,27 @@ module Decidim
           }
         )
       end
+
+      return diff unless values.last.has_key?("machine_translations")
+
+      values.last.fetch("machine_translations").each_key do |locale, _value|
+        next unless I18n.available_locales.include?(locale.to_sym)
+
+        first_value = values.first.try(:[], "machine_translations").try(:[], locale)
+        last_value = values.last.try(:[], "machine_translations").try(:[], locale)
+
+        attribute_locale = :"#{attribute}_machine_translations_#{locale}"
+
+        diff.update(
+          attribute_locale => {
+            type:,
+            label: generate_i18n_label(attribute, locale, "decidim.machine_translations.automatic"),
+            old_value: first_value,
+            new_value: last_value
+          }
+        )
+      end
+
       diff
     end
 
@@ -108,7 +129,8 @@ module Decidim
     end
 
     # Returns a String.
-    def generate_i18n_label(attribute, locale)
+    # i18n-tasks-use t("decidim.machine_translations.automatic")
+    def generate_i18n_label(attribute, locale, postfix = "")
       label = I18n.t(attribute, scope: i18n_scope)
       locale_name = if I18n.available_locales.include?(locale.to_sym)
                       I18n.t("locale.name", locale:)
@@ -116,6 +138,8 @@ module Decidim
                       locale
                     end
 
+      locale_name = I18n.t(postfix, locale_name:, locale:) if postfix.present?
+
       "#{label} (#{locale_name})"
     end