decidim-core 0.30.1 → 0.31.0.rc1

data/app/presenters/decidim/resource_locator_presenter.rb

@@ -119,7 +119,18 @@ module Decidim
     def manifest_for(record)
       record.try(:resource_manifest) ||
         record.class.try(:resource_manifest) ||
-        record.class.try(:participatory_space_manifest)
+        record.class.try(:participatory_space_manifest) ||
+        record.to_s
+    end
+
+    def route_name_for(record)
+      manifest = manifest_for(record)
+
+      if manifest.respond_to?(:route_name)
+        manifest.route_name
+      else
+        manifest.to_s
+      end
     end
 
     def component
@@ -130,14 +141,14 @@ module Decidim
       if polymorphic?
         polymorphic_member_route_name
       else
-        manifest_for(target).route_name
+        route_name_for(target)
       end
     end
 
     def polymorphic_member_route_name
       return unless polymorphic?
 
-      resource.map { |record| manifest_for(record).route_name }.join("_")
+      resource.map { |record| route_name_for(record) }.join("_")
     end
 
     def collection_route_name
@@ -149,7 +160,7 @@ module Decidim
 
       parent_resources = {}
       (resource - [target]).each do |parent|
-        parent_resources["#{manifest_for(parent).route_name}_id"] = parent.id
+        parent_resources["#{route_name_for(parent)}_id"] = parent.id unless parent.is_a?(String)
       end
       parent_resources
     end

data/app/presenters/decidim/resource_presenter.rb

@@ -6,12 +6,12 @@ module Decidim
     include Decidim::TranslatableAttributes
     include Decidim::SanitizeHelper
 
-    def title(resource_title, links, html_escape, all_locales, extras: true)
+    def title(resource_title, html_escape, all_locales)
       handle_locales(resource_title, all_locales) do |content|
         content = decidim_html_escape(content) if html_escape
 
-        renderer = Decidim::ContentRenderers::HashtagRenderer.new(content)
-        renderer.render(links:, extras:).html_safe
+        renderer = Decidim::ContentRenderers::BlobRenderer.new(content)
+        renderer.render.html_safe
       end
     end
 
@@ -30,16 +30,16 @@ module Decidim
     end
 
     # Prepares the HTML content for the editors with the correct tags included
-    # to identify the hashtags and mentions.
-    def editor_locales(data, all_locales, extras: true)
+    # to identify the mentions.
+    def editor_locales(data, all_locales)
       handle_locales(data, all_locales) do |content|
         [
-          Decidim::ContentRenderers::HashtagRenderer,
+          Decidim::ContentRenderers::BlobRenderer,
           Decidim::ContentRenderers::UserRenderer,
-          Decidim::ContentRenderers::UserGroupRenderer
+          Decidim::ContentRenderers::MentionResourceRenderer
         ].each do |renderer_class|
           renderer = renderer_class.new(content)
-          content = renderer.render(links: false, editor: true, extras:).html_safe
+          content = renderer.render(editor: true).html_safe
         end
 
         content

data/app/presenters/decidim/stats_presenter.rb

@@ -3,83 +3,62 @@
 module Decidim
   # A general presenter to render statistics in participatory spaces.
   class StatsPresenter < SimpleDelegator
-    def comments_stats(name)
-      comments = Decidim.component_manifests.map do |component_manifest|
-        component_manifest.stats.only([:comments_count])
-                          .filter({ tag: :comments })
-                          .with_context(published_components)
-                          .map { |_name, value| value }.sum
-      end
-      comments_count = comments.inject(0, :+) { |sum, value| sum + value }
-      [[name, :comments_count, comments_count]]
-    end
-
-    def statistics(grouped_stats)
-      statistics = {}
-
-      grouped_stats.each do |_manifest_name, stats|
-        stats.each do |_space_manifest, component_manifest, count|
-          next if count.zero?
-
-          statistics[component_manifest] ||= 0
-          statistics[component_manifest] += count
+    # Public: returns a collection of stats (Hash) for the Participatory Space Home.
+    def collection(priority: StatsRegistry::MEDIUM_PRIORITY)
+      stats = all_stats(priority:).reject(&:empty?)
+      stats = stats.reject { |stat| stat[:data].blank? || stat[:data][0].zero? }
+      stats.each_with_object({}) do |stat, hash|
+        name = stat[:name]
+        if hash[name]
+          stat[:data].each_with_index do |value, idx|
+            hash[name][:data][idx] ||= 0
+            hash[name][:data][idx] += value
+          end
+        else
+          hash[name] = stat
         end
