decidim-core 0.27.10 → 0.28.0.rc4

data/app/models/decidim/authorization_transfer.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Decidim
+  # An authorization transfer object is created when the user authorizes
+  # themselves with the same unique ID as some other user had used in the past.
+  # Typically this can happen if the user first created an account and
+  # authorized it, then deleted their account, and finally decided to register
+  # again and authorize their account for a second time.
+  #
+  # To register an authorization transfer handler in a specific module, use the
+  # following code example.
+  #
+  # @example Register authorization handler
+  #   Decidim::AuthorizationTransfer.register(:my_module) do |transfer, auth_handler|
+  #     # The move_records method updates the provided active record objects
+  #     # to be mapped to the new user for which the authorization is being
+  #     # transferred to. Provide the record class and the column name which
+  #     # maps the user records to these records as its arguments.
+  #     #
+  #     # If you need access to the authorization handler that caused the
+  #     # transfer to be initiated, it is available as the second yielded
+  #     # argument (auth_hander).
+  #     transfer.move_records(Decidim::MyModule::FooBar, :decidim_user_id)
+  #   end
+  #
+  # The handler registration needs a name for the specific module handling the
+  # transfer and a block which handles the specific transfer. The block is
+  # called with the transfer record, i.e. instance of this class with access to
+  # all necessary information required for handling the transfer.
+  class AuthorizationTransfer < ApplicationRecord
+    belongs_to :authorization, class_name: "Decidim::Authorization"
+    belongs_to :user, class_name: "Decidim::User"
+    belongs_to :source_user, class_name: "Decidim::User"
+    has_many :records, class_name: "Decidim::AuthorizationTransferRecord", foreign_key: :transfer_id, dependent: :destroy
+
+    class DisabledError < StandardError; end
+
+    class << self
+      # Provides access to the registry instance that stores the transfer
+      # handlers for each module.
+      #
+      # The only reason for the registry is defined at the Decidim core module
+      # is to have it in the `lib` folder which is not reloaded on every request
+      # at the development environment. If the registry was stored within the
+      # model class itself, it would be empty after every code reload (i.e.
+      # every request).
+      #
+      # @return [Decidim::BlockRegistry] The registry of the authorization
+      #   transfer handlers.
+      def registry
+        Decidim.authorization_transfer_registry
+      end
+
+      # Expose the methods provided by the registry singleton through the model
+      # class.
+      #
+      # @!method register(name)
+      # Registers an authorization transfer handler for a specific use case in
+      # any modules that need to handle authorization transfers.
+      # @example
+      #   Decidim::AuthorizationTransfer.register(:my_module) do |transfer, auth_handler|
+      #     transfer.move_records(Decidim::MyModule::FooBar, :decidim_user_id)
+      #   end
+      # @param name [Symbol] The name for the block, e.g. `:proposals`.
+      # @yield [transfer, authorization_handler] Handles the authorization
+      #   transfer for the given context. This is called before the
+      #   authorization is transferred over to the new user and granted.
+      # @yieldparam [Decidim::AuthorizationTransfer] The authorization transfer
+      #   being processed which stores all the necessary information about the
+      #   transfer, related authorization and related user and source user (i.e.
+      #   the user from which the authorization is transferred from).
+      # @yieldparam [Decidim::AuthorizationHandler] The authorization handler
+      #   in charge of the current authorization action which initiated the
+      #   transfer due to the duplicate unique ID it detected. This handler can
+      #   provide access to the metadata from the new authorization action that
+      #   caused the conflict to happen.
+      # @return [Proc] The registered block itself.
+      #
+      # @!method unregister(name)
+      # @see Decidim::BlockRegistry#unregister(name)
+      #
+      # @!method unregister(*names)
+      # @see Decidim::BlockRegistry#unregister(*names)
+      #
+      # @!method registrations
+      # @see Decidim::BlockRegistry#registrations
+      delegate :register, :unregister, :registrations, to: :registry
+
+      # Returns the enabled status for the authorization transfers. True by
+      # default.
+      #
+      # @return [Boolean] True if the authorization transfers are enabled and
+      #   false if they are disabled.
+      def enabled?
+        enable! if @enabled.nil?
+
+        @enabled
+      end
+
+      # Enables the authorization transfer functionality. By default the
+      # functionality is already enabled, so this method is only needed in case
+      # the enabled state is changed e.g. during tests.
+      #
+      # @return [Boolean] Returns the enabled status after the enabling, i.e.
+      #   true.
+      def enable!
+        @enabled = true
+      end
+
+      # Disables the authorization transfer functionality.
+      #
+      # @return [Boolean] Returns the enabled status after the disabling, i.e.
+      #   false.
+      def disable!
+        @enabled = false
+      end
+
+      # Performs the authorization transfer for the provided authorization object
+      # with the provided handler which is authorizing the user.
+      #
+      # @param authorization [Decidim::Authorization] The authorization object
+      #   to be transferred over to the new user indicated by the authorization
+      #   handler.
+      # @param handler [Decidim::AuthorizationHandler] The authorization handler
+      #   object with all the necessary information for authorizing the new
+      #   user. The target user for which the authorization is transferred over
+      #   to is fetched from the handler.
+      # @raise [DisabledError] If the functionality is disabled.
+      # @return [Decidim::AuthorizationTransfer] The created authorization
+      #   transfer object.
+      def perform!(authorization, handler)
+        raise DisabledError unless enabled?
+
+        transaction do
+          transfer = create!(
+            authorization:,
+            user: handler.user,
+            source_user: authorization.user
+          )
+
+          transfer.announce!(handler)
+
+          # Update the metadata, transfer to the new user and grant.
+          authorization.attributes = {
+            metadata: handler.metadata,
+            user: handler.user
+          }
+
+          authorization.grant!
+
+          transfer
+        end
+      end
+    end
+
+    # Overwrites the method so that records cannot be modified.
+    #
+    # @return [Boolean] A boolean indicating whether the record is read only.
+    def readonly?
+      !new_record? && !destroyed_by_association
+    end
+
+    # This announces the transfer to external modules that can perform their own
+    # actions during the authorization transfer. This is called before the
+    # authorization is transferred to the new user allowing different modules to
+    # transfer their records from the source user to the user that the
+    # authorization is being transferred to. Note that during the publish event,
+    # the authorization record is still pointing to the source user but the
+    # transfer record itself available for the event is mapped correctly to the
+    # target user.
+    #
+    # @param handler [Decidim::AuthorizationHandler] The authorization handler
+    #   for the transfer procedure which contains all the necessary information
+    #   about the data that was submitted from the authorization action. It is
+    #   yielded to the registered transfer handlers as the second argument of
+    #   the registered block.
+    # @raise [DisabledError] If the functionality is disabled.
+    # @return [Array<Proc>] An array of the blocks that were processed during
+    #   the transfer.
+    def announce!(handler)
+      raise DisabledError unless self.class.enabled?
+
+      self.class.registrations.values.each do |block|
+        block.call(self, handler)
+      end
+    end
+
+    # Creates a presenter instance for this record and returns it.
+    #
+    # @return [Decidim::AuthorizationTransferPresenter] The presenter object.
+    def presenter
+      AuthorizationTransferPresenter.new(self)
+    end
+
+    # Returns information about the transfer in the described format. The
+    # returned hash contains information about the transferred records as the
+    # record type (class name as string) as its keys and an informational hash
+    # as its values with the following keys:
+    # - :class - The class constant of the transferred records
+    # - :count - Number of the records of this type that were transferred
+    # - :name - An instance of ActiveModel::Name for the record class
+    #
+    # @example Format of the returned information hash
+    #   {
+    #     "Decidim::Foo" => {
+    #        class: Decidim::Foo,
+    #        count: 123,
+    #        name: ActiveModel::Name.new(Decidim::Foo)
+    #     },
+    #     "Decidim::Bar" => {
+    #        class: Decidim::Bar,
+    #        count: 456,
+    #        name: ActiveModel::Name.new(Decidim::Bar)
+    #     }
+    #   }
+    #
+    # @return [Hash<String => Hash<Symbol => Integer, ActiveModel::Name>>] The
+    #   information hash created for the transfer.
+    def information
+      {}.tap do |types|
+        records.find_each do |record|
+          resource_class = record.type.safe_constantize
+          next unless resource_class
+
+          types[record.type] ||= { class: resource_class, count: 0 }
+          types[record.type][:count] += 1
+        end
+      end
+    end
+
+    # Handles moving records from the source user to the user to which the
+    # authorization is being transferred to. This updates the provided user
+    # column of the provided class to the user being authorized.
+    #
+    # @param resource_class <Class> The resource class for which records should
+    #   be transferred for.
+    # @param user_column <Symbol, String> The User column to be updated for the
+    #   records. It is updated with the user mapped to the transfer, i.e. the
+    #   target user.
+    # @return [Array<Decidim::AuthorizationTransferRecord>] An array of the
+    #   created authorization transfer records.
+    def move_records(resource_class, user_column)
+      transferrable_records = resource_class.where(user_column => source_user_id)
+      transferrable_ids = transferrable_records.pluck(:id)
+
+      # rubocop:disable Rails::SkipsModelValidations
+      transferrable_records.update_all(user_column => user_id)
+      # rubocop:enable Rails::SkipsModelValidations
+
+      records.create!(
+        transferrable_ids.map do |resource_id|
+          { resource_type: resource_class.name, resource_id: }
+        end
+      )
+    end
+  end
+end

