decidim-core 0.21.0 → 0.22.0

data/app/models/decidim/content_block.rb

@@ -6,6 +6,8 @@ module Decidim
   class ContentBlock < ApplicationRecord
     include Publicable
 
+    attr_accessor :in_preview
+
     belongs_to :organization, foreign_key: :decidim_organization_id, class_name: "Decidim::Organization"
 
     delegate :public_name_key, :has_settings?, :settings_form_cell, :cell, to: :manifest
@@ -16,12 +18,12 @@ 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: scope)
+      where(organization: organization, scope_name: scope)
         .order(weight: :asc)
     end
 
     def manifest
-      @manifest ||= Decidim.content_blocks.for(scope).find { |manifest| manifest.name.to_s == manifest_name }
+      @manifest ||= Decidim.content_blocks.for(scope_name).find { |manifest| manifest.name.to_s == manifest_name }
     end
 
     # Public: Uses the `SettingsManifest` class to generate a settings schema
@@ -124,7 +126,7 @@ module Decidim
       end
 
       @images_container.manifest = manifest
-      @images_container.manifest_scope = scope
+      @images_container.manifest_scope = scope_name
       @images_container = @images_container.new(self)
     end
 

data/app/models/decidim/endorsement.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A resource can have an endorsement for each user or group the author/endorser belongs to.
+  class Endorsement < ApplicationRecord
+    include Decidim::Authorable
+
+    belongs_to :resource,
+               polymorphic: true,
+               counter_cache: true
+
+    validates :resource_id, uniqueness: { scope: [:resource_type, :author, :user_group] }
+    validate :author_and_resource_same_organization
+
+    scope :for_listing, -> { order(:decidim_user_group_id, :created_at) }
+
+    private
+
+    def organization
+      resource&.component&.organization
+    end
+
+    # Private: check if the resource and the author have the same organization
+    def author_and_resource_same_organization
+      return if !resource || !author
+
+      errors.add(:resource, :invalid) unless author.organization == resource.organization
+    end
+  end
+end

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

@@ -24,8 +24,12 @@ module Decidim
 
       has_many :receipts, through: :messages
 
+      scope :unread_messages_by, lambda { |user|
+        joins(:receipts).merge(Receipt.unread_by(user))
+      }
+
       scope :unread_by, lambda { |user|
-        joins(:receipts).merge(Receipt.unread_by(user)).distinct
+        unread_messages_by(user).distinct
       }
 
       default_scope { order(updated_at: :desc) }
@@ -41,11 +45,12 @@ module Decidim
       #
       # @return (see .start)
       #
-      def self.start!(originator:, interlocutors:, body:)
+      def self.start!(originator:, interlocutors:, body:, user: nil)
         conversation = start(
           originator: originator,
           interlocutors: interlocutors,
-          body: body
+          body: body,
+          user: user
         )
 
         conversation.save!
@@ -57,17 +62,18 @@ module Decidim
       # Initiates a conversation between a user and a set of interlocutors with
       # an initial message.
       #
-      # @param originator [Decidim::User] The user starting the conversation
+      # @param originator [Decidim::UserBaseEntity] The user or group starting the conversation
       # @param interlocutors [Array<Decidim::User>] The set of interlocutors in
       #   the conversation (not including the originator).
       # @param body [String] The content of the initial message
+      # @param user [Decidim::User] The user starting the conversation in case originator is a group
       #
       # @return [Decidim::Messaging::Conversation] The newly created conversation
       #
-      def self.start(originator:, interlocutors:, body:)
+      def self.start(originator:, interlocutors:, body:, user: nil)
         conversation = new(participants: [originator] + interlocutors)
 
-        conversation.add_message(sender: originator, body: body)
+        conversation.add_message(sender: originator, body: body, user: user)
 
         conversation
       end
@@ -78,8 +84,8 @@ module Decidim
       #
       # @return (see #add_message)
       #
-      def add_message!(sender:, body:)
-        add_message(sender: sender, body: body)
+      def add_message!(sender:, body:, user: nil)
+        add_message(sender: sender, body: body, user: user)
 
         save!
       end
@@ -87,15 +93,16 @@ module Decidim
       #
       # Appends a message to this conversation
       #
-      # @param sender [Decidim::User] The sender of the message
+      # @param sender [Decidim::UserBaseEntity] The sender of the message
       # @param body [String] The content of the message
+      # @param user [Decidim::User] The user sending the message in case sender is a group
       #
       # @return [Decidim::Messaging::Message] The newly created message
       #
-      def add_message(sender:, body:)
+      def add_message(sender:, body:, user: nil)
         message = messages.build(sender: sender, body: body)
 
-        message.envelope_for(interlocutors(sender))
+        message.envelope_for(recipients: interlocutors(sender), from: user)
 
         message
       end
@@ -111,6 +118,27 @@ module Decidim
         participants.reject { |participant| participant.id == user.id }
       end
 