-      end
-      statistics.map { |key, number| { stat_title: key, stat_number: number } }
+      end.values
     end
 
-    # Public: returns a collection of stats (Hash) for the Participatory Space Home.
-    def collection
-      highlighted_stats = participatory_space_participants_stats
-      highlighted_stats.concat(participatory_space_followers_stats(priority: StatsRegistry::HIGH_PRIORITY))
-      highlighted_stats.concat(component_stats(priority: StatsRegistry::HIGH_PRIORITY))
-      highlighted_stats.concat(component_stats(priority: StatsRegistry::MEDIUM_PRIORITY))
-      highlighted_stats.concat(comments_stats(participatory_space_sym))
-      highlighted_stats = highlighted_stats.reject(&:empty?)
-      highlighted_stats = highlighted_stats.reject { |_stat_manifest, _stat_title, stat_number| stat_number.zero? }
-      grouped_highlighted_stats = highlighted_stats.group_by(&:first)
-
-      statistics(grouped_highlighted_stats)
+    def all_stats(conditions)
+      @global_stats ||= {}
+      @global_stats[conditions] ||= global_stats(**conditions).concat(component_stats(**conditions))
     end
 
-    def card_collection
-      card_stats = Decidim.stats.only([:followers_count, :votings_count])
-                          .filter(priority: StatsRegistry::HIGH_PRIORITY)
-                          .with_context(participatory_space)
-                          .map { |stat_title, stat_number| [participatory_space_sym, stat_title, stat_number] }
-
-      statistics(card_stats.group_by(&:first))
-    end
+    # Public: returns the entity where to limit the stats on.
+    # Usually, this is a Participatory Space or an Organization.
+    def scope_entity = raise NotImplementedError
 
     private
 
-    def participatory_space = raise "Not implemented"
-
-    def participatory_space_sym = raise "Not implemented"
-
-    def participatory_space_participants_stats
-      Decidim.stats.only([:participants_count]).with_context(participatory_space)
-             .map { |stat_title, stat_number| [participatory_space_sym, stat_title, stat_number] }
+    def global_stats(conditions)
+      Decidim.stats.filter(**conditions).with_context(scope_entity).map do |stat|
+        stat[:data] = [stat[:data]] unless stat[:data].is_a?(Array)
+        stat
+      end
     end
 
     def component_stats(conditions)
       Decidim.component_manifests.map do |component_manifest|
-        component_manifest.stats.except([:proposals_accepted])
+        component_manifest.stats
                           .filter(conditions)
                           .with_context(published_components)
-                          .map { |stat_title, stat_number| [component_manifest.name, stat_title, stat_number] }.flatten
-      end
-    end
-
-    def participatory_space_followers_stats(conditions)
-      Decidim.stats.only([:followers_count])
-             .filter(conditions)
-             .with_context(participatory_space)
-             .map { |stat_title, stat_number| [participatory_space_sym, stat_title, stat_number] }
+                          .map do |stat|
+                            stat[:data] = [stat[:data]] unless stat[:data].is_a?(Array)
+                            stat
+                          end
+      end.flatten
     end
 
+    # Override if the scope_entity is not a Participatory Space or an Organization.
     def published_components
-      @published_components ||= Component.where(participatory_space:).published
+      @published_components ||= if scope_entity.is_a?(Decidim::Organization)
+                                  scope_entity.published_components
+                                elsif scope_entity.is_a?(Decidim::ParticipatoryProcessGroup)
+                                  Component.where(participatory_space: scope_entity.participatory_processes).published
+                                else
+                                  Component.where(participatory_space: scope_entity).published
+                                end
     end
   end
 end