data/app/models/decidim/authorization_transfer_record.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Represents an authorization transfer record, i.e. a Decidim record object
+  # which was transferred from another user to the target user during an
+  # authorization transfer.
+  class AuthorizationTransferRecord < ApplicationRecord
+    belongs_to :transfer, class_name: "Decidim::AuthorizationTransfer"
+    belongs_to :resource, polymorphic: true
+
+    # Overwrites the method so that records cannot be modified.
+    #
+    # @return [Boolean] a boolean indicating whether the record is read only.
+    def readonly?
+      !new_record? && !destroyed_by_association
+    end
+
+    # Returns the resource type for the records which is the value of the
+    # resource_type column stored for the record or the mapped_resource_type for
+    # the resource if it responds to that method.
+    #
+    # For example, Decidim::Coauthorable records need to report a model that
+    # they represent instead of "Coauthorable" because otherwise e.g. proposal
+    # transfers would not be reported correctly.
+    #
+    # @return [String] The resource type as string.
+    def type
+      resource.try(:mapped_resource_type) || resource_type
+    end
+  end
+end

data/app/models/decidim/coauthorship.rb

@@ -12,6 +12,13 @@ module Decidim
       user_group || author
     end
 
+    # Reports the mapped resource type for authorization transfers.
+    #
+    # @return [String] The resource type as string (i.e. its class name).
+    def mapped_resource_type
+      coauthorable_type
+    end
+
     private
 
     # As it is used to validate by comparing to author.organization

