decidim-core 0.23.0 → 0.24.0.rc1

data/app/models/decidim/scope.rb

@@ -17,13 +17,11 @@ module Decidim
                inverse_of: :scopes
 
     belongs_to :scope_type,
-               foreign_key: "scope_type_id",
                class_name: "Decidim::ScopeType",
                inverse_of: :scopes,
                optional: true
 
     belongs_to :parent,
-               foreign_key: "parent_id",
                class_name: "Decidim::Scope",
                inverse_of: :children,
                optional: true
@@ -74,6 +72,11 @@ module Decidim
       organization.scopes.where(id: scope_ids).sort { |s1, s2| part_of.index(s2.id) <=> part_of.index(s1.id) }
     end
 
+    # Allow ransacker to search for a key in a hstore column (`name`.`en`)
+    ransacker :name do |parent|
+      Arel::Nodes::InfixOperation.new("->>", parent.table[:name], Arel::Nodes.build_quoted(I18n.locale.to_s))
+    end
+
     private
 
     def forbid_cycles

data/app/models/decidim/scope_type.rb

@@ -12,7 +12,7 @@ module Decidim
                class_name: "Decidim::Organization",
                inverse_of: :scope_types
 
-    has_many :scopes, foreign_key: "scope_type_id", class_name: "Decidim::Scope", inverse_of: :scope_type, dependent: :nullify
+    has_many :scopes, class_name: "Decidim::Scope", inverse_of: :scope_type, dependent: :nullify
 
     validates :name, presence: true
   end

data/app/models/decidim/share_token.rb

@@ -8,7 +8,7 @@ module Decidim
 
     belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
     belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
-    belongs_to :token_for, foreign_key: "token_for_id", foreign_type: "token_for_type", polymorphic: true
+    belongs_to :token_for, foreign_type: "token_for_type", polymorphic: true
 
     after_initialize :generate, :set_default_expiration
 

data/app/models/decidim/static_page.rb

@@ -15,7 +15,7 @@ module Decidim
     translatable_fields :title, :content
 
     belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization", inverse_of: :static_pages
-    belongs_to :topic, foreign_key: "topic_id", class_name: "Decidim::StaticPageTopic", optional: true
+    belongs_to :topic, class_name: "Decidim::StaticPageTopic", optional: true
 
     validates :slug, presence: true, uniqueness: { scope: :organization }
     validates :slug, format: { with: /\A[a-z0-9-]+/ }
@@ -30,6 +30,16 @@ module Decidim
 
     default_scope { order(arel_table[:weight].asc) }
 
+    scope :accessible_for, lambda { |organization, user|
+      collection = where(organization: organization)
+
+      if user.blank? && organization.force_users_to_authenticate_before_access_organization
+        collection.where(allow_public_access: true)
+      else
+        collection
+      end
+    }
+
     # Whether this is slug of a default page or not.
     #
     # slug - The String with the value of the slug.

data/app/models/decidim/static_page_topic.rb

@@ -11,5 +11,9 @@ module Decidim
 
     belongs_to :organization, class_name: "Decidim::Organization"
     has_many :pages, class_name: "Decidim::StaticPage", foreign_key: "topic_id", dependent: :nullify
+
+    def accessible_pages_for(user)
+      pages.accessible_for(organization, user)
+    end
   end
 end

data/app/models/decidim/user.rb

@@ -10,6 +10,8 @@ module Decidim
     include Decidim::DataPortability
     include Decidim::Searchable
     include Decidim::ActsAsAuthor
+    include Decidim::UserReportable
+    include Decidim::Traceable
 
     class Roles
       def self.all
@@ -30,6 +32,8 @@ module Decidim
     has_many :access_grants, class_name: "Doorkeeper::AccessGrant", foreign_key: :resource_owner_id, dependent: :destroy
     has_many :access_tokens, class_name: "Doorkeeper::AccessToken", foreign_key: :resource_owner_id, dependent: :destroy
 
