decidim-core 0.14.4 → 0.15.0

data/app/forms/decidim/notifications_settings_form.rb

@@ -16,5 +16,9 @@ module Decidim
       return nil unless newsletter_notifications
       Time.current
     end
+
+    def map_model(model)
+      self.newsletter_notifications = model.newsletter_notifications_at.present?
+    end
   end
 end

data/app/forms/decidim/registration_form.rb

@@ -5,7 +5,6 @@ module Decidim
   class RegistrationForm < Form
     mimic :user
 
-    attribute :sign_up_as, String
     attribute :name, String
     attribute :nickname, String
     attribute :email, String
@@ -14,11 +13,6 @@ module Decidim
     attribute :newsletter, Boolean
     attribute :tos_agreement, Boolean
 
-    attribute :user_group_name, String
-    attribute :user_group_document_number, String
-    attribute :user_group_phone, String
-
-    validates :sign_up_as, inclusion: { in: %w(user user_group) }
     validates :name, presence: true
     validates :nickname, presence: true, length: { maximum: Decidim::User.nickname_max_length }
     validates :email, presence: true, 'valid_email_2/email': { disposable: true }
@@ -27,18 +21,8 @@ module Decidim
     validates :password_confirmation, presence: true
     validates :tos_agreement, allow_nil: false, acceptance: true
 
-    validates :user_group_name, presence: true, if: :user_group?
-    validates :user_group_document_number, presence: true, if: :user_group?
-    validates :user_group_phone, presence: true, if: :user_group?
-
     validate :email_unique_in_organization
     validate :nickname_unique_in_organization
-    validate :user_group_name_unique_in_organization
-    validate :user_group_document_number_unique_in_organization
-
-    def user_group?
-      sign_up_as == "user_group"
-    end
 
     def newsletter_at
       return nil unless newsletter?
@@ -54,16 +38,5 @@ module Decidim
     def nickname_unique_in_organization
       errors.add :nickname, :taken if User.find_by(nickname: nickname, organization: current_organization).present?
     end
-
-    def user_group_name_unique_in_organization
-      errors.add :user_group_name, :taken if UserGroup.find_by(name: user_group_name, decidim_organization_id: current_organization.id).present?
-    end
-
-    def user_group_document_number_unique_in_organization
-      errors.add :user_group_document_number, :taken if UserGroup.find_by(
-        document_number: user_group_document_number,
-        decidim_organization_id: current_organization.id
-      ).present?
-    end
   end
 end

data/app/forms/decidim/user_group_form.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Decidim
+  # The form object that handles the data behind creating a user group.
+  class UserGroupForm < Form
+    mimic :group
+
+    attribute :name
+    attribute :nickname
+    attribute :email
+    attribute :avatar
+    attribute :about
+    attribute :document_number
+    attribute :phone
+
+    validates :name, presence: true
+    validates :email, presence: true, 'valid_email_2/email': { disposable: true }
+    validates :nickname, presence: true
+    validates :document_number, presence: true
+    validates :phone, presence: true
+
+    validates :nickname, length: { maximum: Decidim::User.nickname_max_length, allow_blank: true }
+    validates :avatar, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_avatar_size } }
+
+    validate :unique_document_number
+    validate :unique_email
+    validate :unique_name
+    validate :unique_nickname
+
+    private
+
+    def unique_document_number
+      errors.add :document_number, :taken if UserGroup
+                                             .with_document_number(
+                                               context.current_organization,
+                                               document_number
+                                             )
+                                             .where.not(id: id)
+                                             .present?
+    end
+
+    def unique_email
+      return true if Decidim::UserBaseEntity
+                     .where(
+                       organization: context.current_organization,
+                       email: email
+                     )
+                     .where.not(id: id)
+                     .empty?
+
+      errors.add :email, :taken
+      false
+    end
+
+    def unique_name
+      return true if Decidim::UserBaseEntity
+                     .where(
+                       organization: context.current_organization,
+                       name: name
+                     )
+                     .where.not(id: id)
+                     .empty?
+
+      errors.add :name, :taken
+      false
+    end
+
+    def unique_nickname
+      return true if Decidim::UserBaseEntity
+                     .where(
+                       organization: context.current_organization,
+                       nickname: nickname
+                     )
+                     .where.not(id: id)
+                     .empty?
+
+      errors.add :nickname, :taken
+      false
+    end
+  end
+end

data/app/helpers/decidim/component_path_helper.rb