data/app/models/decidim/component.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   # A Component represents a self-contained group of functionalities usually
-  # defined via a ComponentManifest. It's meant to be able to provide a single
+  # defined via a ComponentManifest. It is meant to be able to provide a single
   # component that spans over several steps.
   class Component < ApplicationRecord
     include HasSettings
@@ -24,7 +24,7 @@ module Decidim
 
     # Other components with the same manifest and same participatory space as this one.
     def siblings
-      @siblings ||= participatory_space.components.where.not(id: id).where(manifest_name: manifest_name)
+      @siblings ||= participatory_space.components.where.not(id:).where(manifest_name:)
     end
 
     # Public: Finds the manifest this component is associated to.

data/app/models/decidim/content_block.rb

@@ -11,7 +11,7 @@ module Decidim
     belongs_to :organization, foreign_key: :decidim_organization_id, class_name: "Decidim::Organization"
     has_many :attachments, foreign_key: "decidim_content_block_id", class_name: "Decidim::ContentBlockAttachment", inverse_of: :content_block, dependent: :destroy
 
-    delegate :public_name_key, :has_settings?, :settings_form_cell, :cell, to: :manifest
+    delegate :public_name_key, :has_settings?, :settings_form_cell, :cell, :component_manifest_name, to: :manifest
 
     before_save :save_images
     after_save :reload_images