data/app/presenters/decidim/taxonomy_presenter.rb

@@ -4,11 +4,15 @@ module Decidim
   #
   # Decorator for taxonomies.
   #
-  class TaxonomyPresenter < SimpleDelegator
+  class TaxonomyPresenter < ResourcePresenter
     include Decidim::TranslationsHelper
 
     def translated_name
       @translated_name ||= translated_attribute name
     end
+
+    def title(html_escape: false, all_locales: false)
+      super(name, html_escape, all_locales)
+    end
   end
 end

data/app/presenters/decidim/user_presenter.rb

@@ -73,12 +73,6 @@ module Decidim
       true
     end
 
-    def has_tooltip?
-      return if respond_to?(:deleted?) && deleted?
-
-      true
-    end
-
     private
 
     def decidim

data/app/queries/decidim/authorized_users.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This query counts registered users from a collection of organizations
+  # in an optional interval of time.
+  class AuthorizedUsers < Decidim::Query
+    def initialize(organization:, handlers: [], strict: false)
+      @organization = organization
+      @valid_types = organization.available_authorizations
+      @handlers = strict ? handlers : handlers&.select { |type| @valid_types.include?(type) } || []
+      @users = organization.users.not_deleted.not_blocked.confirmed
+    end
+
+    def query
+      return @users if @handlers.blank?
+
+      verified_users = Decidim::Authorization.select(:decidim_user_id)
+                                             .where(decidim_user_id: @users.select(:id))
+                                             .where.not(granted_at: nil)
+                                             .where(name: @handlers)
+                                             .group(:decidim_user_id)
+                                             .having("COUNT(distinct name) = ?", @handlers.count)
+      @users = @users.where(id: verified_users)
+    end
+  end
+end

data/app/queries/decidim/inactive_users_query.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  class InactiveUsersQuery < Decidim::Query
+    attr_reader :scope
+
+    def initialize(scope = Decidim::User.not_deleted)
+      @scope = scope
+    end
+
+    def for_first_warning(cutoff_date)
+      scope
+        .where("(current_sign_in_at <= :cutoff OR current_sign_in_at IS NULL) AND created_at <= :cutoff", cutoff: cutoff_date)
+        .where.not("extended_data ? 'inactivity_notification'")
+    end
+
+    def for_last_warning(cutoff_date)
+      scope
+        .where("(extended_data->'inactivity_notification'->>'notification_type') = 'first'")
+        .where("(extended_data->'inactivity_notification'->>'sent_at')::timestamp <= ?", cutoff_date)
+        .where("current_sign_in_at IS NULL OR current_sign_in_at <= (extended_data->'inactivity_notification'->>'sent_at')::timestamp")
+    end
+
+    def for_removal(cutoff_date)
+      scope
+        .where("(extended_data->'inactivity_notification'->>'notification_type') = 'second'")
+        .where("(extended_data->'inactivity_notification'->>'sent_at')::timestamp <= ?", cutoff_date)
+        .where("current_sign_in_at IS NULL OR current_sign_in_at <= (extended_data->'inactivity_notification'->>'sent_at')::timestamp")
+    end
+  end
+end

data/app/queries/decidim/public_activities.rb

@@ -32,7 +32,7 @@ module Decidim
     def query
       query = base_query
 
-      query = query.where(user:) if user
+      query = query.where(user_id: user.id, user_type: user.class.name) if user
       query = query.where(resource_type: resource_name) if resource_name.present?
 
       query = filter_follows(query)
@@ -71,7 +71,7 @@ module Decidim
       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))]
+      [Decidim::ActionLog.arel_table[:user_id].in(followed_users.map(&:decidim_followable_id))]
     end
 
     def followed_spaces_conditions(follows)