+    has_one :blocking, class_name: "Decidim::UserBlock", foreign_key: :id, primary_key: :block_id, dependent: :destroy
+
     validates :name, presence: true, unless: -> { deleted? }
     validates :nickname, presence: true, unless: -> { deleted? || managed? }, length: { maximum: Decidim::User.nickname_max_length }
     validates :locale, inclusion: { in: :available_locales }, allow_blank: true
@@ -52,9 +56,20 @@ module Decidim
     scope :confirmed, -> { where.not(confirmed_at: nil) }
     scope :not_confirmed, -> { where(confirmed_at: nil) }
 
+    scope :blocked, -> { where(blocked: true) }
+    scope :not_blocked, -> { where(blocked: false) }
+
     scope :interested_in_scopes, lambda { |scope_ids|
-      ids = scope_ids.map { |i| "%#{i}%" }.join(",")
-      where("extended_data->>'interested_scopes' ~~ ANY('{#{ids}}')")
+      actual_ids = scope_ids.select(&:presence)
+      if actual_ids.count.positive?
+        ids = actual_ids.map(&:to_i).join(",")
+        where("extended_data->'interested_scopes' @> ANY('{#{ids}}')")
+      else
+        # Do not apply the scope filter when there are scope ids available. Note
+        # that the active record scope must always return an active record
+        # collection.
+        self
+      end
     }
 
     scope :org_admins_except_me, ->(user) { where(organization: user.organization, admin: true).where.not(id: user.id) }
@@ -193,7 +208,7 @@ module Decidim
     end
 
     def being_impersonated?
-      ImpersonationLog.active.where(user: self).exists?
+      ImpersonationLog.active.exists?(user: self)
     end
 
     def interested_scopes_ids
@@ -204,9 +219,13 @@ module Decidim
       @interested_scopes ||= organization.scopes.where(id: interested_scopes_ids)
     end
 
+    def user_name
+      extended_data["user_name"] || name
+    end
+
     # Caches a Decidim::DataPortabilityUploader with the retrieved file.
     def data_portability_file(filename)
-      @data_portability_file ||= DataPortabilityUploader.new.tap do |uploader|
+      @data_portability_file ||= DataPortabilityUploader.new(self).tap do |uploader|
         uploader.retrieve_from_store!(filename)
         uploader.cache!(filename)
       end

data/app/models/decidim/user_base_entity.rb

@@ -18,7 +18,7 @@ module Decidim
     has_many :following_follows, foreign_key: "decidim_user_id", class_name: "Decidim::Follow", dependent: :destroy
 
     # Regex for name & nickname format validations