@@ -21,7 +21,7 @@ module Decidim
     # Public: finds the published content blocks for the given scope and
     # organization. Returns them ordered by ascending weight (lowest first).
     def self.for_scope(scope, organization:)
-      where(organization: organization, scope_name: scope)
+      where(organization:, scope_name: scope)
         .order(weight: :asc)
     end
 
@@ -47,8 +47,8 @@ module Decidim
 
     # Public: Holds access to the images related to the content block. This
     # method generates a dynamic class that encapsulates the uploaders for the
-    # content block images, and eases the access to them. It's a little bit
-    # hacky, but it's the only way I could come up with in order to let content
+    # content block images, and eases the access to them. It is a little bit
+    # hacky, but it is the only way I could come up with in order to let content
     # block images have different uploaders.
     #
     # Examples:
@@ -128,7 +128,7 @@ module Decidim
       end
     end
 
-    # Internal: Since we're using the `images_container` hack to hold the
+    # Internal: Since we are using the `images_container` hack to hold the
     # uploaders, we need to manually trigger it to save the attached images.
     def save_images
       images_container.save

data/app/models/decidim/contextual_help_section.rb

@@ -21,7 +21,7 @@ module Decidim
     #
     # Returns a Hash with the localized content
     def self.find_content(organization, id)
-      find_by(organization: organization, section_id: id).try(:content) || {}
+      find_by(organization:, section_id: id).try(:content) || {}
     end
 
     # Public: Stores the content.
@@ -33,12 +33,12 @@ module Decidim
     # Returns a Hash with the localized content
     def self.set_content(organization, id, content)
       item = find_or_initialize_by(
-        organization: organization,
+        organization:,
         section_id: id
       )
 
       if content.present? && content.values.any?(&:present?)
-        item.update!(content: content)
+        item.update!(content:)
       else
         item.destroy!
       end

data/app/models/decidim/follow.rb

@@ -24,9 +24,7 @@ module Decidim
     end
 
     def self.user_follower_ids_for_participatory_spaces(spaces)
-      # IF the space has questions it's a Consultations
-      followables = spaces.flat_map { |space| space.try(:questions) || space }
-      joins(:user).where(followable: followables).pluck(:decidim_user_id).uniq
+      joins(:user).where(followable: spaces).pluck(:decidim_user_id).uniq
     end
 
     private

data/app/models/decidim/messaging/conversation.rb

@@ -49,10 +49,10 @@ module Decidim
       #
       def self.start!(originator:, interlocutors:, body:, user: nil)
         conversation = start(
-          originator: originator,
-          interlocutors: interlocutors,
-          body: body,
-          user: user
+          originator:,
+          interlocutors:,
+          body:,
+          user:
         )
 
         conversation.save!
@@ -75,7 +75,7 @@ module Decidim
       def self.start(originator:, interlocutors:, body:, user: nil)
         conversation = new(participants: [originator] + interlocutors)
 
-        conversation.add_message(sender: originator, body: body, user: user)
+        conversation.add_message(sender: originator, body:, user:)
 
         conversation
       end
@@ -87,7 +87,7 @@ module Decidim
       # @return (see #add_message)
       #
       def add_message!(sender:, body:, user: nil)
-        add_message(sender: sender, body: body, user: user)
+        add_message(sender:, body:, user:)
 
         save!
       end
@@ -102,7 +102,7 @@ module Decidim
       # @return [Decidim::Messaging::Message] The newly created message
       #
       def add_message(sender:, body:, user: nil)
-        message = messages.build(sender: sender, body: body)
+        message = messages.build(sender:, body:)
 
         message.envelope_for(recipients: interlocutors(sender), from: user)
 

data/app/models/decidim/messaging/message.rb

@@ -52,7 +52,7 @@ module Decidim
         all_recipients(recipients).each do |recipient|
           next if @already_notified.include?(recipient)
 
-          receipts.build(recipient: recipient)
+          receipts.build(recipient:)
           @already_notified.push(recipient)
         end
       end

data/app/models/decidim/messaging/receipt.rb

@@ -13,7 +13,7 @@ module Decidim
       belongs_to :recipient, foreign_key: "decidim_recipient_id", class_name: "Decidim::User"
       belongs_to :message, foreign_key: "decidim_message_id", class_name: "Decidim::Messaging::Message"
 
