decidim-core 0.20.0 → 0.23.1.rc1

data/app/models/decidim/participatory_space_role_config/admin.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpaceRoleConfig
+    class Admin < Base
+    end
+  end
+end

data/app/models/decidim/participatory_space_role_config/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpaceRoleConfig
+    class Base
+      def initialize(user_role)
+        @user_role = user_role
+      end
+
+      # Checks whether the given manifest name is accepted for this role.
+      #
+      # Returns a boolean.
+      def component_is_accessible?(manifest_name)
+        return true if accepted_components == [:all]
+
+        accepted_components.include?(manifest_name.to_sym)
+      end
+
+      # Public: Lists the names of the accepted components for this role.
+      #
+      # Returns an Array of Symbols.
+      def accepted_components
+        [:all]
+      end
+
+      private
+
+      attr_reader :user_role
+    end
+  end
+end

data/app/models/decidim/participatory_space_role_config/collaborator.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpaceRoleConfig
+    class Collaborator < Base
+    end
+  end
+end

data/app/models/decidim/participatory_space_role_config/moderator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpaceRoleConfig
+    class Moderator < Base
+      def accepted_components
+        []
+      end
+    end
+  end
+end

data/app/models/decidim/participatory_space_role_config/null_object.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpaceRoleConfig
+    class NullObject < Base
+      def accepted_components
+        []
+      end
+    end
+  end
+end

data/app/models/decidim/participatory_space_role_config/participatory_space_admin.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpaceRoleConfig
+    class ParticipatorySpaceAdmin < Base
+    end
+  end
+end

data/app/models/decidim/participatory_space_role_config/valuator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatorySpaceRoleConfig
+    class Valuator < Base
+      def accepted_components
+        [:proposals]
+      end
+    end
+  end
+end

data/app/models/decidim/scope.rb

@@ -7,6 +7,9 @@ module Decidim
   class Scope < ApplicationRecord
     include Decidim::Traceable
     include Decidim::Loggable
+    include Decidim::TranslatableResource
+
+    translatable_fields :name
 
     belongs_to :organization,
                foreign_key: "decidim_organization_id",
@@ -42,8 +45,10 @@ module Decidim
     # Scope to return only the top level scopes.
     #
     # Returns an ActiveRecord::Relation.
-    def self.top_level
-      where parent_id: nil
+    def self.top_level(organization_id = nil)
+      query = where parent_id: nil
+      query = query.where(decidim_organization_id: organization_id) if organization_id
+      query
     end
 
     def self.log_presenter_class_for(_log)
@@ -51,7 +56,7 @@ module Decidim
     end
 
     def descendants
-      organization.scopes.where("? = ANY(decidim_scopes.part_of)", id)
+      @descendants ||= organization.scopes.where("? = ANY(decidim_scopes.part_of)", id)
     end
 
     def ancestor_of?(scope)

data/app/models/decidim/scope_type.rb

@@ -4,6 +4,9 @@ module Decidim
   # Scope types allows to use different types of scopes in participatory process
   # (municipalities, provinces, states, countries, etc.)
   class ScopeType < ApplicationRecord
+    include Decidim::TranslatableResource
+
+    translatable_fields :name, :plural
     belongs_to :organization,
                foreign_key: "decidim_organization_id",
                class_name: "Decidim::Organization",

data/app/models/decidim/share_token.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  class ShareToken < ApplicationRecord
+    validates :organization, presence: true
+    validates :user, presence: true
+    validates :token, presence: true, uniqueness: { scope: [:decidim_organization_id, :token_for_type, :token_for_id] }
+
+    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
+
+    after_initialize :generate, :set_default_expiration
+
+    def self.use!(token_for:, token:)
+      record = find_by!(token_for: token_for, token: token)
+      record.use!
+    end
+
+    def use!
+      return raise StandardError, "Share token '#{token}' for '#{token_for_type}' with id = #{token_for_id} has expired." if expired?
+
+      update!(times_used: times_used + 1, last_used_at: Time.zone.now)
+    end
+
+    def expired?
+      expires_at.past?
+    end
+
+    def url
+      token_for.shareable_url(self)
+    end
+
+    private
+
+    def generate
+      return if token.present?
+
+      loop do
+        self.token = SecureRandom.hex(32)
+        break if ShareToken.find_by(token: token).blank?
+      end
+    end
+
+    def set_default_expiration
+      self.expires_at ||= 1.day.from_now
+    end
+  end
+end

data/app/models/decidim/static_page.rb

@@ -10,6 +10,9 @@ module Decidim
   class StaticPage < ApplicationRecord
     include Decidim::Traceable
     include Decidim::Loggable
+    include Decidim::TranslatableResource
+
+    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
@@ -19,7 +22,7 @@ module Decidim
 
     # These pages will be created by default when registering an organization
     # and cannot be deleted.
-    DEFAULT_PAGES = %w(faq terms-and-conditions accessibility).freeze
+    DEFAULT_PAGES = %w(terms-and-conditions).freeze
 
     after_create :update_organization_tos_version
     before_destroy :can_be_destroyed?

