decidim-core 0.14.4 → 0.15.0

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Metrics
+    # Metric manager for User's registries
+    class UsersMetricManage < Decidim::MetricManage
+      def metric_name
+        "users"
+      end
+
+      private
+
+      def query
+        return @query if @query
+
+        @query = Decidim::User
+        @query = @query.where("confirmed_at <= ?", end_time).not_managed.confirmed
+        @query
+      end
+
+      def quantity
+        @quantity ||= @query.where("confirmed_at >= ?", start_time).count
+      end
+    end
+  end
+end

data/app/queries/decidim/user_groups/accepted_memberships.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module UserGroups
+    # Use this class to find the accepted memberships of the given user group.
+    class AcceptedMemberships < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # user_group - a UserGroup that needs to find its accepted memberships
+      def self.for(user_group)
+        new(user_group).query
+      end
+
+      # Initializes the class.
+      #
+      # user_group - a UserGroup that needs to find its accepted memberships
+      def initialize(user_group)
+        @user_group = user_group
+      end
+
+      # Finds the accepted memberships of the user group.
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        user_group
+          .memberships
+          .includes(:user)
+          .where(role: %w(creator admin member))
+      end
+
+      private
+
+      attr_reader :user_group
+    end
+  end
+end

data/app/queries/decidim/user_groups/accepted_user_groups.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module UserGroups
+    # Use this class to find the user groups the given user is accepted. In order
+    # to calculate this, we get those groups where the user has a role of
+    # member, creator or admin.
+    class AcceptedUserGroups < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # user - a User that needs to find the groups where they are accepted
+      def self.for(user)
+        new(user).query
+      end
+
+      # Initializes the class.
+      #
+      # user - a User that needs to find the groups where they are accepted
+      def initialize(user)
+        @user = user
+      end
+
+      # Finds the UserGroups where the user has an accepted membership.
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        user
+          .user_groups
+          .includes(:memberships)
+          .where(decidim_user_group_memberships: { role: %w(creator admin member) })
+      end
+
+      private
+
+      attr_reader :user
+    end
+  end
+end

data/app/queries/decidim/user_groups/accepted_users.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module UserGroups
+    # Use this class to find the accepted members of the given user group.
+    class AcceptedUsers < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # user_group - a UserGroup that needs to find its accepted members
+      def self.for(user_group)
+        new(user_group).query
+      end
+
+      # Initializes the class.
+      #
+      # user_group - a UserGroup that needs to find its accepted members
+      def initialize(user_group)
+        @user_group = user_group
+      end
+
+      # Finds the accepted members of the user group.
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        user_group
+          .users
+          .includes(:memberships)
+          .where(decidim_user_group_memberships: { role: %w(creator admin member) })
+      end
+
+      private
+
+      attr_reader :user_group
+    end
+  end
+end

data/app/queries/decidim/user_groups/admin_memberships.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module UserGroups
+    # Use this class to find the the admins of the given user group with the
+    # "member" role. It returns memberships.
+    class AdminMemberships < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # user_group - a UserGroup that needs to find its admin users
+      def self.for(user_group)
+        new(user_group).query
+      end
+
+      # Initializes the class.
+      #
+      # user_group - a UserGroup that needs to find its member users
+      def initialize(user_group)
+        @user_group = user_group
+      end
+
+      # Finds the member users of the user group.
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        user_group
+          .memberships
+          .includes(:user)
+          .where(role: :admin)
+      end
+
+      private
+
+      attr_reader :user_group
+    end
+  end
+end

data/app/queries/decidim/user_groups/invited_memberships.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module UserGroups
+    # Use this class to find the invitations to user groups the given user has.
+    class InvitedMemberships < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # user - a User that needs to find which groups they have been invited to
+      def self.for(user)
+        new(user).query
+      end
+
+      # Initializes the class.
+      #
+      # user - a User that needs to find which groups they have been invited to
+      def initialize(user)
+        @user = user
+      end
+
+      # Finds the UserGroupMemberships the user has been invited to.
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        user
+          .memberships
+          .includes(:user_group)
+          .where(role: "invited")
+      end
+
+      private
+
+      attr_reader :user
+    end
+  end
+end

