decidim-core 0.15.2 → 0.16.0

data/app/queries/decidim/metrics/users_metric_manage.rb

@@ -13,7 +13,7 @@ module Decidim
       def query
         return @query if @query
 
-        @query = Decidim::User
+        @query = Decidim::User.where(organization: @organization)
         @query = @query.where("confirmed_at <= ?", end_time).not_managed.confirmed
         @query
       end

data/app/queries/decidim/public_components.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This query finds the published components for all public participatory
+  # spaces in the given organization. Can filter by manifest name.
+  class PublicComponents < Rectify::Query
+    def self.for(organization, manifest_name: nil)
+      new(organization, manifest_name: manifest_name).query
+    end
+
+    def initialize(organization, manifest_name: nil)
+      @organization = organization
+      @manifest_name = manifest_name
+    end
+
+    def query
+      results = Decidim::Component.where(participatory_space: public_spaces).published
+      results = results.where(manifest_name: manifest_name) if manifest_name.present?
+      results
+    end
+
+    private
+
+    attr_reader :organization, :manifest_name
+
+    def public_spaces
+      Decidim.participatory_space_manifests.flat_map do |manifest|
+        manifest.participatory_spaces.call(organization).public_spaces
+      end
+    end
+  end
+end

data/app/resolvers/decidim/core/metric_resolver.rb

@@ -6,33 +6,65 @@ module Decidim
     class MetricResolver
       attr_reader :name
 
-      def initialize(name, organization)
+      #
+      # - name: name identifier of metric
+      # - organization: Decidim::Organization scoping
+      # - filters: hash of attr - value to filter results
+      #
+      def initialize(name, organization, filters = {})
         @name = name
         @organization = organization
+        @filters = filters
         @group_by = :day
         @counter_field = :cumulative
       end
 
       def count
-        metric_scope.max.try(:last) || 0
+        resolve.max.try(:last) || 0
       end
 
       def history
-        metric_scope
+        resolve
       end
 
       private
 
-      def metric_scope
-        Decidim::Metric
-          .where(metric_type: name, organization: organization)
-          .group(group_by)
-          .order("#{group_by} DESC")
-          .limit(60)
-          .sum(counter_field)
+      def resolve
+        return @records if @records
+
+        scope
+        filter
+        group
+        sum
+        @records
+      end
+
+      def scope
+        @records = Decidim::Metric
+                   .where(metric_type: name, organization: organization)
+      end
+
+      # Only key name attributes in Decidim::Metric will be applied
+      def filter
+        @filters.each do |key, value|
+          next unless Decidim::Metric.column_names.include? key.to_s
+          @records = @records.where("#{key}": value)
+        end
+      end
+
+      def group
+        @records = @records
+                   .group(group_by)
+                   .order("#{group_by} DESC")
+      end
+
+      def sum
+        @records = @records
+                   .limit(60)
+                   .sum(counter_field)
       end
 
-      attr_reader :organization, :group_by, :counter_field
+      attr_reader :organization, :filters, :group_by, :counter_field
     end
   end
 end

data/app/services/decidim/action_logger.rb

@@ -53,6 +53,8 @@ module Decidim
         resource_type: resource.class.name,
         participatory_space: participatory_space,
         component: component,
+        area: area,
+        scope: scope,
         version_id: version_id,
         extra: extra_data,
         visibility: visibility
@@ -76,6 +78,14 @@ module Decidim
       resource.participatory_space if resource.respond_to?(:participatory_space)
     end
 
+    def area
+      resource.try(:area) || participatory_space.try(:area)
+    end
+
+    def scope
+      resource.try(:scope) || participatory_space.try(:scope)
+    end
+
     def title_for(resource)
       resource.try(:title) || resource.try(:name) || resource.try(:subject)
     end

data/app/services/decidim/activity_search.rb

@@ -2,13 +2,35 @@
 
 module Decidim
   # A class to search for recent activity performed in a Decidim Organization.
+  # It is intended to be used in the user profile, to retrieve activity and
+  # timeline for that user.
+  #
+  # It will return any action for a given resource, except `create` on resources
+  # that implement the `Decidim::Publicable` concern to avoid leaking private
+  # data.
+  #
+  # Possible options:
+  #
+  # :organization - the `Decidim::Organization` to scope to search. Required.
+  # :user - an optional `Decidim::USer` that performed the activites
+  # :follows - a collection of `Decidim::Follow` resources. It will return any
+  #   activity affecting any of these resources, performed by any of them or
+  #   contained in any of them as spaces.
+  # :scopes - a collection of `Decidim::Scope`. It will return any activity that
+  #   took place in any of those scopes.
   class ActivitySearch < Searchlight::Search
     # Needed by Searchlight, this is the base query that will be used to
     # append other criteria to the search.
     def base_query