+      #
+      # Given a user, returns if ALL the interlocutors allow her to join the conversation
+      #
+      # @return Boolean
+      #
+      def accept_user?(user)
+        # if user is a group, members are accepted
+        blocked = interlocutors(user).detect { |participant| !participant.accepts_conversation?(user) }
+        blocked.blank?
+      end
+
+      #
+      # Given a user, returns if the user is participating in the conversation
+      # for groups being part of a conversation all their admin member are accepted
+      #
+      # @return Boolean
+      #
+      def participating?(user)
+        participants.include?(user)
+      end
+
       #
       # The most recent message in this conversation
       #

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

@@ -12,7 +12,7 @@ module Decidim
 
       belongs_to :sender,
                  foreign_key: :decidim_sender_id,
-                 class_name: "Decidim::User"
+                 class_name: "Decidim::UserBaseEntity"
 
       belongs_to :conversation,
                  foreign_key: :decidim_conversation_id,
@@ -36,16 +36,42 @@ module Decidim
       # including also a receipt for the remitent (sender) of the message.
       # Receipts are unread by default, except for the sender's receipt.
       #
-      # @param recipients [Array<Decidim::User>]
+      # If the sender is a UserGroup then receipts will be created for its managers
+      # a "from" user can be specified to avoid create a receipt for the real user sending the message
       #
-      def envelope_for(recipients)
-        receipts.build(recipient: sender, read_at: Time.current)
+      # @param recipients [Array<Decidim::UserBaseEntity>] Users or groups receiving the message
+      # @param from [Array<Decidim::User>] the user sending the message in case sender is a group
+      #
+      def envelope_for(recipients:, from: nil)
+        @from = sender.is_a?(User) ? sender : from
+        @already_notified = [@from]
+
+        receipts.build(recipient: @from, read_at: Time.current) if @from.is_a?(User)
 
-        recipients.each { |recipient| receipts.build(recipient: recipient) }
+        all_recipients(recipients).each do |recipient|
+          next if @already_notified.include?(recipient)
+
+          receipts.build(recipient: recipient)
+          @already_notified.push(recipient)
+        end
+      end
+
+      # Public: Returns the comment body with links
+      def body_with_links
+        Decidim::ContentRenderers::LinkRenderer.new(body).render
       end
 
       private
 
+      # returns all posible recipients from a list of users or groups
+      def all_recipients(recipients)
+        users = recipients.flat_map do |recipient|
+          recipient.is_a?(UserGroup) ? recipient.managers : recipient
+        end
+        users += sender.managers if sender.is_a?(UserGroup)
+        users
+      end
+
       def sender_is_participant
         errors.add(:sender, :invalid) unless conversation.participants.include?(sender)
       end

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

@@ -13,7 +13,7 @@ module Decidim
 
       belongs_to :participant,
                  foreign_key: :decidim_participant_id,
-                 class_name: "Decidim::User"
+                 class_name: "Decidim::UserBaseEntity"
 
       validates :conversation, :participant, presence: true
 

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

@@ -22,6 +22,14 @@ module Decidim
         recipient(user).update_all(read_at: Time.current)
       end
       # rubocop:enable Rails/SkipsModelValidations
+
+      # The number of messages unread by a user
+      #
+      # @return [Integer]
+      #
+      def self.unread_count(user)
+        unread_by(user).count
+      end
     end
   end
 end

data/app/models/decidim/newsletter.rb

@@ -9,7 +9,7 @@ module Decidim
     belongs_to :author, class_name: "User"
     belongs_to :organization
 
-    validates :subject, :body, presence: true
+    validates :subject, presence: true
     validate :author_belongs_to_organization
 
     def self.log_presenter_class_for(_log)
@@ -47,6 +47,12 @@ module Decidim
       extended_data["participatory_space_types"]
     end
 
+    def template
+      @template ||= Decidim::ContentBlock
+                    .for_scope(:newsletter_template, organization: organization)
+                    .find_by(scoped_resource_id: id)
+    end
+
     private
 
     def author_belongs_to_organization

data/app/models/decidim/organization.rb

@@ -104,22 +104,31 @@ module Decidim
     end
 
     def enabled_omniauth_providers
-      return Decidim::OmniauthProvider.enabled if omniauth_settings.nil?
+      return Decidim::OmniauthProvider.enabled || {} if omniauth_settings.nil?
 
-      Decidim::OmniauthProvider.enabled.merge(tenant_enabled_providers)
+      default_except_disabled = Decidim::OmniauthProvider.enabled.except(*tenant_disabled_providers_keys)
+      default_except_disabled.merge(tenant_enabled_providers)
     end
 
     private
 
+    def tenant_disabled_providers_keys
+      omniauth_settings.collect do |key, value|
+        next unless key.match?(/omniauth_settings_.*_enabled/) && value == false
+
+        Decidim::OmniauthProvider.extract_provider_key(key)
+      end.compact.uniq
+    end
+
     def tenant_enabled_providers