@@ -32,5 +32,15 @@ module Decidim
       current_params = try(:params) || {}
       EngineRouter.admin_proxy(component).root_path(locale: current_params[:locale])
     end
+
+    # Returns whether the component can be managed or not by checking if it has
+    # an admin engine.
+    #
+    # component - the Component we want to find if it's manageable or not.
+    #
+    # Returns a boolean matching the question.
+    def can_be_managed?(component)
+      component.manifest.admin_engine.present?
+    end
   end
 end

data/app/helpers/decidim/filters_helper.rb

@@ -7,12 +7,13 @@ module Decidim
     # the form_for helper with a custom builder
     #
     # filter - A filter object
+    # url    - A String with the URL to post the from. Self URL by default.
     # block  - A block to be called with the form builder
     #
     # Returns the filter resource form wrapped in a div
-    def filter_form_for(filter)
+    def filter_form_for(filter, url = url_for)
       content_tag :div, class: "filters" do
-        form_for filter, builder: FilterFormBuilder, url: url_for, as: :filter, method: :get, remote: true, html: { id: nil } do |form|
+        form_for filter, builder: FilterFormBuilder, url: url, as: :filter, method: :get, remote: true, html: { id: nil } do |form|
           yield form
         end
       end

data/app/helpers/decidim/icon_helper.rb

@@ -40,7 +40,9 @@ module Decidim
     #
     # Returns an HTML tag with the icon.
     def resource_icon(resource, options = {})
-      if resource.respond_to?(:component)
+      if resource.class.name == "Decidim::Comments::Comment"
+        icon "comment-square", options
+      elsif resource.respond_to?(:component)
         component_icon(resource.component, options)
       elsif resource.respond_to?(:manifest)
         manifest_icon(resource.manifest, options)

data/app/helpers/decidim/map_helper.rb

@@ -33,7 +33,7 @@ module Decidim
         "data-here-app-id" => Decidim.geocoder[:here_app_id],
         "data-here-app-code" => Decidim.geocoder[:here_app_code]
       }
-      content = capture { yield }
+      content = capture { yield }.html_safe
       content_tag :div, class: "row column" do
         content_tag(:div, "", map_html_options) + content
       end

data/app/jobs/decidim/metric_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  class MetricJob < ApplicationJob
+    queue_as :metrics
+
+    def perform(manager_class, organization_id, day = nil)
+      organization = Decidim::Organization.find_by(id: organization_id)
+      return unless organization
+      metric = manager_class.constantize.for(day, organization)
+      metric.save if metric.valid?
+    end
+  end
+end

data/app/mailers/decidim/newsletter_mailer.rb

@@ -8,6 +8,8 @@ module Decidim
     add_template_helper Decidim::TranslationsHelper
 
     def newsletter(user, newsletter)
+      return if user.email.blank?
+
       @organization = user.organization
       @newsletter = newsletter
       @user = user

data/app/mailers/decidim/notification_mailer.rb

@@ -7,7 +7,7 @@ module Decidim
     helper Decidim::ResourceHelper
 
     def event_received(event, event_class_name, resource, user, extra)
-      return unless user.email
+      return if user.email.blank?
 
       with_user(user) do
         @organization = user.organization

data/app/models/decidim/action_log.rb

@@ -32,10 +32,16 @@ module Decidim
 
     validates :organization, :user, :action, presence: true
     validates :resource, presence: true, if: ->(log) { log.action != "delete" }
+    validates :visibility, presence: true, inclusion: { in: %w(admin-only public-only all) }
 
     # To ensure records can't be deleted
     before_destroy { |_record| raise ActiveRecord::ReadOnlyRecord }
 
+    # A scope that filters all the logs that should be visible at the admin panel.
+    def self.for_admin
+      where(visibility: %w(admin-only all))
+    end
+
     # Overwrites the method so that records cannot be modified.
     #
     # Returns a Boolean.
@@ -43,6 +49,39 @@ module Decidim
       !new_record?
     end
 