-      ActionLog
-        .where(visibility: %w(public-only all))
-        .where(organization: options.fetch(:organization))
+      query = ActionLog
+              .where(visibility: %w(public-only all))
+              .where(organization: options.fetch(:organization))
+
+      query = query.where(user: options[:user]) if options[:user]
+
+      query = filter_follows(query)
+
+      query
     end
 
     # Overwrites the default Searchlight run method since we want to return
@@ -53,24 +75,77 @@ module Decidim
     end
 
     def scope_for(resource_type)
-      action = if publicable_resource_types.include?(resource_type)
-                 "publish"
-               else
-                 "create"
-               end
-
-      query.where(resource_type: resource_type, action: action)
+      if publicable_resource_types.include?(resource_type)
+        query.where(resource_type: resource_type).where.not(action: "create")
+      else
+        query.where(resource_type: resource_type)
+      end
     end
 
     def all_resources_scope
       query
         .where(
-          "(action = ? AND resource_type IN (?)) OR (action = ? AND resource_type IN (?))",
-          "publish",
-          publicable_resource_types,
+          "(action <> ? AND resource_type IN (?)) OR (resource_type IN (?))",
           "create",
+          publicable_resource_types,
           (resource_types - publicable_resource_types)
         )
     end
+
+    def filter_follows(query)
+      follows = options[:follows]
+      interesting_scopes = options[:scopes]
+      conditions = []
+
+      if follows.present?
+        conditions += follows.group_by(&:decidim_followable_type).map do |type, grouped_follows|
+          Decidim::ActionLog.arel_table[:resource_type].eq(type).and(
+            Decidim::ActionLog.arel_table[:resource_id].in(grouped_follows.map(&:decidim_followable_id))
+          )
+        end
+
+        conditions += followed_users_conditions(follows)
+        conditions += followed_spaces_conditions(follows)
+      end
+
+      conditions += interesting_scopes_conditions(interesting_scopes)
+
+      return query if conditions.empty?
+
+      chained_conditions = conditions.inject do |previous_condition, condition|
+        next condition unless previous_condition
+        previous_condition.or(condition)
+      end
+
+      query.where(chained_conditions)
+    end
+
+    def followed_users_conditions(follows)
+      followed_users = follows.where(decidim_followable_type: "Decidim::UserBaseEntity")
+      return [] if followed_users.empty?
+
+      [Decidim::ActionLog.arel_table[:decidim_user_id].in(followed_users.map(&:decidim_followable_id))]
+    end
+
+    def followed_spaces_conditions(follows)
+      followed_spaces = follows.where(decidim_followable_type: participatory_space_classes)
+      return [] if followed_spaces.empty?
+
+      followed_spaces.group_by(&:decidim_followable_type).map do |type, grouped_follows|
+        Decidim::ActionLog.arel_table[:participatory_space_type].eq(type).and(
+          Decidim::ActionLog.arel_table[:participatory_space_id].in(grouped_follows.map(&:decidim_followable_id))
+        )
+      end
+    end
+
+    def interesting_scopes_conditions(interesting_scopes)
+      return [] if interesting_scopes.blank?
+
+      [Decidim::ActionLog.arel_table[:decidim_scope_id].in(interesting_scopes.map(&:id))]
+    end
+
+    def participatory_space_classes
+      Decidim.participatory_space_manifests.map(&:model_class_name)
+    end
   end
 end

data/app/services/decidim/email_notification_generator.rb

@@ -12,14 +12,21 @@ module Decidim
     # event - A String with the name of the event.
     # event_class - A class that wraps the event.
     # resource - an instance of a class implementing the `Decidim::Resource` concern.
+    # followers - a collection of Users that receive the notification because
+    #   they're following it
+    # affected_users - a collection of Users that receive the notification because
+    #   they're affected by it
     # extra - a Hash with extra information to be included in the notification.
-    def initialize(event, event_class, resource, recipient_ids, extra)
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(event, event_class, resource, followers, affected_users, extra)
       @event = event
       @event_class = event_class
       @resource = resource
-      @recipient_ids = recipient_ids
+      @followers = followers
+      @affected_users = affected_users
       @extra = extra
     end
+    # rubocop:enable Metrics/ParameterLists
 
     # Schedules a job for each recipient to send the email. Returns `nil`
     # if the resource is not resource or if it is not present.
@@ -29,23 +36,30 @@ module Decidim
       return unless resource
       return unless event_class.types.include?(:email)
 
-      recipient_ids.each do |recipient_id|
-        send_email_to(recipient_id)
+      followers.each do |recipient|
+        next unless ["all", "followed-only"].include?(recipient.notification_types)
+        send_email_to(recipient, user_role: :follower)
+      end
+
+      affected_users.each do |recipient|
+        next unless ["all", "own-only"].include?(recipient.notification_types)
+        send_email_to(recipient, user_role: :affected_user)
       end
     end
 
     private
 