data/app/queries/decidim/stats_followers_count.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  class StatsFollowersCount < Decidim::Query
+    def initialize(participatory_space)
+      @participatory_space = participatory_space
+    end
+
+    def query
+      space_query + components_query
+    end
+
+    private
+
+    attr_reader :participatory_space
+
+    def components_query
+      Decidim.component_manifests.sum do |component|
+        component.stats
+                 .filter(tag: :followers)
+                 .with_context(space_components)
+                 .map { |_name, value| value }
+                 .compact_blank
+                 .sum
+      end
+    end
+
+    def space_query
+      Decidim.participatory_space_manifests.sum do |space|
+        space.stats
+             .filter(tag: :followers)
+             .with_context(participatory_space_items)
+             .map { |_name, value| value }
+             .compact_blank
+             .sum
+      end
+    end
+
+    def space_components
+      @space_components ||= Decidim::Component.where(participatory_space:).published
+    end
+  end
+end

data/app/queries/decidim/stats_participants_count.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Decidim
+  class StatsParticipantsCount < Decidim::Query
+    def initialize(participatory_space)
+      @participatory_space = participatory_space
+    end
+
+    def query
+      [
+        comments_query,
+        debates_query,
+        meetings_query,
+        likes_query,
+        project_votes_query,
+        proposals_query,
+        proposal_votes_query,
+        survey_response_query
+      ].flatten.uniq.count
+    end
+
+    private
+
+    attr_reader :participatory_space
+
+    def comments_query
+      return [] unless Decidim.module_installed?(:comments)
+
+      Decidim::Comments::Comment
+        .where(participatory_space:)
+        .pluck(:decidim_author_id)
+        .uniq
+    end
+
+    def debates_query
+      return [] unless Decidim.module_installed?(:debates)
+
+      Decidim::Debates::Debate
+        .where(component: space_components, decidim_author_type: Decidim::UserBaseEntity.name)
+        .not_hidden
+        .pluck(:decidim_author_id)
+        .uniq
+    end
+
+    def meetings_query
+      return [] unless Decidim.module_installed?(:meetings)
+
+      meetings = Decidim::Meetings::Meeting.where(component: space_components).not_hidden
+      registrations = Decidim::Meetings::Registration.where(decidim_meeting_id: meetings).pluck(:decidim_user_id)
+      organizers = meetings.where(decidim_author_type: Decidim::UserBaseEntity.name).pluck(:decidim_author_id)
+
+      [registrations, organizers].flatten.uniq
+    end
+
+    def likes_query
+      Decidim::Like
+        .where(resource: space_components)
+        .pluck(:decidim_author_id)
+        .uniq
+    end
+
+    def proposals_query
+      return [] unless Decidim.module_installed?(:proposals)
+
+      Decidim::Coauthorship
+        .where(coauthorable: proposals_components, decidim_author_type: Decidim::UserBaseEntity.name)
+        .pluck(:decidim_author_id)
+        .uniq
+    end
+
+    def proposal_votes_query
+      return [] unless Decidim.module_installed?(:proposals)
+
+      Decidim::Proposals::ProposalVote
+        .where(proposal: proposals_components)
+        .final
+        .pluck(:decidim_author_id)
+        .uniq
+    end
+
+    def project_votes_query
+      return [] unless Decidim.module_installed?(:budgets)
+
+      Decidim::Budgets::Order.joins(budget: [:component])
+                             .where(budget: { decidim_components: { id: space_components.pluck(:id) } })
+                             .pluck(:decidim_user_id)
+                             .uniq
+    end
+
+    def survey_response_query
+      Decidim::Forms::Response.newsletter_participant_ids(space_components)
+    end
+
+    def space_components
+      @space_components ||= Decidim::Component.where(participatory_space:).published
+    end
+
+    def proposals_components
+      @proposals_components ||= Decidim::Proposals::FilteredProposals.for(space_components).published.not_hidden
+    end
+  end
+end

data/app/serializers/decidim/exporters/open_data_user_serializer.rb

@@ -19,11 +19,7 @@ module Decidim
           profile_url: presented.profile_url,
           direct_messages_enabled: (resource.direct_message_types != "followed-only"),
           deleted: presented.deleted?,
-          badge: presented.badge,
-          groups: {
-            id: resource.accepted_user_groups.collect(&:id),
-            name: resource.accepted_user_groups.collect(&:name)
-          }
+          badge: presented.badge
         }
       end
 