-      scope :recipient, ->(recipient) { where(recipient: recipient) }
+      scope :recipient, ->(recipient) { where(recipient:) }
       scope :unread_by, ->(user) { recipient(user).unread }
       scope :unread, -> { where(read_at: nil) }
 

data/app/models/decidim/newsletter.rb

@@ -52,12 +52,12 @@ module Decidim
 
     def template
       @template ||= Decidim::ContentBlock
-                    .for_scope(:newsletter_template, organization: organization)
+                    .for_scope(:newsletter_template, organization:)
                     .find_by(scoped_resource_id: id)
     end
 
     def url(**kwargs)
-      proxy_url(:newsletter_url, id: id, **kwargs)
+      proxy_url(:newsletter_url, id:, **kwargs)
     end
 
     def notifications_settings_url(**kwargs)

data/app/models/decidim/notification.rb

@@ -21,11 +21,11 @@ module Decidim
 
     def event_class_instance
       @event_class_instance ||= event_class.constantize.new(
-        resource: resource,
-        event_name: event_name,
-        user: user,
-        user_role: user_role,
-        extra: extra
+        resource:,
+        event_name:,
+        user:,
+        user_role:,
+        extra:
       )
     end
 

data/app/models/decidim/organization.rb

@@ -18,7 +18,7 @@ module Decidim
     translatable_fields :description, :cta_button_text, :omnipresent_banner_title, :omnipresent_banner_short_description,
                         :highlighted_content_banner_title, :highlighted_content_banner_short_description, :highlighted_content_banner_action_title,
                         :highlighted_content_banner_action_subtitle, :welcome_notification_subject, :welcome_notification_body, :id_documents_explanation_text,
-                        :admin_terms_of_use_body
+                        :admin_terms_of_service_body
 
     has_many :static_pages, foreign_key: "decidim_organization_id", class_name: "Decidim::StaticPage", inverse_of: :organization, dependent: :destroy
     has_many :static_page_topics, class_name: "Decidim::StaticPageTopic", inverse_of: :organization, dependent: :destroy
@@ -35,10 +35,10 @@ module Decidim
 
     has_many :templates, foreign_key: "decidim_organization_id", class_name: "Decidim::Templates::Template", dependent: :destroy if defined? Decidim::Templates
 
-    # Users registration mode. Whether users can register or access the system. Doesn't affect users that access through Omniauth integrations.
+    # Users registration mode. Whether users can register or access the system. Does not affect users that access through Omniauth integrations.
     #  enabled: Users registration and sign in are enabled (default value).
-    #  existing: Users can't be registered in the system. Only existing users can sign in.
-    #  disable: Users can't register or sign in.
+    #  existing: Users cannot be registered in the system. Only existing users can sign in.
+    #  disable: Users cannot register or sign in.
     enum users_registration_mode: [:enabled, :existing, :disabled], _prefix: true
 
     validates :name, :host, uniqueness: true
@@ -46,9 +46,6 @@ module Decidim
     validates :time_zone, presence: true, time_zone: true
     validates :default_locale, inclusion: { in: :available_locales }
 
-    has_one_attached :official_img_header
-    validates_upload :official_img_header, uploader: Decidim::OfficialImageHeaderUploader
-
     has_one_attached :official_img_footer
     validates_upload :official_img_footer, uploader: Decidim::OfficialImageFooterUploader
 
@@ -117,9 +114,9 @@ module Decidim
         multi_translation("decidim.welcome_notification.default_body", available_locales)
     end
 
-    def admin_terms_of_use_body
-      self[:admin_terms_of_use_body] ||
-        multi_translation("decidim.admin_terms_of_use.default_body", available_locales)
+    def admin_terms_of_service_body
+      self[:admin_terms_of_service_body] ||
+        multi_translation("decidim.admin_terms_of_service.default_body", available_locales)
     end
 
     def sign_up_enabled?
@@ -159,6 +156,15 @@ module Decidim
       static_pages.accessible_for(self, user)
     end
 