+    # Lazy loads the `component` association through BatchLoader, can be used
+    # as a regular object.
+    def component_lazy(cache: true)
+      self.class.lazy_relation(decidim_component_id, "Decidim::Component", cache)
+    end
+
+    # Lazy loads the `organization` association through BatchLoader, can be used
+    # as a regular object.
+    def organization_lazy(cache: true)
+      self.class.lazy_relation(decidim_organization_id, "Decidim::Organization", cache)
+    end
+
+    # Lazy loads the `user` association through BatchLoader, can be used
+    # as a regular object.
+    def user_lazy(cache: true)
+      self.class.lazy_relation(decidim_user_id, "Decidim::User", cache)
+    end
+
+    # Lazy loads the `participatory_space` association through BatchLoader, can be used
+    # as a regular object.
+    def participatory_space_lazy(cache: true)
+      return if participatory_space_id.blank? || participatory_space_type.blank?
+      return resouce_lazy if participatory_space_id == resource_id && participatory_space_type == resource_type
+
+      self.class.lazy_relation(participatory_space_id, participatory_space_type, cache)
+    end
+
+    # Lazy loads the `resource` association through BatchLoader, can be used
+    # as a regular object.
+    def resource_lazy(cache: true)
+      self.class.lazy_relation(resource_id, resource_type, cache)
+    end
+
     # Public: Finds the correct presenter class for the given
     # `log_type` and the related `resource_type`. If no specific
     # presenter can be found, it falls back to `Decidim::Log::BasePresenter`
@@ -55,5 +94,32 @@ module Decidim
     rescue NameError
       Decidim::Log::BasePresenter
     end
+
+    # Returns a Batchloader for a given class to avoid N+1 queries.
+    #
+    # Since ActionLogs are related to many different resources, loading a collection
+    # of them would trigger a lot of N+1 queries. We're using BatchLoader to
+    # accumulate and group all the resource by their class and only loading them
+    # when it's necessary.
+    def self.lazy_relation(id_method, klass_name, cache)
+      klass = klass_name.constantize
+      BatchLoader.for(id_method).batch(cache: cache, key: klass.name.underscore) do |relation_ids, loader|
+        scope = klass.where(id: relation_ids)
+
+        scope = if klass.include?(Decidim::HasComponent)
+                  scope.where(id: relation_ids).includes(:component).where.not(decidim_components: { published_at: nil })
+                elsif klass.reflect_on_association(:organization)
+                  scope.where(id: relation_ids).includes(:organization)
+                elsif klass_name == "Decidim::Comments::Comment"
+                  scope.where(id: relation_ids).includes(:commentable)
+                else
+                  scope
+                end
+
+        scope = scope.published if klass.include?(Decidim::Publicable)
+
+        scope.each { |relation| loader.call(relation.id, relation) }
+      end
+    end
   end
 end

data/app/models/decidim/coauthorship.rb

@@ -8,6 +8,8 @@ module Decidim
 
     validates :coauthorable, presence: true
 
+    after_commit :author_is_follower, on: [:create]
+
     def identity
       user_group || author
     end
@@ -19,5 +21,12 @@ module Decidim
     def organization
       coauthorable&.organization
     end
+
+    def author_is_follower
+      return unless author.is_a?(Decidim::User)
+      return unless coauthorable.is_a?(Decidim::Followable)
+
+      Decidim::Follow.find_or_create_by!(followable: coauthorable, user: author)
+    end
   end
 end

data/app/models/decidim/component.rb

@@ -20,6 +20,11 @@ module Decidim
       Decidim::AdminLog::ComponentPresenter
     end
 
+    # 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)
+    end
+
     # Public: Finds the manifest this component is associated to.
     #
     # Returns a ComponentManifest.

data/app/models/decidim/continuity_badge_status.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Decidim
+  class ContinuityBadgeStatus < ApplicationRecord
+    belongs_to :subject, polymorphic: true
+
+    validates :subject, :current_streak, :last_session_at, presence: true
+  end
+end

data/app/models/decidim/gamification/badge_score.rb

@@ -5,7 +5,7 @@ module Decidim
     class BadgeScore < ApplicationRecord
       self.table_name = "decidim_gamification_badge_scores"
 
-      belongs_to :user, class_name: "Decidim::User"
+      belongs_to :user, class_name: "Decidim::UserBaseEntity"
       validates :user, presence: true
       validates :value, numericality: { greater_than_or_equal_to: 0 }
     end

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

@@ -16,6 +16,7 @@ module Decidim
 
       belongs_to :conversation,
                  foreign_key: :decidim_conversation_id,
+                 touch: true,
                  class_name: "Decidim::Messaging::Conversation"
 
       has_many :receipts,

