feat: update the stat API to fill the incubateur requirements

Author: ttdm

apps/nuxt/src/server/api/statistics/index.get.ts

@@ -0,0 +1,25 @@
+import { defineEventHandler, getQuery } from 'h3'
+import { Monitor, StatisticsService } from '@tee/backend-ddd'
+import { StatsPeriodicity } from '@tee/common'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const query = getQuery(event)
+
+    const periodicity = ['day', 'week', 'month', 'year'].includes(query.periodicity as StatsPeriodicity)
+      ? (query.periodicity as StatsPeriodicity)
+      : undefined
+    const since = typeof query.since === 'string' ? query.since : undefined
+    const to = typeof query.to === 'string' ? query.to : undefined
+
+    const statsResult = await new StatisticsService().getNorthStarStats({ periodicity, since, to })
+
+    return statsResult
+  } catch (error: any) {
+    Monitor.error('Error in /api/stats', { error })
+    throw createError({
+      statusCode: 500,
+      statusMessage: `Server internal error: ${error.message}`
+    })
+  }
+})

apps/nuxt/src/server/api/stats/index.get.ts

@@ -1,11 +1,8 @@
-import { Result } from 'true-myth'
-import { StatsData } from '@tee/common'
-import { ProgramService } from '../../program'
+import { StatOutput, StatQueryParams } from '@tee/common'
 import StatisticsFeatures from '../domain/statisticsFeatures'