data/app/models/decidim/static_page_topic.rb

@@ -3,6 +3,9 @@
 module Decidim
   class StaticPageTopic < ApplicationRecord
     validates :title, presence: true
+    include Decidim::TranslatableResource
+
+    translatable_fields :title, :description
 
     default_scope { order(arel_table[:weight].asc) }
 

data/app/models/decidim/user.rb

@@ -11,8 +11,6 @@ module Decidim
     include Decidim::Searchable
     include Decidim::ActsAsAuthor
 
-    OMNIAUTH_PROVIDERS = [:facebook, :twitter, :google_oauth2, (:developer if Rails.env.development?)].compact
-
     class Roles
       def self.all
         Decidim.config.user_roles
@@ -22,7 +20,7 @@ module Decidim
     devise :invitable, :database_authenticatable, :registerable, :confirmable, :timeoutable,
            :recoverable, :rememberable, :trackable, :lockable,
            :decidim_validatable, :decidim_newsletterable,
-           :omniauthable, omniauth_providers: OMNIAUTH_PROVIDERS,
+           :omniauthable, omniauth_providers: Decidim::OmniauthProvider.available.keys,
                           request_keys: [:env], reset_password_keys: [:decidim_organization_id, :email],
                           confirmation_keys: [:decidim_organization_id, :email]
 
@@ -59,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({
@@ -82,6 +82,12 @@ module Decidim
     # Returns a String.
     attr_accessor :invitation_instructions
 
+    # Returns the user corresponding to the given +email+ if it exists and has pending invitations,
+    #   otherwise returns nil.
+    def self.has_pending_invitations?(organization_id, email)
+      invitation_not_accepted.find_by(decidim_organization_id: organization_id, email: email)
+    end
+
     # Returns the presenter for this author, to be used in the views.
     # Required by ActsAsAuthor.
     def presenter
@@ -126,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
@@ -166,6 +183,10 @@ module Decidim
       accepted_tos_version.to_i >= organization.tos_version.to_i
     end
 
+    def admin_terms_accepted?
+      return true if admin_terms_accepted_at
+    end
+
     # Whether this user can be verified against some authorization or not.
     def verifiable?
       confirmed? || managed? || being_impersonated?
@@ -183,6 +204,33 @@ module Decidim
       @interested_scopes ||= organization.scopes.where(id: interested_scopes_ids)
     end
 
+    # Caches a Decidim::DataPortabilityUploader with the retrieved file.
+    def data_portability_file(filename)
+      @data_portability_file ||= DataPortabilityUploader.new.tap do |uploader|
+        uploader.retrieve_from_store!(filename)
+        uploader.cache!(filename)
+      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_base_entity.rb

@@ -11,15 +11,19 @@ module Decidim
     include Resourceable
     include Decidim::Followable
     include Decidim::Loggable
+    include Decidim::HasUploadValidations
 
     belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
     has_many :notifications, foreign_key: "decidim_user_id", class_name: "Decidim::Notification", dependent: :destroy
     has_many :following_follows, foreign_key: "decidim_user_id", class_name: "Decidim::Follow", dependent: :destroy
 
-    validates :avatar, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_avatar_size } }
+    # Regex for name & nickname format validations
+    REGEXP_NAME = /\A(?!.*[<>?%&\^*#@\(\)\[\]\=\+\:\;\"\{\}\\\|])/.freeze
+
+    validates_avatar
     mount_uploader :avatar, Decidim::AvatarUploader
 
-    validates :name, :nickname, format: { with: /\A(?!.*[<>?%&\^*#@\(\)\[\]\=\+\:\;\"\{\}\\\|])/ }
+    validates :name, :nickname, format: { with: REGEXP_NAME }
 
     # Public: Returns a collection with all the entities this user is following.
     #

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
@@ -45,6 +46,7 @@ module Decidim
                     permission_action.action == :read
 
       return allow! if component.published?
+      return allow! if user_can_preview_component?
       return allow! if user_can_admin_component?
       return allow! if user_can_admin_component_via_space?
 
@@ -71,10 +73,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 +106,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 +122,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)
 
-      conversation = context.fetch(:conversation, nil)
-      toggle_allow(conversation.participants.include?(user))
+      if [:create, :update].include?(permission_action.action)
+        return disallow! unless conversation&.accept_user? interlocutor
+      end
+
+      toggle_allow(conversation&.participating?(interlocutor))
     end
 
     def user_group_action?
@@ -139,6 +153,14 @@ module Decidim
       allow! if permission_action.subject == :user_group_invitations
     end
 
+    def user_can_preview_component?
+      return allow! if context[:share_token].present? && Decidim::ShareToken.use!(token_for: component, token: context[:share_token])
+    rescue ActiveRecord::RecordNotFound
+      nil
+    rescue StandardError
+      nil
+    end
+
     def user_can_admin_component?
       new_permission_action = Decidim::PermissionAction.new(
         action: permission_action.action,