data/app/queries/decidim/user_groups/manageable_user_groups.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module UserGroups
+    # Use this class to find the user groups the given user can manage. In order
+    # to calculate this, we get those groups where the user has a role of
+    # creator or admin.
+    class ManageableUserGroups < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # user - a User that needs to find which groups can manage
+      def self.for(user)
+        new(user).query
+      end
+
+      # Initializes the class.
+      #
+      # user - a User that needs to find which groups can manage
+      def initialize(user)
+        @user = user
+      end
+
+      # Finds the UserGroups where the user has a role of `:admin` or
+      # `:creator`.
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        user
+          .user_groups
+          .includes(:memberships)
+          .where(decidim_user_group_memberships: { role: %w(admin creator) })
+      end
+
+      private
+
+      attr_reader :user
+    end
+  end
+end

data/app/queries/decidim/user_groups/member_memberships.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module UserGroups
+    # Use this class to find the the members of the given user group with the
+    # "member" role. It returns memberships.
+    class MemberMemberships < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # user_group - a UserGroup that needs to find its member users
+      def self.for(user_group)
+        new(user_group).query
+      end
+
+      # Initializes the class.
+      #
+      # user_group - a UserGroup that needs to find its member users
+      def initialize(user_group)
+        @user_group = user_group
+      end
+
+      # Finds the member users of the user group.
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        user_group
+          .memberships
+          .includes(:user)
+          .where(role: :member)
+      end
+
+      private
+
+      attr_reader :user_group
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # A GraphQL resolver to handle `count` and `metric` queries
+    class MetricResolver
+      attr_reader :name
+
+      def initialize(name, organization)
+        @name = name
+        @organization = organization
+        @group_by = :day
+        @counter_field = :cumulative
+      end
+
+      def count
+        metric_scope.max.try(:last) || 0
+      end
+
+      def history
+        metric_scope
+      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)
+      end
+
+      attr_reader :organization, :group_by, :counter_field
+    end
+  end
+end

data/app/services/decidim/action_logger.rb

@@ -36,6 +36,7 @@ module Decidim
       @resource = resource
       @version_id = version_id
       @resource_extra = resource_extra
+      @visibility = resource_extra.delete(:visibility).presence || "admin-only"
     end
 
     # Public: Logs the given `action` by the given `user` on the given
@@ -53,13 +54,14 @@ module Decidim
         participatory_space: participatory_space,
         component: component,
         version_id: version_id,
-        extra: extra_data
+        extra: extra_data,
+        visibility: visibility
       )
     end
 
     private
 
-    attr_reader :action, :user, :resource, :resource_extra, :version_id
+    attr_reader :action, :user, :resource, :resource_extra, :version_id, :visibility
 
     def organization
       user.organization

data/app/services/decidim/activity_search.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A class to search for recent activity performed in a Decidim Organization.
+  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))
+    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

data/app/services/decidim/continuity_badge_tracker.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class keeps tabs on a user's consecutive days streak
+  # so it can update the score of their continuity badge.
+  class ContinuityBadgeTracker
+    # Initializes the class with a polymorphic subject
+    #
+    # subject - A in instance of a subclass of ActiveRecord::Base to be tracked
+    #
+    def initialize(subject)
+      @subject = subject
+    end
+
+    # Public: Tracks the past activity of a user to update the continuity badge's
+    # score. It will set it to the amount of consecutive days a user has logged into
+    # the system.
+    #
+    # date - The date of the last user's activity. Usually `Time.zone.today`.
+    #
+    # Returns nothing.
+    def track!(date)
+      @subject.with_lock do
+        last_session_at = status.try(:last_session_at) || date
+        current_streak = status.try(:current_streak) || 1
+
+        streak = if last_session_at == date
+                   current_streak
+                 elsif last_session_at == date - 1.day
+                   current_streak + 1
+                 else
+                   1
+                 end
+
+        update_status(date, streak)
+        update_badge(streak)
+      end
+    end
+
+    private
+
+    def update_badge(streak)
+      score = Decidim::Gamification.status_for(@subject, :continuity).score
+      return unless streak > 1 && streak > score
+
+      Decidim::Gamification.set_score(@subject, :continuity, streak)
+    end
+
+    def status
+      @status ||= ContinuityBadgeStatus.find_by(
+        subject: @subject
+      )
+    end
+
+    def update_status(date, streak)
+      @status = ContinuityBadgeStatus.find_or_initialize_by(
+        subject: @subject
+      ).update(
+        last_session_at: date,
+        current_streak: streak
+      )
+    end
+  end
+end