-    attr_reader :event, :event_class, :resource, :recipient_ids, :extra
+    attr_reader :event, :event_class, :resource, :followers, :affected_users, :extra
 
     # Private: sends the notification email to the user if they have the
     # `email_on_notification` flag active.
     #
-    # recipient_id - The ID of the user that will receive the email.
+    # recipient - The user that will receive the email.
+    # user_role - the role the user takes for this notification (either
+    #   `:follower` or `:affected_user`)
     #
     # Returns nothing.
-    def send_email_to(recipient_id)
-      recipient = Decidim::User.find_by(id: recipient_id)
+    def send_email_to(recipient, user_role:)
       return unless recipient
       return unless recipient.email_on_notification?
 
@@ -55,6 +69,7 @@ module Decidim
           event_class.name,
           resource,
           recipient,
+          user_role.to_s,
           extra
         )
         .deliver_later

data/app/services/decidim/events_manager.rb

@@ -14,19 +14,25 @@ module Decidim
     #   the resource and builds the needed information to publish the event to
     #   the different subscribers in the system.
     # resource - an instance of a class that received the event.
-    # recipient_ids - an Array of IDs of the users that will receive the event
+    # affected_users - a collection of `Decidim::Users` that are affected by the
+    #   event and will receive a notification about it.
+    # followers - a collection of `Decidim::Users` that should be notified about
+    #   the event, even though it doesn't affect them directly
     # extra - a Hash with extra information to be included in the notification.
     #
     # Returns nothing.
-    def self.publish(event:, event_class: Decidim::Events::BaseEvent, resource:, recipient_ids:, extra: {})
+    # rubocop:disable Metrics/ParameterLists
+    def self.publish(event:, event_class: Decidim::Events::BaseEvent, resource:, affected_users: [], followers: [], extra: {})
       ActiveSupport::Notifications.publish(
         event,
         event_class: event_class.name,
         resource: resource,
-        recipient_ids: recipient_ids.compact.uniq,
+        affected_users: affected_users.uniq.compact,
+        followers: followers.uniq.compact,
         extra: extra
       )
     end
+    # rubocop:enable Metrics/ParameterLists
 
     # Subscribes to the given event, and runs the block every time that event
     # is received.

data/app/services/decidim/home_activity_search.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A class to search for recent activity performed in a Decidim Organization.
+  # It will only return the `Decidim::ActionLog` rows that have an action as
+  # `created` or `published`.
+  #
+  # This class is thought to be used in the `LastActivityCell` uniquely.
+  class HomeActivitySearch < Searchlight::Search
+    # Needed by Searchlight, this is the base query that will be used to
+    # append other criteria to the search.
+    def base_query
+      ActionLog
+        .where(visibility: %w(public-only all))
+        .where(organization: options.fetch(:organization))
+    end
+
+    # Overwrites the default Searchlight run method since we want to return
+    # activities in an specific order but we need to set it at the end of the chain.
+    def run
+      super.order(created_at: :desc)
+    end
+
+    # Adds a constrain to filter by resource type(s).
+    def search_resource_type
+      if resource_types.include?(resource_type)
+        scope_for(resource_type)
+      else
+        all_resources_scope
+      end
+    end
+
+    # All the resource types that are eligible to be included as an activity.
+    def resource_types
+      @resource_types ||= %w(
+        Decidim::Accountability::Result
+        Decidim::Blogs::Post
+        Decidim::Comments::Comment
+        Decidim::Consultations::Question
+        Decidim::Debates::Debate
+        Decidim::Meetings::Meeting
+        Decidim::Proposals::Proposal
+        Decidim::Surveys::Survey
+        Decidim::Assembly
+        Decidim::Consultation
+        Decidim::Initiative
+        Decidim::ParticipatoryProcess
+      ).select do |klass|
+        klass.safe_constantize.present?
+      end
+    end
+
+    private
+
+    def publicable_resource_types
+      @publicable_resource_types ||= resource_types.select { |klass| klass.constantize.column_names.include?("published_at") }
+    end
+
+    def scope_for(resource_type)
+      action = if publicable_resource_types.include?(resource_type)
+                 "publish"
+               else
+                 "create"
+               end
+
+      query.where(resource_type: resource_type, action: action)
+    end
+
+    def all_resources_scope
+      query
+        .where(
+          "(action = ? AND resource_type IN (?)) OR (action = ? AND resource_type IN (?))",
+          "publish",
+          publicable_resource_types,
+          "create",
+          (resource_types - publicable_resource_types)
+        )
+    end
+  end
+end