-      tenant_enabled_providers_keys = omniauth_settings.map do |k, v|
-        next unless k.match?(/omniauth_settings_.*_enabled/) && v == true
+      tenant_enabled_providers_keys = omniauth_settings.map do |key, value|
+        next unless key.match?(/omniauth_settings_.*_enabled/) && value == true
 
-        Decidim::OmniauthProvider.extract_provider_key(k)
+        Decidim::OmniauthProvider.extract_provider_key(key)
       end.compact.uniq
 
-      Hash[tenant_enabled_providers_keys.map do |k|
-        [k, omniauth_provider_settings(k)]
+      Hash[tenant_enabled_providers_keys.map do |key|
+        [key, omniauth_provider_settings(key)]
       end]
     end
 

data/app/models/decidim/user.rb

@@ -57,6 +57,8 @@ module Decidim
       where("extended_data->>'interested_scopes' ~~ ANY('{#{ids}}')")
     }
 
+    scope :org_admins_except_me, ->(user) { where(organization: user.organization, admin: true).where.not(id: user.id) }
+
     attr_accessor :newsletter_notifications
 
     searchable_fields({
@@ -130,10 +132,21 @@ module Decidim
       Decidim::Follow.where(user: self, followable: followable).any?
     end
 
+    # Public: whether the user accepts direct messages from another
+    def accepts_conversation?(user)
+      return follows?(user) if direct_message_types == "followed-only"
+
+      true
+    end
+
     def unread_conversations
       Decidim::Messaging::Conversation.unread_by(self)
     end
 
+    def unread_messages_count
+      @unread_messages_count ||= Decidim::Messaging::Receipt.unread_count(self)
+    end
+
     # Check if the user exists with the given email and the current organization
     #
     # warden_conditions - A hash with the authentication conditions
@@ -199,6 +212,25 @@ module Decidim
       end
     end
 
+    # return the groups where this user has been accepted
+    def accepted_user_groups
+      UserGroups::AcceptedUserGroups.for(self)
+    end
+
+    # return the groups where this user has admin permissions
+    def manageable_user_groups
+      UserGroups::ManageableUserGroups.for(self)
+    end
+
+    def authenticatable_salt
+      "#{super}#{session_token}"
+    end
+
+    def invalidate_all_sessions!
+      self.session_token = SecureRandom.hex
+      save!
+    end
+
     protected
 
     # Overrides devise email required validation.

data/app/models/decidim/user_group.rb

@@ -97,6 +97,29 @@ module Decidim
       save!
     end
 
+    # sugar for the memberships query
+    def accepted_memberships
+      UserGroups::AcceptedMemberships.for(self)
+    end
+
+    # easy way to return all the users accepted in this group
+    def accepted_users
+      accepted_memberships.map(&:user)
+    end
+
+    # Currently, groups always accept conversations from anyone.
+    # This may change in the future in case the desired behaviour
+    # is to check if all (or any) of the administrators accepts conversations
+    # or there's simply and option for this in the group preferences.
+    def accepts_conversation?(_user)
+      true
+    end
+
+    def unread_messages_count_for(user)
+      @unread_messages_count_for ||= {}
+      @unread_messages_count_for[user.id] ||= Decidim::Messaging::Conversation.user_collection(self).unread_messages_by(user).count
+    end
+
     private
 
     # Private: Checks if the state user group is correct.

data/app/permissions/decidim/permissions.rb

@@ -21,6 +21,7 @@ module Decidim
       conversation_action?
       user_group_action?
       user_group_invitations_action?
+      apply_endorsement_permissions if permission_action.subject == :endorsement
 
       permission_action
     end
@@ -71,10 +72,10 @@ module Decidim
       case permission_action.action
       when :create
         toggle_allow(authorization.user == user && not_already_active?(authorization))
-      when :update
-        toggle_allow(authorization.user == user && !authorization.granted?)
-      when :destroy
+      when :update, :destroy
         toggle_allow(authorization.user == user && !authorization.granted?)
+      when :renew
+        toggle_allow(authorization.user == user && authorization.granted? && authorization.renewable?)
       end
     end
 
@@ -104,6 +105,12 @@ module Decidim
       toggle_allow(amendment&.amender == user)
     end
 
+    def apply_endorsement_permissions
+      return disallow! if !current_settings.endorsements_enabled || current_settings.endorsements_blocked
+
+      allow!
+    end
+
     def notification_action?
       return unless permission_action.subject == :notification
       return allow! if permission_action.action == :read
@@ -114,10 +121,16 @@ module Decidim
 
     def conversation_action?
       return unless permission_action.subject == :conversation
-      return allow! if [:create, :list].include?(permission_action.action)
+      return allow! if permission_action.action == :list
+
+      conversation = context.fetch(:conversation)
+      interlocutor = context.fetch(:interlocutor, user)
+
+      if [:create, :update].include?(permission_action.action)
+        return disallow! unless conversation&.accept_user? interlocutor
+      end
 
-      conversation = context.fetch(:conversation, nil)
-      toggle_allow(conversation.participants.include?(user))
+      toggle_allow(conversation&.participating?(interlocutor))
     end
 
     def user_group_action?