-import { brevoRepository } from '../../opportunity/infrastructure/api/brevo/brevoDeal'
 
 export class StatisticsService {
-  public async get(): Promise<Result<StatsData, Error>> {
-    return await new StatisticsFeatures(brevoRepository, new ProgramService()).computeStatistics()
+  public async getNorthStarStats(params: StatQueryParams): Promise<StatOutput> {
+    return await new StatisticsFeatures().fetchNorthStarStats(params)
   }
 }

apps/nuxt/src/server/api/statistics/update_posthog_data.get.ts renamed to apps/nuxt/src/server/api/stats/update_posthog_data.get.ts

@@ -1,114 +1,75 @@
-import { DemandsAtTime, OpportunityStats, ProgramStats, StatsData } from '@tee/common'
-import { ProgramService } from '../../program/application/programService'
-import { Result } from 'true-myth'
-import { OpportunityRepository } from '../../opportunity/domain/spi'
-import StatisticsCache from './statisticsCache'
-import Monitor from '../../common/domain/monitoring/monitor'
+import { Stat, StatOutput, StatQueryParams } from '@tee/common'
 
 export default class StatisticsFeatures {
-  private readonly _opportunityRepository: OpportunityRepository
-  private readonly _cache: StatisticsCache
-  private readonly _programService: ProgramService
+  async fetchNorthStarStats(params: StatQueryParams): Promise<StatOutput> {
+    const METABASE_URL = 'http://tee-metabase.osc-fr1.scalingo.io/public/question/6969b2ab-ec49-44a0-9db8-3e2f9afbcf29.json'
 
-  constructor(opportunityRepository: OpportunityRepository, programService: ProgramService) {
-    this._opportunityRepository = opportunityRepository
-    this._cache = StatisticsCache.getInstance()
-    this._programService = programService
-  }
-
-  async computeStatistics(): Promise<Result<StatsData, Error>> {
-    if (!this._cache.statistics || !this._cache.isValid()) {
-      const opportunityStats = await this.getOpportunityStatistics()
-      const programStats = this.getProgramStatistics()
+    const periodicity = params.periodicity || 'month'
 
-      const statistics: StatsData = {
-        ...programStats,
-        ...opportunityStats
-      }
-      this._cache.statistics = {
-        statistics: statistics,
-        timestamp: Date.now()
-      }
-    }
-    return Result.ok(this._cache.statistics.statistics)
-  }
-
-  async getOpportunityStatistics(): Promise<OpportunityStats> {
-    const opportunitiesDates = await this.getOpportunitiesCreated()
-    let datesWithinLast30Days = 0
-    let timeSeries: DemandsAtTime[] = []
-    if (opportunitiesDates) {
-      const thirtyDaysAgo = new Date(new Date().getTime() - 30 * 24 * 60 * 60 * 1000)
-      datesWithinLast30Days = opportunitiesDates.filter((date) => date >= thirtyDaysAgo).length
-      timeSeries = this.convertDatesToCumulativeTimeSeries(opportunitiesDates)
-    }
-    return {
-      countOpportunitiesTotal: opportunitiesDates ? opportunitiesDates.length : null,
-      countOpportunities30Days: opportunitiesDates ? datesWithinLast30Days : null,
-      demandsTimeSeries: timeSeries
-    }
-  }
+    const today = new Date()
+    const since = params.since ? new Date(params.since) : new Date(today.getFullYear(), 0, 1)
+    const to = params.to ? new Date(params.to) : new Date(today.getFullYear(), today.getMonth(), today.getDate() - 1)
 
-  getProgramStatistics(): ProgramStats {
-    const allPrograms = this._programService.getAll()
-    const activeProgramsResult = this._programService.getFilteredPrograms({})
-    if (activeProgramsResult.isErr) {
-      Monitor.error('Error generating program statistics', { error: activeProgramsResult.error })
-      throw activeProgramsResult.error
+    const response = await fetch(METABASE_URL)
+    if (!response.ok) {
+      throw new Error('Stats API: Failed to fetch Metabase data')
     }
-    return {
-      countProgramsTotal: allPrograms.length,
-      countProgramsNow: activeProgramsResult.value.length
-    }
-  }
 
-  convertDatesToCumulativeTimeSeries(opportunitiesDate: Date[]): DemandsAtTime[] {
-    const timeSeries: DemandsAtTime[] = []
+    const rawData: { week_start_date: string; total_2_3: number }[] = await response.json()
+    const filtered = rawData
+      .map((row) => ({
+        date: this.toLocalDateOnly(new Date(row.week_start_date)), // week_start_date is a metabase variable that is poorly named and that is simply the statistic date
+        value: row.total_2_3
+      }))
+      .filter((row) => row.date >= since && row.date <= to)
 
-    for (const date of opportunitiesDate) {
-      const year = date.getFullYear()
-      const month = date.getMonth() + 1
+    const grouped: Record<string, { date: Date; value: number }> = {}
 
-      const existingEntryIndex = timeSeries.findIndex((entry) => entry.year === year && entry.month === month)
-      if (existingEntryIndex !== -1) {
-        const entry = timeSeries[existingEntryIndex] as DemandsAtTime
-        entry.nDemands++
-      } else {
-        timeSeries.push({ year: year, month: month, nDemands: 1 })
-      }
-    }
+    filtered.forEach(({ date, value }) => {
+      const d = new Date(date)
+      if (d < since || d > to) return
 
-    return this.convertToCumulativeTimeSeries(timeSeries)
-  }
+      let keyStatDate = today
 
-  convertToCumulativeTimeSeries(timeSeries: DemandsAtTime[]): DemandsAtTime[] {
-    // Sort the array by year and month
-    timeSeries.sort((a, b) => {
-      if (a.year !== b.year) {
-        return a.year - b.year
+      switch (periodicity) {
+        case 'day':
+          keyStatDate = new Date(d.getFullYear(), d.getMonth(), d.getDate())
+          break
+        case 'week': {
+          const weekStart = new Date(d.getFullYear(), d.getMonth(), d.getDate() - ((d.getDay() + 6) % 7))
+          keyStatDate = weekStart
+          break
+        }
+        case 'month':
+          keyStatDate = new Date(d.getFullYear(), d.getMonth(), 1)
+          break
+        case 'year':
+          keyStatDate = new Date(d.getFullYear(), 0, 1)
+          break
       }
-      return a.month - b.month
-    })
-    // compute the cumulative sum
-    let cumulativeTotal = 0
-    return timeSeries.map((entry) => {
-      cumulativeTotal += entry.nDemands
 
-      return {
-        year: entry.year,
-        month: entry.month,
-        nDemands: cumulativeTotal
+      keyStatDate.setHours(keyStatDate.getHours() + 15) // To compensate for UTC hours and locales that can cause issues
+      const key = keyStatDate.toISOString().slice(0, 10)
+      if (!grouped[key]) {
+        grouped[key] = { date: keyStatDate, value: 0 }
       }
+      grouped[key].value += value
     })
-  }
 
-  async getOpportunitiesCreated(): Promise<Date[] | null> {
-    const opportunitiesDates = await this._opportunityRepository.readDates()
+    const stats: Stat[] = Object.values(grouped)
+      .sort((a, b) => a.date.getTime() - b.date.getTime())
+      .map((stat) => ({
+        ...stat,
+        date: stat.date.toISOString().split('T')[0]
+      }))
 
-    if (opportunitiesDates.isOk) {
-      return opportunitiesDates.value
+    return {
+      description: `Entreprises bénéficiaires`,
+      stats
     }
-    Monitor.error('Error generating Opportunities dates ', { error: opportunitiesDates.error })
-    return null
+  }
+
+  toLocalDateOnly(date: Date): Date {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate())
   }
 }

libs/backend-ddd/src/statistics/application/statisticsService.ts

@@ -1,18 +1,17 @@
-export type DemandsAtTime = {
-  year: number
-  month: number
-  nDemands: number
-}
+export type StatsPeriodicity = 'day' | 'week' | 'month' | 'year'
 
-export interface ProgramStats {
-  countProgramsTotal: number | null
-  countProgramsNow: number | null
+export interface StatQueryParams {
+  periodicity?: StatsPeriodicity
+  since?: string
+  to?: string
 }
 
-export interface OpportunityStats {
-  countOpportunitiesTotal: number | null
-  countOpportunities30Days: number | null
-  demandsTimeSeries: DemandsAtTime[]
+export interface Stat {
+  value: number
+  date: string
 }
 
-export type StatsData = ProgramStats & OpportunityStats
+export interface StatOutput {
+  description?: string
+  stats: Stat[]
+}