data/app/models/decidim/metric.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A Metric is a registry that holds cumulative and quantity value by day, category, participatory_space, category, an a related object
+  class Metric < ApplicationRecord
+    # ParticipatorySpace, RelatedObject and Category are optional relationships because not all metric objects need them
+    # For example, User is only related to an organization, but a Proposal can have all of them
+    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
+    belongs_to :participatory_space, foreign_key: "participatory_space_id", foreign_type: "participatory_space_type", polymorphic: true, optional: true
+    belongs_to :related_object, foreign_key: "related_object_id", foreign_type: "related_object_type", polymorphic: true, optional: true
+    belongs_to :category, foreign_key: "decidim_category_id", class_name: "Decidim::Category", optional: true
+  end
+end

data/app/models/decidim/participatory_space_private_user.rb

@@ -18,6 +18,10 @@ module Decidim
       Decidim::DataPortabilitySerializers::DataPortabilityParticipatorySpacePrivateUserSerializer
     end
 
+    def self.log_presenter_class_for(_log)
+      Decidim::AdminLog::ParticipatorySpacePrivateUserPresenter
+    end
+
     private
 
     # Private: check if the participatory space and the user have the same organization

data/app/models/decidim/user.rb

@@ -6,11 +6,7 @@ require "valid_email2"
 
 module Decidim
   # A User is a citizen that wants to join the platform to participate.
-  class User < ApplicationRecord
-    include Nicknamizable
-    include Resourceable
-    include Decidim::Followable
-    include Decidim::Loggable
+  class User < UserBaseEntity
     include Decidim::DataPortability
     include Decidim::Searchable
 
@@ -24,21 +20,17 @@ module Decidim
                           request_keys: [:env], reset_password_keys: [:decidim_organization_id, :email],
                           confirmation_keys: [:decidim_organization_id, :email]
 
-    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
     has_many :identities, foreign_key: "decidim_user_id", class_name: "Decidim::Identity", dependent: :destroy
     has_many :memberships, class_name: "Decidim::UserGroupMembership", foreign_key: :decidim_user_id, dependent: :destroy
     has_many :user_groups, through: :memberships, class_name: "Decidim::UserGroup", foreign_key: :decidim_user_group_id
-    has_many :notifications, foreign_key: "decidim_user_id", class_name: "Decidim::Notification", dependent: :destroy
     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_many :following_follows, foreign_key: "decidim_user_id", class_name: "Decidim::Follow", dependent: :destroy
 
     validates :name, presence: true, unless: -> { deleted? }
-    validates :nickname, presence: true, unless: -> { deleted? || managed? || name.blank? }, length: { maximum: Decidim::User.nickname_max_length }
+    validates :nickname, presence: true, unless: -> { deleted? || managed? }, length: { maximum: Decidim::User.nickname_max_length }
     validates :locale, inclusion: { in: :available_locales }, allow_blank: true
     validates :tos_agreement, acceptance: true, allow_nil: false, on: :create
     validates :tos_agreement, acceptance: true, if: :user_invited?
-    validates :avatar, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_avatar_size } }
     validates :email, :nickname, uniqueness: { scope: :organization }, unless: -> { deleted? || managed? || nickname.blank? }
 
     validate :all_roles_are_valid
@@ -53,6 +45,9 @@ module Decidim
     scope :officialized, -> { where.not(officialized_at: nil) }
     scope :not_officialized, -> { where(officialized_at: nil) }
 
+    scope :confirmed, -> { where.not(confirmed_at: nil) }
+    scope :not_confirmed, -> { where(confirmed_at: nil) }
+
     attr_accessor :newsletter_notifications
 
     searchable_fields({
@@ -112,34 +107,6 @@ module Decidim
       Decidim::Follow.where(user: self, followable: followable).any?
     end
 
-    # Public: Returns a collection with all the entities this user is following.
-    #
-    # This can't be done as with a `has_many :following, through: :following_follows`
-    # since it's a polymorphic relation and Rails doesn't know how to load it. With
-    # this implementation we only query the database once for each kind of following.
-    #
-    # 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
-    end
-
-    def following_users
-      @following_users ||= following.select do |f|
-        f.is_a?(Decidim::User)
-      end
-    end
-
     def unread_conversations
       Decidim::Messaging::Conversation.unread_by(self)
     end
@@ -176,6 +143,15 @@ module Decidim
       accepted_tos_version >= organization.tos_version
     end
 
+    # Whether this user can be verified against some authorization or not.
+    def verifiable?
+      confirmed? || managed? || being_impersonated?
+    end
+
+    def being_impersonated?
+      ImpersonationLog.active.where(user: self).exists?
+    end
+
     protected
 
     # Overrides devise email required validation.