+    def favicon_ico
+      return unless favicon.attached?
+      return favicon if favicon.content_type == "image/vnd.microsoft.icon"
+
+      uploader = attached_uploader(:favicon)
+      variant = uploader.variant(:favicon)
+      variant.processed.image
+    end
+
     private
 
     def tenant_disabled_providers_keys

data/app/models/decidim/participatory_space_private_user.rb

@@ -4,12 +4,10 @@ module Decidim
   # This class gives a given User access to a given private ParticipatorySpacePrivateUser
   class ParticipatorySpacePrivateUser < ApplicationRecord
     include Decidim::DownloadYourData
+    include ParticipatorySpaceUser
 
-    belongs_to :user, class_name: "Decidim::User", foreign_key: :decidim_user_id
     belongs_to :privatable_to, polymorphic: true
 
-    validate :user_and_participatory_space_same_organization
-
     scope :by_participatory_space, ->(privatable_to) { where(privatable_to_id: privatable_to.id, privatable_to_type: privatable_to.class.to_s) }
 
     def self.user_collection(user)
@@ -24,29 +22,10 @@ module Decidim
       Decidim::AdminLog::ParticipatorySpacePrivateUserPresenter
     end
 
-    ransacker :name do
-      Arel.sql(%{("decidim_users"."name")::text})
-    end
-
-    ransacker :email do
-      Arel.sql(%{("decidim_users"."email")::text})
-    end
-
     ransacker :invitation_sent_at do
       Arel.sql(%{("invitation_sent_at")::text})
     end
 
-    ransacker :invitation_accepted_at do
-      Arel.sql(%{("invitation_accepted_at")::text})
-    end
-
-    private
-
-    # Private: check if the participatory space and the user have the same organization
-    def user_and_participatory_space_same_organization
-      return if !privatable_to || !user
-
-      errors.add(:privatable_to, :invalid) unless user.organization == privatable_to.organization
-    end
+    def target_space_association = :privatable_to
   end
 end

data/app/models/decidim/permission_action.rb

@@ -32,7 +32,7 @@ module Decidim
     end
 
     def allowed?
-      raise PermissionNotSetError, "Permission hasn't been allowed or disallowed yet: #{inspect}" if @state.blank?
+      raise PermissionNotSetError, "Permission has not been allowed or disallowed yet: #{inspect}" if @state.blank?
 
       @state == :allowed
     end

data/app/models/decidim/reminder_record.rb

@@ -2,28 +2,11 @@
 
 module Decidim
   class ReminderRecord < ApplicationRecord
+    STATES = { active: 0, pending: 10, completed: 20, deleted: -1 }.freeze
+
     belongs_to :reminder, foreign_key: "decidim_reminder_id", class_name: "Decidim::Reminder"
     belongs_to :remindable, foreign_type: "remindable_type", polymorphic: true, optional: true
 
-    scope :active, -> { where(state: "active") }
-    scope :pending, -> { where(state: "pending") }
-    scope :completed, -> { where(state: "completed") }
-    scope :deleted, -> { where(state: "deleted") }
-
-    def active?
-      state == "active"
-    end
-
-    def pending?
-      state == "pending"
-    end
-
-    def completed?
-      state == "completed"
-    end
-
-    def deleted?
-      state == "deleted"
-    end
+    enum state: STATES
   end
 end

data/app/models/decidim/report.rb

@@ -5,7 +5,7 @@ module Decidim
   class Report < ApplicationRecord
     include Decidim::DownloadYourData
 
-    REASONS = %w(spam offensive does_not_belong).freeze
+    REASONS = %w(spam offensive does_not_belong hidden_during_block).freeze
 
     belongs_to :moderation, foreign_key: "decidim_moderation_id", class_name: "Decidim::Moderation"
     belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"

data/app/models/decidim/share_token.rb

@@ -11,7 +11,7 @@ module Decidim
     after_initialize :generate, :set_default_expiration
 
     def self.use!(token_for:, token:)
-      record = find_by!(token_for: token_for, token: token)
+      record = find_by!(token_for:, token:)
       record.use!
     end
 
@@ -36,7 +36,7 @@ module Decidim
 
       loop do
         self.token = SecureRandom.hex(32)
-        break if ShareToken.find_by(token: token).blank?
+        break if ShareToken.find_by(token:).blank?
       end
     end