Feature branch report builder (last things)

back/engines/commercial/analytics/spec/acceptance/analytics_participations_spec.rb

@@ -4,7 +4,7 @@
 require 'rspec_api_documentation/dsl'
 
 resource 'Analytics - FactParticipations' do
-  explanation 'Queries to summarise participations/active users.'
+  explanation 'Queries to summarise participations.'
 
   before do
     header 'Content-Type', 'application/json'

back/engines/commercial/report_builder/app/services/report_builder/queries/analytics/active_users.rb → back/engines/commercial/report_builder/app/services/report_builder/queries/analytics/participants.rb

@@ -1,6 +1,6 @@
 module ReportBuilder
-  class Queries::Analytics::ActiveUsers < Queries::Analytics::Base
-    def active_users_query(start_at, end_at, project_id, apply_visitor_filter: false)
+  class Queries::Analytics::Participants < Queries::Analytics::Base
+    def participants_query(start_at, end_at, project_id, apply_visitor_filter: false)
       {
         fact: 'participation',
         filters: {
@@ -51,43 +51,43 @@ def query(
         }
       }
 
-      active_users_whole_period_query = active_users_query(start_at, end_at, project_id)
+      participants_whole_period_query = participants_query(start_at, end_at, project_id)
       visitors_whole_period_query = visitors_query(start_at, end_at, project_id)
 
-      # We request the active user count again,
+      # We request the participants count again,
       # but this time we filter by has_visits = true
       # This is so that we can calculate a more accurate
       # conversion rate on the FE, where we only compare
       # visitors (i.e. people that accepted cookies)
-      # to active users that also accepted cookies
-      active_visitor_users_whole_period_query = active_users_query(
+      # to participants that also accepted cookies
+      participants_who_accepted_cookies_whole_period_query = participants_query(
         start_at, end_at, project_id, apply_visitor_filter: true
       )
 
       queries = [
         time_series_query,
-        active_users_whole_period_query,
+        participants_whole_period_query,
         visitors_whole_period_query,
-        active_visitor_users_whole_period_query
+        participants_who_accepted_cookies_whole_period_query
       ]
 
       if compare_start_at.present? && compare_end_at.present?
-        active_users_compared_period_query = active_users_query(compare_start_at, compare_end_at, project_id)
+        participants_compared_period_query = participants_query(compare_start_at, compare_end_at, project_id)
         visitors_compared_period_query = visitors_query(compare_start_at, compare_end_at, project_id)
 
-        # We request the active user count again,
+        # We request the participants count again,
         # but this time we filter by has_visits = true
         # This is so that we can calculate a more accurate
         # conversion rate on the FE, where we only compare
         # visitors (i.e. people that accepted cookies)
-        # to active users that also accepted cookies
-        active_visitor_users_compared_period_query = active_users_query(
+        # to participants that also accepted cookies
+        participants_who_accepted_cookies_compared_period_query = participants_query(
           compare_start_at, compare_end_at, project_id, apply_visitor_filter: true
         )
 
-        queries << active_users_compared_period_query
+        queries << participants_compared_period_query
         queries << visitors_compared_period_query
-        queries << active_visitor_users_compared_period_query
+        queries << participants_who_accepted_cookies_compared_period_query
       end
 
       queries

back/engines/commercial/report_builder/app/services/report_builder/queries/analytics/participation.rb

@@ -0,0 +1,115 @@
+module ReportBuilder
+  class Queries::Analytics::Participation < Queries::Analytics::Base
+    protected
+
+    def query(
+      start_at: nil,
+      end_at: nil,
+      project_id: nil,
+      resolution: nil,
+      compare_start_at: nil,
+      compare_end_at: nil,
+      **_other_props
+    )
+      # First, the time series
+      inputs_time_series = {
+        fact: 'post',
+        filters: {
+          **date_filter('dimension_date_created', start_at, end_at),
+          **project_filter('dimension_project_id', project_id),
+          'dimension_type.name': %w[idea initiative],
+          publication_status: 'published'
+        },
+        groups: "dimension_date_created.#{interval(resolution)}",
+        aggregations: {
+          all: 'count',
+          'dimension_date_created.date': 'first'
+        }
+      }
+
+      comments_time_series = {
+        fact: 'participation',
+        filters: {
+          **date_filter('dimension_date_created', start_at, end_at),
+          **project_filter('dimension_project_id', project_id),
+          'dimension_type.name': 'comment',
+          'dimension_type.parent': %w[idea initiative]
+        },
+        groups: "dimension_date_created.#{interval(resolution)}",
+        aggregations: {
+          all: 'count',
+          'dimension_date_created.date': 'first'
+        }
+      }
+
+      baskets_time_series = {
+        fact: 'participation',
+        filters: {
+          **date_filter('dimension_date_created', start_at, end_at),
+          **project_filter('dimension_project_id', project_id),
+          'dimension_type.name': 'basket'
+        },
+        groups: "dimension_date_created.#{interval(resolution)}",
+        aggregations: {
+          all: 'count',
+          'dimension_date_created.date': 'first'
+        }
+      }
+
+      queries = [
+        inputs_time_series,
+        comments_time_series,
+        baskets_time_series
+      ]
+
+      # We will derive the totals of the whole period in the FE, based on the time series
+
+      # Second, if necessary, the comparisons
+      if compare_start_at.present? && compare_end_at.present?
+        inputs_compared_period = {
+          fact: 'post',
+          filters: {
+            **date_filter('dimension_date_created', compare_start_at, compare_end_at),
+            **project_filter('dimension_project_id', project_id),
+            'dimension_type.name': %w[idea initiative],
+            publication_status: 'published'
+          },
+          aggregations: {
+            all: 'count'
+          }
+        }
+
+        comments_compared_period = {
+          fact: 'participation',
+          filters: {
+            **date_filter('dimension_date_created', compare_start_at, compare_end_at),
+            **project_filter('dimension_project_id', project_id),
+            'dimension_type.name': 'comment',
+            'dimension_type.parent': %w[idea initiative]
+          },
+          aggregations: {
+            all: 'count'
+          }
+        }
+
+        baskets_compared_period = {
+          fact: 'participation',
+          filters: {
+            **date_filter('dimension_date_created', start_at, end_at),
+            **project_filter('dimension_project_id', project_id),
+            'dimension_type.name': 'basket'
+          },
+          aggregations: {
+            all: 'count'
+          }
+        }
+
+        queries << inputs_compared_period
+        queries << comments_compared_period
+        queries << baskets_compared_period
+      end
+
+      queries
+    end
+  end
+end

back/engines/commercial/report_builder/app/services/report_builder/queries/analytics/registrations.rb

@@ -50,32 +50,32 @@ def query(
       registrations_whole_period_query = registrations_query(start_at, end_at)
       visitors_whole_period_query = visitors_query(start_at, end_at)
 
-      # Similar to active_users.rb, we request the registrations another
+      # Similar to participants.rb, we request the registrations another
       # time, but this time we filter by has_visits = true
-      registrations_visitors_whole_period_query = registrations_query(
+      registrations_who_accepted_cookies_whole_period_query = registrations_query(
         start_at, end_at, apply_visitor_filter: true
       )
 
       queries = [
         time_series_query,
         registrations_whole_period_query,
         visitors_whole_period_query,
-        registrations_visitors_whole_period_query
+        registrations_who_accepted_cookies_whole_period_query
       ]
 
       if compare_start_at.present? && compare_end_at.present?
         registrations_compared_period_query = registrations_query(compare_start_at, compare_end_at)
         visitors_compared_period_query = visitors_query(compare_start_at, compare_end_at)
 
-        # Similar to active_users.rb, we request the registrations another
+        # Similar to participants.rb, we request the registrations another
         # time, but this time we filter by has_visits = true
-        registrations_visitors_compared_period_query = registrations_query(
+        registrations_who_accepted_cookies_compared_period_query = registrations_query(
           compare_start_at, compare_end_at, apply_visitor_filter: true
         )
 
         queries << registrations_compared_period_query
         queries << visitors_compared_period_query
-        queries << registrations_visitors_compared_period_query
+        queries << registrations_who_accepted_cookies_compared_period_query
       end
 
       queries

back/engines/commercial/report_builder/app/services/report_builder/queries/methods_used.rb

@@ -0,0 +1,37 @@
+module ReportBuilder
+  class Queries::MethodsUsed < ReportBuilder::Queries::Base
+    def run_query(
+      start_at: nil,
+      end_at: nil,
+      compare_start_at: nil,
+      compare_end_at: nil,
+      **_other_props
+    )
+      start_date, end_date = TimeBoundariesParser.new(start_at, end_at).parse
+
+      json_response = {
+        count_per_method: get_methods_used_in_overlapping_phases(
+          start_date,
+          end_date
+        )
+      }
+
+      if compare_start_at.present? && compare_end_at.present?
+        json_response[:count_per_method_compared_period] = get_methods_used_in_overlapping_phases(
+          compare_start_at, compare_end_at
+        )
+      end
+
+      json_response
+    end
+
+    def get_methods_used_in_overlapping_phases(start_date, end_date)
+      non_overlapping_phase_ids = Phase.where('end_at <= ? OR start_at >= ?', start_date, end_date).select(:id)
+
+      Phase
+        .where.not(id: non_overlapping_phase_ids)
+        .group(:participation_method)
+        .count
+    end
+  end
+end

back/engines/commercial/report_builder/app/services/report_builder/queries/projects.rb

@@ -0,0 +1,55 @@
+module ReportBuilder
+  class Queries::Projects < ReportBuilder::Queries::Base
+    def run_query(start_at: nil, end_at: nil, **_other_props)
+      start_date, end_date = TimeBoundariesParser.new(start_at, end_at).parse
+
+      overlapping_project_ids = Phase
+        .select(:project_id)
+        .where("(start_at, coalesce(end_at, 'infinity'::DATE)) OVERLAPS (?, ?)", start_date, end_date)
+
+      overlapping_projects = Project
+        .joins(:admin_publication)
+        .where(id: overlapping_project_ids)
+        .where(admin_publication: { publication_status: 'published' })
+
+      periods = Phase
+        .select(
+          :project_id,
+          'min(start_at) as start_at',
+          'max(start_at) as last_phase_start_at',
+          'CASE WHEN count(end_at) = count(*) THEN max(end_at) ELSE NULL END as end_at'
+        )
+        .where(project_id: overlapping_project_ids)
+        .group(:project_id)
+        .to_h do |period|
+        [
+          period.project_id,
+          period.slice(:start_at, :last_phase_start_at, :end_at)
+        ]
+      end
+
+      project_images_hash = ProjectImage
+        .where(project_id: overlapping_projects)
+        .to_h { |project_image| [project_image.id, serialize(project_image, ::WebApi::V1::ImageSerializer)] }
+
+      participants = Analytics::FactParticipation
+        .where(dimension_project_id: overlapping_project_ids)
+        .group(:dimension_project_id)
+        .select('COUNT(DISTINCT participant_id) as participants_count, dimension_project_id')
+        .to_h { |participant| [participant.dimension_project_id, participant.participants_count] }
+
+      {
+        projects: serialize(overlapping_projects, ::WebApi::V1::ProjectSerializer),
+        project_images: project_images_hash,
+        periods: periods,
+        participants: participants
+      }
+    end
+
+    private
+
+    def serialize(entity, serializer)
+      serializer.new(entity, params: { current_user: @current_user }).serializable_hash[:data]
+    end
+  end
+end

back/engines/commercial/report_builder/app/services/report_builder/query_repository.rb

@@ -8,14 +8,17 @@ class QueryRepository
       'ReactionsByTimeWidget' => Queries::Analytics::ReactionsByTime,
       'CommentsByTimeWidget' => Queries::Analytics::CommentsByTime,
       'PostsByTimeWidget' => Queries::Analytics::PostsByTime,
-      'ActiveUsersWidget' => Queries::Analytics::ActiveUsers,
+      'ParticipantsWidget' => Queries::Analytics::Participants,
       'VisitorsWidget' => Queries::Analytics::Visitors,
       'VisitorsTrafficSourcesWidget' => Queries::Analytics::TrafficSources,
       'SurveyQuestionResultWidget' => Queries::SurveyQuestionResult,
       'MostReactedIdeasWidget' => Queries::MostReactedIdeas,
       'SingleIdeaWidget' => Queries::SingleIdea,
       'DemographicsWidget' => Queries::Demographics,
-      'RegistrationsWidget' => Queries::Analytics::Registrations
+      'RegistrationsWidget' => Queries::Analytics::Registrations,
+      'MethodsUsedWidget' => Queries::MethodsUsed,
+      'ParticipationWidget' => Queries::Analytics::Participation,
+      'ProjectsWidget' => Queries::Projects
     }.freeze
 
     def initialize(current_user)

back/engines/commercial/report_builder/spec/services/report_builder/queries/analytics/comments_by_time_spec.rb

@@ -9,13 +9,11 @@
     let(:date) { Date.new(2022, 9, 1) }
     let(:idea) do
       create(:dimension_date, date: date)
-      create(:dimension_type, name: 'idea', parent: 'post')
-
       create(:idea, created_at: date)
     end
 
     before do
-      create(:dimension_type, name: 'comment', parent: 'idea')
+      Analytics::PopulateDimensionsService.populate_types
       create(:comment, created_at: date, post: idea)
     end
 

back/engines/commercial/report_builder/spec/services/report_builder/queries/analytics/active_users_spec.rb → back/engines/commercial/report_builder/spec/services/report_builder/queries/analytics/participants_spec.rb

@@ -2,7 +2,7 @@
 
 require 'rails_helper'
 
-RSpec.describe ReportBuilder::Queries::Analytics::ActiveUsers do
+RSpec.describe ReportBuilder::Queries::Analytics::Participants do
   subject(:query) { described_class.new(build(:user)) }
 
   describe '#run_query' do
@@ -13,11 +13,10 @@
 
       @dimension_date_sept = create(:dimension_date, date: @date_september)
       @dimension_date_oct = create(:dimension_date, date: @date_october)
-      create(:dimension_type, name: 'idea', parent: 'post')
-      create(:dimension_type, name: 'comment', parent: 'idea')
+      Analytics::PopulateDimensionsService.populate_types
     end
 
-    it 'returns active users' do
+    it 'returns participants' do
       project = create(:single_phase_ideation_project)
       create(:idea, created_at: @date_september, project: project)
 
@@ -99,7 +98,7 @@
       )
     end
 
-    it 'returns active users in compared period' do
+    it 'returns participants in compared period' do
       project = create(:project)
       pp1, pp2, pp3, pp4 = create_list(:user, 4)