data/app/serializers/decidim/exporters/participatory_space_serializer.rb

@@ -25,7 +25,6 @@ module Decidim
           updated_at: resource.updated_at,
           published_at: resource.published_at,
           follows_count: resource.follows_count,
-          hashtag: resource.hashtag,
           short_description: resource.short_description,
           description: resource.description,
           promoted: resource.promoted

data/app/services/decidim/action_logger.rb

@@ -45,7 +45,8 @@ module Decidim
     # Returns the newly created `Decidim::ActionLog` resource.
     def log!
       Decidim::ActionLog.create!(
-        user:,
+        user_id: user.id,
+        user_type: user.class.name,
         organization:,
         action:,
         resource:,

data/app/services/decidim/base_diff_renderer.rb

@@ -82,22 +82,6 @@ module Decidim
       diff
     end
 
-    def parse_user_group_changeset(attribute, values, type, diff)
-      return unless diff
-
-      old_user_group = Decidim::UserGroup.find_by(id: values[0])
-      new_user_group = Decidim::UserGroup.find_by(id: values[1])
-
-      diff.update(
-        attribute => {
-          type:,
-          label: I18n.t(attribute, scope: i18n_scope),
-          old_value: old_user_group ? translated_attribute(old_user_group.name) : "",
-          new_value: new_user_group ? translated_attribute(new_user_group.name) : ""
-        }
-      )
-    end
-
     def parse_scope_changeset(attribute, values, type, diff)
       return unless diff
 
@@ -118,7 +102,6 @@ module Decidim
       return parse_i18n_changeset(attribute, values, type, diff) if [:i18n, :i18n_html].include?(type)
 
       return parse_scope_changeset(attribute, values, type, diff) if type == :scope
-      return parse_user_group_changeset(attribute, values, type, diff) if type == :user_group
 
       diff.update(
         attribute => {

data/app/services/decidim/onboarding_manager.rb

@@ -171,6 +171,10 @@ module Decidim
       EngineRouter.main_proxy(component).root_path
     end
 
+    def authorization_path
+      @authorization_path ||= onboarding_data["authorization_path"].presence
+    end
+
     def expired?
       return unless ephemeral?
 

data/app/services/decidim/open_data_exporter.rb

@@ -60,7 +60,7 @@ module Decidim
       collection = export_manifest.collection.call(organization)
       exporter = Decidim::Exporters::CSV.new(collection, export_manifest.serializer)
 
-      get_help_definition(:core, exporter, export_manifest) unless collection.empty?
+      get_help_definition(:core, exporter, export_manifest, collection.count) unless collection.empty?
 
       exporter.export
     end
@@ -98,7 +98,8 @@ module Decidim
 
             collection.push(filename)
 
-            get_help_definition(:components, exporter, export_manifest) unless collection.empty?
+            collection_count = exported.read.split("\n").count - 1
+            get_help_definition(:components, exporter, export_manifest, collection_count) unless collection.empty?
           end
         end
       end
@@ -121,22 +122,26 @@ module Decidim
       end
       serializer = export_manifest.open_data_serializer.nil? ? export_manifest.serializer : export_manifest.open_data_serializer
       exporter = Decidim::Exporters::CSV.new(collection, serializer)
-      get_help_definition(:spaces, exporter, export_manifest) unless collection.empty?
+      get_help_definition(:spaces, exporter, export_manifest, collection.count) unless collection.empty?
 
       exporter.export
     end
 
-    def get_help_definition(manifest_type, exporter, export_manifest)
+    def get_help_definition(manifest_type, exporter, export_manifest, collection_count)
       help_definition[manifest_type] = {} if help_definition[manifest_type].nil?
       help_definition[manifest_type][export_manifest.name] = {} if help_definition[manifest_type][export_manifest.name].blank?
+      help_definition[manifest_type][export_manifest.name][:headers] = {} if help_definition[manifest_type][export_manifest.name][:headers].blank?
       exporter.headers_without_locales.each do |header|
-        help_definition[manifest_type][export_manifest.name][header] = I18n.t("decidim.open_data.help.#{export_manifest.name}.#{header}")
+        help_definition[manifest_type][export_manifest.name][:headers][header] = I18n.t("decidim.open_data.help.#{export_manifest.name}.#{header}")
       end
+      help_definition[manifest_type][export_manifest.name][:collection_count] = 0 if help_definition[manifest_type][export_manifest.name][:collection_count].nil?
+      help_definition[manifest_type][export_manifest.name][:collection_count] += collection_count
     end
 
     def readme
       "# #{I18n.t("decidim.open_data.help.core.title", organization: translated_attribute(organization.name))}\n\n
 #{I18n.t("decidim.open_data.help.core.description")}\n\n
+#{I18n.t("decidim.open_data.help.core.generated_on_date", date: I18n.l(Time.current, format: :decidim_short))}\n\n
 #{core_readme}
 #{space_readme}
 #{component_readme}
@@ -147,8 +152,9 @@ module Decidim
       return unless help_definition.fetch(:core, false)
 
       readme_file = "## #{I18n.t("decidim.open_data.help.core.main")}\n\n"
-      help_definition.fetch(:core, []).each do |element, headers|
-        readme_file << "### #{element}\n\n"
+      help_definition.fetch(:core, []).each do |element, metadata|
+        headers = metadata[:headers]
+        readme_file << "### #{element} (#{I18n.t("decidim.open_data.help.core.resources", count: metadata[:collection_count])})\n\n"
 
         headers.each do |header, help_value|
           readme_file << "* #{header}: #{help_value}\n"
@@ -164,8 +170,9 @@ module Decidim
 
       readme_file = "## #{I18n.t("decidim.open_data.help.core.spaces")}\n\n"
 
-      help_definition.fetch(:spaces, []).each do |space, headers|
-        readme_file << "### #{space}\n\n"
+      help_definition.fetch(:spaces, []).each do |space, metadata|
+        headers = metadata[:headers]
+        readme_file << "### #{space} (#{I18n.t("decidim.open_data.help.core.resources", count: metadata[:collection_count])})\n\n"
 
         headers.each do |header, help_value|
           readme_file << "* #{header}: #{help_value}\n"
@@ -181,8 +188,9 @@ module Decidim
 
       readme_file = "## #{I18n.t("decidim.open_data.help.core.components")}\n\n"
 
-      help_definition.fetch(:components, []).each do |component, headers|
-        readme_file << "### #{component}\n\n"
+      help_definition.fetch(:components, []).each do |component, metadata|
+        headers = metadata[:headers]
+        readme_file << "### #{component} (#{I18n.t("decidim.open_data.help.core.resources", count: metadata[:collection_count])})\n\n"
 
         headers.each do |header, help_value|
           readme_file << "* #{header}: #{help_value}\n"

data/app/services/decidim/send_push_notification.rb

@@ -19,7 +19,8 @@ module Decidim
     #
     # @return [Array<Net::HTTPCreated>, nil] the result of the dispatch or nil if user or subscription are empty
     def perform(notification, title = nil)
-      return unless Rails.application.secrets.dig(:vapid, :enabled)
+      return if Decidim.vapid_public_key.blank?
+
       raise ArgumentError, "Need to provide a title if the notification is a PushNotificationMessage" if notification.is_a?(Decidim::PushNotificationMessage) && title.nil?
 
       user = notification.user
@@ -66,8 +67,8 @@ module Decidim
         p256dh: subscription["p256dh"],
         auth: subscription["auth"],
         vapid: {
-          public_key: Rails.application.secrets.vapid[:public_key],
-          private_key: Rails.application.secrets.vapid[:private_key]
+          public_key: Decidim.vapid_public_key,
+          private_key: Decidim.vapid_private_key
         }
       }
     end

data/app/services/decidim/traceability.rb

@@ -127,7 +127,7 @@ module Decidim
     end
 
     def log(action, user, resource, extra_log_info = {})
-      return unless user.is_a?(Decidim::User)
+      return unless user.is_a?(Decidim::UserBaseEntity)
       # If the record is not valid, it may not yet have an ID causing an
       # exception when trying to save the log record.
       return if resource.nil?