HugoGresse
diff --git a/‎functions/package-lock.json‎
Lines changed: 469 additions & 27 deletions b/‎functions/package-lock.json‎
Lines changed: 469 additions & 27 deletions
diff --git a/‎functions/src/api/routes/whatsapp/cloudTasks.ts‎
Lines changed: 94 additions & 0 deletions b/‎functions/src/api/routes/whatsapp/cloudTasks.ts‎
Lines changed: 94 additions & 0 deletions
diff --git a/‎functions/src/api/routes/whatsapp/greenApi.ts‎
Lines changed: 103 additions & 0 deletions b/‎functions/src/api/routes/whatsapp/greenApi.ts‎
Lines changed: 103 additions & 0 deletions
diff --git a/‎functions/src/api/routes/whatsapp/trackFlow.test.ts‎
Lines changed: 100 additions & 0 deletions b/‎functions/src/api/routes/whatsapp/trackFlow.test.ts‎
Lines changed: 100 additions & 0 deletions
diff --git a/‎functions/src/api/routes/whatsapp/trackFlow.ts‎
Lines changed: 57 additions & 0 deletions b/‎functions/src/api/routes/whatsapp/trackFlow.ts‎
Lines changed: 57 additions & 0 deletions
@@ -0,0 +1,94 @@
+import fb from 'firebase-admin'
+import { PanelTaskPayload } from './whatsappPanelTask'
+
+// The reminder tasks live in the Cloud Tasks queue Firebase creates for the onTaskDispatched function
+// (queue id === function name), in the same region it is deployed to. We talk to the Cloud Tasks REST
+// API directly (authenticated with the admin SDK's access token) to avoid pulling the heavy
+// @google-cloud/tasks client just for list/delete.
+const LOCATION = 'europe-west1'
+const QUEUE_ID = 'sendWhatsappPanel'
+const API_BASE = 'https://cloudtasks.googleapis.com/v2'
+
+export type ScheduledPanel = { name: string; scheduleTime: string | null; message: string }
+
+const projectId = (app: fb.app.App): string => {
+    const id =
+        app.options.projectId ||
+        process.env.GCLOUD_PROJECT ||
+        process.env.GCP_PROJECT ||
+        process.env.GOOGLE_CLOUD_PROJECT
+    if (!id) throw new Error('Project id not found in environment')
+    return id
+}
+
+// The admin SDK credential yields an OAuth token scoped for cloud-platform, which Cloud Tasks accepts.
+const accessToken = async (app: fb.app.App): Promise<string> => {
+    const credential = app.options.credential ?? fb.credential.applicationDefault()
+    const { access_token } = await credential.getAccessToken()
+    return access_token
+}
+
+const queuePath = (app: fb.app.App): string => `projects/${projectId(app)}/locations/${LOCATION}/queues/${QUEUE_ID}`
+
+// `path` is a resource path (e.g. "projects/.../tasks/123"), optionally with a query string.
+const apiFetch = async (app: fb.app.App, path: string, init: RequestInit = {}): Promise<any> => {
+    const res = await fetch(`${API_BASE}/${path}`, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${await accessToken(app)}`,
+            'Content-Type': 'application/json',
+            ...(init.headers || {}),
+        },
+    })
+    const text = await res.text()
+    if (!res.ok) {
+        throw new Error(`Cloud Tasks ${init.method || 'GET'} failed (${res.status}): ${text}`)
+    }
+    return text ? JSON.parse(text) : {}
+}
+
+// Firebase enqueues the payload as the JSON body `{ data: <payload> }` (base64 in the REST response);
+// tolerate a bare payload too.
+const decodePayload = (bodyBase64: unknown): PanelTaskPayload | null => {
+    if (typeof bodyBase64 !== 'string' || bodyBase64.length === 0) return null
+    try {
+        const parsed = JSON.parse(Buffer.from(bodyBase64, 'base64').toString('utf8'))
+        return (parsed?.data ?? parsed) as PanelTaskPayload
+    } catch {
+        return null
+    }
+}
+
+// Lists the still-pending reminder tasks for one event, soonest first.
+export const listScheduledPanels = async (app: fb.app.App, eventId: string): Promise<ScheduledPanel[]> => {
+    const out: ScheduledPanel[] = []
+    let pageToken: string | undefined
+    // Few tasks per queue, but page through to be correct.
+    do {
+        const query = `responseView=FULL&pageSize=100${pageToken ? `&pageToken=${encodeURIComponent(pageToken)}` : ''}`
+        const data = await apiFetch(app, `${queuePath(app)}/tasks?${query}`)
+        for (const task of data.tasks || []) {
+            const payload = decodePayload(task?.httpRequest?.body)
+            if (!payload || payload.eventId !== eventId) continue
+            out.push({ name: String(task.name), scheduleTime: task.scheduleTime || null, message: payload.message })
+        }
+        pageToken = data.nextPageToken || undefined
+    } while (pageToken)
+
+    return out.sort((a, b) => (a.scheduleTime || '').localeCompare(b.scheduleTime || ''))
+}
+
+// Deletes a single reminder task, but only if it belongs to this event's queue (guards against
+// deleting another queue's / another event's task via a forged name).
+export const deleteScheduledPanel = async (app: fb.app.App, eventId: string, name: string): Promise<boolean> => {
+    if (!name.startsWith(`${queuePath(app)}/tasks/`)) return false
+    try {
+        const task = await apiFetch(app, `${name}?responseView=FULL`)
+        const payload = decodePayload(task?.httpRequest?.body)
+        if (!payload || payload.eventId !== eventId) return false
+    } catch {
+        return false
+    }
+    await apiFetch(app, name, { method: 'DELETE' })
+    return true
+}
@@ -0,0 +1,103 @@
+// Thin GreenAPI (WhatsApp) client. Each instance also has its own host, but the shared gateway
+// routes by instance id, so no per-event URL is needed.
+const GREEN_API_BASE = 'https://api.green-api.com'
+
+export type GreenApiCreds = {
+    instanceId: string
+    token: string
+}
+
+export const credsFromEvent = (event: {
+    greenApiInstanceId?: string | null
+    greenApiToken?: string | null
+}): GreenApiCreds | null => {
+    if (!event.greenApiInstanceId || !event.greenApiToken) return null
+    return { instanceId: event.greenApiInstanceId, token: event.greenApiToken }
+}
+
+const call = async (creds: GreenApiCreds, method: string, payload: unknown): Promise<any> => {
+    const url = `${GREEN_API_BASE}/waInstance${creds.instanceId}/${method}/${creds.token}`
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+    })
+    const text = await res.text()
+    if (!res.ok) {
+        throw new Error(`GreenAPI ${method} failed (${res.status}): ${text}`)
+    }
+    return text ? JSON.parse(text) : {}
+}
+
+const callGet = async (creds: GreenApiCreds, method: string): Promise<any> => {
+    const url = `${GREEN_API_BASE}/waInstance${creds.instanceId}/${method}/${creds.token}`
+    const res = await fetch(url)
+    const text = await res.text()
+    if (!res.ok) {
+        throw new Error(`GreenAPI ${method} failed (${res.status}): ${text}`)
+    }
+    return text ? JSON.parse(text) : {}
+}
+
+// A WhatsApp chatId for a person is the phone number (digits only, country code included) + "@c.us".
+// A value that already looks like a chatId (contains "@") is passed through untouched.
+export const toChatId = (raw: string): string => {
+    if (raw.includes('@')) return raw
+    return `${raw.replace(/[^0-9]/g, '')}@c.us`
+}
+
+// A WhatsApp chat as exposed to the admin UI. `type` is 'group' for group chats (id ends @g.us)
+// and 'user' for single contacts (id ends @c.us).
+export type GreenApiContact = { id: string; name: string; type: 'group' | 'user' }
+
+// https://green-api.com/en/docs/api/chats/GetChats/ — lists every chat and group the instance has.
+// Used so the operator can pick the shared chat / test recipient instead of pasting a raw chatId.
+export const getChats = async (creds: GreenApiCreds): Promise<GreenApiContact[]> => {
+    const data = await callGet(creds, 'getChats')
+    if (!Array.isArray(data)) return []
+    return data
+        .map((c: any) => {
+            const id = String(c?.id ?? '')
+            const type: 'group' | 'user' = id.endsWith('@g.us') ? 'group' : 'user'
+            return { id, name: String(c?.name || c?.contactName || id), type }
+        })
+        .filter((c) => c.id.length > 0)
+}
+
+export const sendMessage = async (creds: GreenApiCreds, chatId: string, message: string): Promise<string> => {
+    const data = await call(creds, 'sendMessage', { chatId, message })
+    return data.idMessage
+}
+
+// https://green-api.com/en/docs/api/sending/SendPoll/ — WhatsApp polls allow up to 12 options.
+// Unlike interactive buttons, poll votes DO produce incoming (pollUpdateMessage) webhooks.
+export const sendPoll = async (
+    creds: GreenApiCreds,
+    chatId: string,
+    question: string,
+    options: string[],
+    multipleAnswers = true
+): Promise<string> => {
+    const data = await call(creds, 'sendPoll', {
+        chatId,
+        message: question,
+        options: options.slice(0, 12).map((name) => ({ optionName: name })),
+        multipleAnswers,
+    })
+    return data.idMessage
+}
+
+// Configure the instance to call our webhook for incoming messages (poll votes included). GreenAPI
+// sends webhookUrlToken back as the "Authorization: Bearer <token>" header. NB: changing settings
+// reboots the instance (it can be unavailable for a few minutes afterwards).
+export const setSettings = async (
+    creds: GreenApiCreds,
+    settings: { webhookUrl: string; webhookUrlToken: string }
+): Promise<void> => {
+    await call(creds, 'setSettings', {
+        webhookUrl: settings.webhookUrl,
+        webhookUrlToken: settings.webhookUrlToken,
+        incomingWebhook: 'yes',
+        pollMessageWebhook: 'yes',
+    })
+}
@@ -0,0 +1,100 @@
+import { describe, expect, test, vi } from 'vitest'
+import { applyPollVotes, sendGoMessage, startTrackSession, WhatsappSenders } from './trackFlow'
+
+const makeSenders = () => {
+    let n = 0
+    const sendPoll = vi.fn(async () => `poll-${++n}`)
+    const sendMessage = vi.fn(async () => `txt-${++n}`)
+    const senders: WhatsappSenders = { sendPoll, sendMessage }
+    return { senders, sendPoll, sendMessage }
+}
+
+const tracks = (n: number) => Array.from({ length: n }, (_, i) => ({ id: `t${i + 1}`, name: `Track ${i + 1}` }))
+
+describe('startTrackSession', () => {
+    test('sends one poll for up to 12 tracks', async () => {
+        const { senders, sendPoll } = makeSenders()
+        const session = await startTrackSession(tracks(5), '123@c.us', senders)
+
+        expect(sendPoll).toHaveBeenCalledTimes(1)
+        expect(sendPoll.mock.calls[0][2]).toEqual(['Track 1', 'Track 2', 'Track 3', 'Track 4', 'Track 5'])
+        expect(session.pollMessageIds).toEqual(['poll-1'])
+        expect(session.tracks.every((t) => !t.ready)).toBe(true)
+        expect(session.goSent).toBe(false)
+    })
+
+    test('splits into multiple polls beyond 12 options', async () => {
+        const { senders, sendPoll } = makeSenders()
+        const session = await startTrackSession(tracks(13), 'c@c.us', senders)
+        expect(sendPoll).toHaveBeenCalledTimes(2) // 13 -> [12, 1]
+        expect(session.pollMessageIds).toHaveLength(2)
+    })
+})
+
+describe('applyPollVotes', () => {
+    test('marks voted tracks ready (matched by option name)', async () => {
+        const { senders } = makeSenders()
+        const session = await startTrackSession(tracks(3), 'c@c.us', senders)
+
+        applyPollVotes(session, [
+            { name: 'Track 1', ready: true },
+            { name: 'Track 2', ready: false },
+            { name: 'Track 3', ready: false },
+        ])
+
+        expect(session.tracks.find((t) => t.id === 't1')!.ready).toBe(true)
+        expect(session.tracks.find((t) => t.id === 't2')!.ready).toBe(false)
+    })
+
+    test('cancelling a vote un-readies the track and never sends GO on its own', async () => {
+        const { senders, sendMessage } = makeSenders()
+        const session = await startTrackSession(tracks(2), 'c@c.us', senders)
+
+        applyPollVotes(session, [
+            { name: 'Track 1', ready: true },
+            { name: 'Track 2', ready: false },
+        ])
+        expect(session.tracks.find((t) => t.id === 't1')!.ready).toBe(true)
+
+        // The voter removes their vote: the same poll now reports Track 1 with no voters.
+        applyPollVotes(session, [
+            { name: 'Track 1', ready: false },
+            { name: 'Track 2', ready: false },
+        ])
+        expect(session.tracks.find((t) => t.id === 't1')!.ready).toBe(false)
+        expect(sendMessage).not.toHaveBeenCalled()
+        expect(session.goSent).toBe(false)
+    })
+
+    test('only updates tracks that are options in this poll (multi-poll split)', async () => {
+        const { senders } = makeSenders()
+        const session = await startTrackSession(tracks(2), 'c@c.us', senders)
+
+        // Each track voted ready via its own poll message.
+        applyPollVotes(session, [{ name: 'Track 1', ready: true }])
+        applyPollVotes(session, [{ name: 'Track 2', ready: true }])
+        expect(session.tracks.every((t) => t.ready)).toBe(true)
+
+        // An update for the first poll must not touch Track 2 (a different poll message).
+        applyPollVotes(session, [{ name: 'Track 1', ready: false }])
+        expect(session.tracks.find((t) => t.id === 't1')!.ready).toBe(false)
+        expect(session.tracks.find((t) => t.id === 't2')!.ready).toBe(true)
+    })
+})
+
+describe('sendGoMessage', () => {
+    test('sends the GO message and flags the session as sent', async () => {
+        const { senders, sendMessage } = makeSenders()
+        const session = await startTrackSession(tracks(2), 'c@c.us', senders)
+        applyPollVotes(session, [
+            { name: 'Track 1', ready: true },
+            { name: 'Track 2', ready: true },
+        ])
+
+        const updated = await sendGoMessage(session, senders)
+
+        expect(sendMessage).toHaveBeenCalledTimes(1)
+        expect(sendMessage).toHaveBeenCalledWith('c@c.us', expect.stringContaining('GO'))
+        expect(updated.goSent).toBe(true)
+    })
+})
@@ -0,0 +1,57 @@
+import { chunk, goMessage, OPTIONS_PER_POLL, POLL_QUESTION, TrackSession, TrackState } from './trackSession'
+
+// Side effects are injected so the flow is unit-testable without Firebase or the network.
+export type WhatsappSenders = {
+    sendPoll: (chatId: string, question: string, options: string[]) => Promise<string>
+    sendMessage: (chatId: string, message: string) => Promise<string>
+}
+
+// Start a track-management session: send one poll per group of up to 12 tracks.
+export const startTrackSession = async (
+    tracks: { id: string; name: string }[],
+    chatId: string,
+    senders: WhatsappSenders
+): Promise<TrackSession> => {
+    const trackStates: TrackState[] = tracks.map((t) => ({ id: t.id, name: t.name, ready: false }))
+    const pollMessageIds: string[] = []
+
+    for (const group of chunk(trackStates, OPTIONS_PER_POLL)) {
+        const idMessage = await senders.sendPoll(
+            chatId,
+            POLL_QUESTION,
+            group.map((t) => t.name)
+        )
+        pollMessageIds.push(idMessage)
+    }
+
+    return { chatId, tracks: trackStates, pollMessageIds, goSent: false, panelsSent: [] }
+}
+
+// Apply a poll vote snapshot for one poll message. GreenAPI sends the full current vote state, so each
+// track that is an option in this poll is set ready iff it currently has at least one voter — meaning
+// cancelling a vote un-readies the track. Tracks that aren't options in this poll (when >12 tracks were
+// split across several poll messages) are left untouched. GO is never sent automatically — see
+// sendGoMessage, triggered manually from the admin UI.
+export const applyPollVotes = (
+    session: TrackSession,
+    optionStates: { name: string; ready: boolean }[]
+): TrackSession => {
+    const readyByName = new Map(optionStates.map((o) => [o.name, o.ready]))
+
+    for (const track of session.tracks) {
+        const ready = readyByName.get(track.name)
+        if (ready !== undefined) {
+            track.ready = ready
+        }
+    }
+
+    return session
+}
+
+// Manually broadcast the GO message. Caller is responsible for checking allReady(session.tracks)
+// and !session.goSent first (the admin route does, guarding against early/duplicate sends).
+export const sendGoMessage = async (session: TrackSession, senders: WhatsappSenders): Promise<TrackSession> => {
+    await senders.sendMessage(session.chatId, goMessage(session.tracks))
+    session.goSent = true
+    return session
+}