-    REGEXP_NAME = /\A(?!.*[<>?%&\^*#@\(\)\[\]\=\+\:\;\"\{\}\\\|])/.freeze
+    REGEXP_NAME = /\A(?!.*[<>?%&\^*#@()\[\]=+:;"{}\\|])/.freeze
 
     validates_avatar
     mount_uploader :avatar, Decidim::AvatarUploader
@@ -34,17 +34,17 @@ module Decidim
     # Returns an Array of Decidim::Followable
     def following
       @following ||= begin
-                       followings = following_follows.pluck(:decidim_followable_type, :decidim_followable_id)
-                       grouped_followings = followings.each_with_object({}) do |(type, following_id), all|
-                         all[type] ||= []
-                         all[type] << following_id
-                         all
-                       end
-
-                       grouped_followings.flat_map do |type, ids|
-                         type.constantize.where(id: ids)
-                       end
-                     end
+        followings = following_follows.pluck(:decidim_followable_type, :decidim_followable_id)
+        grouped_followings = followings.each_with_object({}) do |(type, following_id), all|
+          all[type] ||= []
+          all[type] << following_id
+          all
+        end
+
+        grouped_followings.flat_map do |type, ids|
+          type.constantize.where(id: ids)
+        end
+      end
     end
   end
 end

data/app/models/decidim/user_block.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  class UserBlock < ApplicationRecord
+    MINIMUM_JUSTIFICATION_LENGTH = 15
+
+    belongs_to :user, class_name: "Decidim::User", foreign_key: :decidim_user_id
+    belongs_to :blocking_user, class_name: "Decidim::User"
+  end
+end

data/app/models/decidim/user_group.rb

@@ -9,6 +9,7 @@ module Decidim
     include Decidim::Traceable
     include Decidim::DataPortability
     include Decidim::ActsAsAuthor
+    include Decidim::UserReportable
 
     has_many :memberships, class_name: "Decidim::UserGroupMembership", foreign_key: :decidim_user_group_id, dependent: :destroy
     has_many :users, through: :memberships, class_name: "Decidim::User", foreign_key: :decidim_user_id

data/app/models/decidim/user_moderation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  class UserModeration < ApplicationRecord
+    include Traceable
+    include Loggable
+
+    belongs_to :user, foreign_key: :decidim_user_id, class_name: "Decidim::UserBaseEntity"
+    has_many :reports, class_name: "Decidim::UserReport", dependent: :destroy
+
+    scope :blocked, -> { joins(:user).where(decidim_users: { blocked: true }) }
+    scope :unblocked, -> { joins(:user).where(decidim_users: { blocked: false }) }
+
+    delegate :organization, to: :user
+    scope :blocked, -> { joins(:user).where(decidim_users: { blocked: true }) }
+    scope :unblocked, -> { joins(:user).where(decidim_users: { blocked: false }) }
+
+    def self.log_presenter_class_for(_log)
+      Decidim::AdminLog::UserModerationPresenter
+    end
+  end
+end

data/app/models/decidim/user_report.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  class UserReport < ApplicationRecord
+    include Decidim::DataPortability
+
+    REASONS = %w(spam offensive does_not_belong).freeze
+
+    belongs_to :moderation, foreign_key: :user_moderation_id, class_name: "Decidim::UserModeration"
+    belongs_to :user, class_name: "Decidim::User"
+
+    validates :reason, presence: true
+    validates :reason, inclusion: { in: REASONS }
+    validates :user, uniqueness: { scope: :user_moderation_id }
+    validate :user_and_moderation_same_organization
+
+    def self.export_serializer
+      raise NotImplementedError
+      # Decidim::DataPortabilitySerializers::DataPortabilityReportSerializer
+    end
+
+    private
+
+    # Private: check if the moderation and the user have the same organization
+    def user_and_moderation_same_organization
+      return if !moderation || !user
+
+      errors.add(:moderation, :invalid) unless user.organization == moderation.organization
+    end
+  end
+end

data/app/permissions/decidim/permissions.rb

@@ -127,9 +127,7 @@ module Decidim
       conversation = context.fetch(:conversation)
       interlocutor = context.fetch(:interlocutor, user)
 
-      if [:create, :update].include?(permission_action.action)
-        return disallow! unless conversation&.accept_user? interlocutor
-      end
+      return disallow! if [:create, :update].include?(permission_action.action) && !conversation&.accept_user?(interlocutor)
 
       toggle_allow(conversation&.participating?(interlocutor))
     end

data/app/permissions/decidim/report_user_permissions.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  class ReportUserPermissions < DefaultPermissions
+    def permissions
+      return permission_action unless user
+
+      allow! if permission_action.subject == :user_report && permission_action.action == :create
+
+      permission_action
+    end
+  end
+end

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

@@ -35,8 +35,8 @@ module Decidim
         end
       end
 
-      def has_diff?
-        action == "unpublish" || super
+      def diff_actions
+        super + %w(unpublish)
       end
     end
   end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AdminLog
+    # This class holds the logic to present a `Decidim::ImpersonationLog`
+    # for the `AdminLog` log.
+    #
+    # Usage should be automatic and you shouldn't need to call this class
+    # directly, but here's an example:
+    #
+    #    action_log = Decidim::ActionLog.last
+    #    view_helpers # => this comes from the views
+    #    ImpersonationLogPresenter.new(action_log, view_helpers).present
+    class ImpersonationLogPresenter < Decidim::Log::BasePresenter
+      alias h view_helpers
+
+      private
+
+      def action_string
+        case action
+        when "manage"
+          "decidim.admin_log.impersonation_log.#{action}"
+        else
+          super
+        end
+      end
+
+      def i18n_params
+        super.merge(
+          reason: action_log.extra["reason"]
+        )
+      end
+
+      def resource_presenter
+        @resource_presenter ||= Decidim::Log::UserPresenter.new(action_log.resource.user, h, action_log.extra["resource"])
+      end
+    end
+  end
+end

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

@@ -40,8 +40,8 @@ module Decidim
         )
       end
 
-      def has_diff?
-        action == "unreport" || super
+      def diff_actions
+        super + %w(unreport)
       end
     end
   end

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

@@ -67,8 +67,7 @@ module Decidim
           favicon: :string,
           official_img_header: :string,
           official_img_footer: :string,
-          official_url: :string,
-          show_statistics: :boolean
+          official_url: :string
         }
       end
 
@@ -89,8 +88,8 @@ module Decidim
         "activemodel.attributes.organization"
       end
 
-      def has_diff?
-        action == "update_id_documents_config" || super
+      def diff_actions
+        super + %w(update_id_documents_config)
       end
     end
   end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AdminLog
+    # This class holds the logic to present a `Decidim::UserModeration`
+    # for the `AdminLog` log.
+    #
+    # Usage should be automatic and you shouldn't need to call this class
+    # directly, but here's an example:
+    #
+    #    action_log = Decidim::ActionLog.last
+    #    view_helpers # => this comes from the views
+    #    ModerationPresenter.new(action_log, view_helpers).present
+    class UserModerationPresenter < Decidim::Log::BasePresenter
+      private
+
+      def diff_fields_mapping
+        {
+          hidden_at: :date,
+          report_count: :integer
+        }
+      end
+
+      def action_string
+        case action
+        when "hide", "unreport"
+          "decidim.admin_log.user_moderation.#{action}"
+        else
+          super
+        end
+      end
+
+      def i18n_labels_scope
+        "decidim.moderations.models.moderation.fields"
+      end
+
+      def i18n_params
+        super.merge(
+          resource_type: action_log.extra.dig("extra", "reportable_type").try(:demodulize),
+          unreported_user_name: unreported_user_presenter.try(:present)
+        )
+      end
+
+      # Private: Caches the object that will be responsible of presenting the user
+      # that performed the given action.
+      #
+      # Returns an object that responds to `present`.
+      def unreported_user_presenter
+        @unreported_user_presenter ||= Decidim::Log::UserPresenter.new(unreported_user, h,
+                                                                       "name" => unreported_user.name,
+                                                                       "nickname" => unreported_user.nickname)
+      end
+
+      def unreported_user
+        @unreported_user ||= Decidim::User.find_by(id: action_log.extra.dig("extra", "user_id"))
+      end
+
+      def has_diff?
+        action == "unreport" || super
+      end
+    end
+  end
+end

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

@@ -16,7 +16,7 @@ module Decidim
 
       def action_string
         case action
-        when "grant_id_documents_offline_verification", "invite", "officialize", "remove_from_admin", "show_email", "unofficialize"
+        when "grant_id_documents_offline_verification", "invite", "officialize", "remove_from_admin", "show_email", "unofficialize", "block", "unblock", "promote", "transfer"
           "decidim.admin_log.user.#{action}"
         else
           super
@@ -41,18 +41,27 @@ module Decidim
         action_log.extra.dig("extra", "officialized_user_badge_previous") || Hash.new("")
       end
 
-      # We fake the changeset for officialization actions.
+      def previous_justification
+        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
-        Decidim::Log::DiffChangesetCalculator.new(
-          { badge: [previous_user_badge, user_badge] },
-          { badge: :i18n },
-          i18n_labels_scope
-        ).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
 
-      # If the action is officialization, then we want to show the diff
-      def has_diff?
-        %w(officialize unofficialize).include?(action)
+      def diff_actions
+        %w(officialize unofficialize block)
       end
     end
   end