decidim-core 0.29.4 → 0.30.0.rc1

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,14 +41,12 @@ module Decidim
     end
 
     def parse_i18n_changeset(attribute, values, type, diff)
-      return diff unless values.last.is_a?(Hash)
-
       (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:,

data/app/services/decidim/download_your_data_exporter.rb

@@ -1,41 +1,52 @@
 # frozen_string_literal: true
 
-require "decidim/seven_zip_wrapper"
-
 module Decidim
-  # Public: Generates a 7z(seven zip) file with data files ready to be persisted
+  # Public: Generates a zip archive with data files ready to be persisted
   # somewhere so users can download their data.
   #
-  # In fact, the 7z file wraps a ZIP file which finally contains the data files.
   class DownloadYourDataExporter
     DEFAULT_EXPORT_FORMAT = "CSV"
     ZIP_FILE_NAME = "download-your-data.zip"
 
+    include Decidim::TranslatableAttributes
+
     # Public: Initializes the class.
     #
     # user          - The user to export the data from.
-    # path          - The String path where to write the zip file.
-    # password      - The password to protect the zip file.
+    # name          - The name of the export in private area
     # export_format - The format of the data files inside the zip file. (CSV by default)
-    def initialize(user, path, password, export_format = DEFAULT_EXPORT_FORMAT)
+    def initialize(user, name, export_format = DEFAULT_EXPORT_FORMAT)
       @user = user
-      @path = File.expand_path path
       @export_format = export_format
-      @password = password
+      @name = name
     end
 
+    # i18n-tasks-use t("decidim.download_your_data.show.download_your_data")
     def export
-      tmpdir = Dir.mktmpdir("temporary-download-your-data-dir")
-      user_data, user_attachments = data_and_attachments_for_user
-      save_user_data(tmpdir, user_data)
-      save_user_attachments(tmpdir, user_attachments)
-
-      SevenZipWrapper.compress_and_encrypt(filename: @path, password: @password, input_directory: tmpdir)
+      user_export = user.private_exports.build
+      user_export.export_type = name
+      user_export.file.attach(io: data, filename: "#{name}.zip", content_type: "application/zip")
+      user_export.expires_at = Decidim.download_your_data_expiry_time.from_now
+      user_export.metadata = {}
+      user_export.save!
+      user_export
     end
 
     private
 
-    attr_reader :user, :export_format
+    attr_reader :user, :export_format, :name
+
+    def data
+      user_data, user_attachments = data_and_attachments_for_user
+      buffer = Zip::OutputStream.write_buffer do |out|
+        save_user_data(out, user_data)
+        save_user_attachments(out, user_attachments)
+        save_readme(out)
+      end
+
+      buffer.rewind
+      buffer
+    end
 
     def data_and_attachments_for_user
       export_data = []
@@ -43,7 +54,8 @@ module Decidim
 
       download_your_data_entities.each do |object|
         klass = Object.const_get(object)
-        export_data << [klass.model_name.name.parameterize.pluralize, Exporters.find_exporter(export_format).new(klass.user_collection(user), klass.export_serializer).export]
+        exporter = Exporters.find_exporter(export_format).new(klass.user_collection(user), klass.export_serializer)
+        export_data << [klass.model_name.name.parameterize.pluralize, exporter.export]
         attachments = klass.download_your_data_images(user)
         export_attachments << [klass.model_name.name.parameterize.pluralize, attachments.flatten] unless attachments.nil?
       end
@@ -55,30 +67,52 @@ module Decidim
       @download_your_data_entities ||= DownloadYourDataSerializers.data_entities
     end
 
-    def save_user_data(tmpdir, user_data)
+    def save_user_data(output, user_data)
       user_data.each do |entity, exporter_data|
         next if exporter_data.read == "\n"
 
-        file_name = File.join(tmpdir, "#{entity}-#{exporter_data.filename}")
-        File.write(file_name, exporter_data.read)
+        output.put_next_entry("#{entity}-#{exporter_data.filename}")
+        output.write exporter_data.read
       end
     end
 
-    def save_user_attachments(tmpdir, user_attachments)
+    def save_user_attachments(output, user_attachments)
       user_attachments.each do |entity, attachment_block|
         attachment_block.each do |attachment|
           next unless attachment.attached?
 
           blobs = attachment.is_a?(ActiveStorage::Attached::One) ? [attachment.blob] : attachment.blobs
           blobs.each do |blob|
-            Dir.mkdir(File.join(tmpdir, entity.parameterize))
-            file_name = File.join(tmpdir, entity.parameterize, blob.filename.to_s)
             blob.open do |blob_file|
-              File.write(file_name, blob_file.read.force_encoding("UTF-8"))
+              output.put_next_entry("#{entity.parameterize}/#{blob.filename}")
+              output.write blob_file.read.force_encoding("UTF-8")
             end
           end
         end
       end
     end
+
+    def save_readme(output)
+      output.put_next_entry("README.md")
+      output.write readme
+    end
+
+    def readme
+      readme_file = "# #{I18n.t("decidim.download_your_data.help.core.title", organization: translated_attribute(user.organization.name))}\n\n"
+      readme_file << "#{I18n.t("decidim.download_your_data.help.core.description", user_name: "#{user.name} (#{user.nickname})")}\n\n"
+      help_definition = DownloadYourDataSerializers.help_definitions_for(user)
+
+      help_definition.each do |entity, headers|
+        next if headers.empty?
+
+        readme_file << "\n\n## #{entity}\n\n"
+
+        headers.each do |header, help_value|
+          readme_file << "* #{header}: #{help_value}\n"
+        end
+      end
+
+      readme_file
+    end
   end
 end