Merge branch 'main' into bu-f-er

Author: HugoGresse

functions/package.json

@@ -14,7 +14,7 @@
     "engines": {
         "node": "20"
     },
-    "main": "lib/index.js",
+    "main": "lib/functions/src/index.js",
     "dependencies": {
         "@fastify/auth": "^4.4.0",
         "@fastify/cors": "^8.4.2",

functions/src/api/apiKeyPlugin.ts

@@ -2,31 +2,37 @@ import fastifyPlugin from 'fastify-plugin'
 import { EventDao } from './dao/eventDao'
 import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
 import { FastifyAuthFunction } from '@fastify/auth'
-
+import { Static, Type } from '@sinclair/typebox'
 const verifyRequest = async (fastify: FastifyInstance, request: FastifyRequest, reply: FastifyReply) => {
     // @ts-ignore
     const eventId = request.params?.eventId
     // @ts-ignore
     const apiKey = request.query?.apiKey
 
     if (!eventId || eventId.length === 0) {
-        reply.code(400).send({ error: "Bad Request! Missing eventId, hophop let's get to work !" })
+        reply.code(400).send({ error: "Bad Request! Missing eventId, hophop let's get to work !", success: false })
         return
     }
 
     if (!apiKey || apiKey.length === 0) {
-        reply.code(401).send({ error: 'Unauthorized! Du balai !' })
+        reply.code(401).send({ error: 'Unauthorized! Du balai !', success: false })
         return
     }
 
     const event = await EventDao.getEvent(fastify.firebase, eventId)
 
     if (event.apiKey !== apiKey) {
-        reply.code(401).send({ error: 'Unauthorized! Du balai !' })
+        reply.code(401).send({ error: 'Unauthorized! Du balai !', success: false })
         return
     }
 }
 
+export const Error400_401_VerifyRequest = Type.Object({
+    success: Type.Boolean(),
+    error: Type.String(),
+})
+export type Error400_401_VerifyRequestType = Static<typeof Error400_401_VerifyRequest>
+
 export const apiKeyPlugin = fastifyPlugin(
     (fastify: FastifyInstance, options: any, next: () => void) => {
         fastify.decorate<FastifyAuthFunction>('verifyApiKey', async (request: FastifyRequest, reply: FastifyReply) => {

functions/src/api/dao/faqDao.ts

@@ -1,7 +1,9 @@
 import firebase from 'firebase-admin'
 import { v4 as uuidv4 } from 'uuid'
 import { FaqCategoryType, FaqType } from '../routes/faq/faq'
+import { Faq, FaqCategory } from '../../../../src/types'
 import { NotFoundError } from '../other/Errors'
+import { dateToString } from '../other/dateConverter'
 
 const { FieldValue } = firebase.firestore
 
@@ -87,4 +89,39 @@ export class FaqDao {
                 } as FaqType)
         )
     }
+
+    public static async getFullFaqs(firebaseApp: firebase.app.App, eventId: string): Promise<FaqCategory[]> {
+        const db = firebaseApp.firestore()
+
+        const snapshots = await db.collection(`events/${eventId}/faq`).get()
+
+        const faqCategory: FaqCategory[] = snapshots.docs.map((snapshot) => ({
+            ...(snapshot.data() as FaqCategory),
+            id: snapshot.id,
+        }))
+
+        const faqItems = await Promise.all(
+            faqCategory.map((category) => FaqDao.getFaqItems(firebaseApp, eventId, category.id))
+        )
+
+        return faqCategory.map((category, index) => ({
+            ...category,
+            items: faqItems[index] || [],
+        }))
+    }
+
+    private static async getFaqItems(firebaseApp: firebase.app.App, eventId: string, faqId: string): Promise<Faq[]> {
+        const db = firebaseApp.firestore()
+        const snapshots = await db.collection(`events/${eventId}/faq/${faqId}/items`).get()
+        return snapshots.docs
+            .map((snapshot) => ({
+                ...(snapshot.data() as Faq),
+                id: snapshot.id,
+            }))
+            .map((faq) => ({
+                ...faq,
+                updatedAt: dateToString(faq.updatedAt),
+                createdAt: dateToString(faq.createdAt),
+            }))
+    }
 }

functions/src/api/dao/sessionDao.ts

@@ -1,9 +1,29 @@
 import firebase from 'firebase-admin'
 import { Session } from '../../types'
-
+import { Session as SessionConverted } from '../../../../src/types'
+import { unknownToDateTime } from '../other/dateConverter'
 const { FieldValue } = firebase.firestore
 
 export class SessionDao {
+    public static async getSessions(firebaseApp: firebase.app.App, eventId: string): Promise<SessionConverted[]> {
+        const db = firebaseApp.firestore()
+        const snapshot = await db.collection(`events/${eventId}/sessions`).get()
+        return (
+            snapshot.docs.map((doc) => ({
+                id: doc.id,
+                ...doc.data(),
+            })) as Session[]
+        ).map((session) => ({
+            ...session,
+            dates: session.dates
+                ? {
+                      start: unknownToDateTime(session.dates.start),
+                      end: unknownToDateTime(session.dates.end),
+                  }
+                : null,
+        }))
+    }
+
     public static async doesSessionExist(
         firebaseApp: firebase.app.App,
         eventId: string,

functions/src/api/dao/speakerDao.ts

@@ -4,6 +4,15 @@ import firebase from 'firebase-admin'
 const { FieldValue } = firebase.firestore
 
 export class SpeakerDao {
+    public static async getSpeakers(firebaseApp: firebase.app.App, eventId: string): Promise<Speaker[]> {
+        const db = firebaseApp.firestore()
+        const snapshot = await db.collection(`events/${eventId}/speakers`).get()
+        return snapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        })) as Speaker[]
+    }
+
     public static async doesSpeakerExist(
         firebaseApp: firebase.app.App,
         eventId: string,

functions/src/api/dao/sponsorDao.ts

@@ -2,6 +2,7 @@ import firebase from 'firebase-admin'
 import { SponsorType } from '../routes/sponsors/sponsors'
 import { SponsorResponse } from '../../types'
 import { v4 as uuidv4 } from 'uuid'
+import { SponsorCategory } from '../../../../src/types'
 
 const { FieldValue } = firebase.firestore
 
@@ -54,4 +55,13 @@ export class SponsorDao {
         const sponsors = snapshot.data()?.sponsors as SponsorResponse[]
         return sponsors.find((sponsor) => sponsor.id === sponsorId) as SponsorResponse
     }
+
+    public static async getSponsors(firebaseApp: firebase.app.App, eventId: string): Promise<SponsorCategory[]> {
+        const db = firebaseApp.firestore()
+        const snapshot = await db.collection(`events/${eventId}/sponsors`).get()
+        return snapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        })) as SponsorCategory[]
+    }
 }

functions/src/api/dao/teamDao.ts

@@ -0,0 +1,47 @@
+import firebase from 'firebase-admin'
+import { TeamMember } from '../../../../src/types'
+
+export class TeamDao {
+    public static async getTeams(
+        firebaseApp: firebase.app.App,
+        eventId: string
+    ): Promise<{
+        team: TeamMember[]
+        teams: { id: string; members: TeamMember[]; order: number }[]
+    }> {
+        const db = firebaseApp.firestore()
+        const snapshot = await db.collection(`events/${eventId}/team`).get()
+        const members = snapshot.docs.map((doc) => ({
+            id: doc.id,
+            ...doc.data(),
+        })) as TeamMember[]
+
+        // Group members by team
+        const teamGroups = members.reduce((acc, member) => {
+            const teamId = member.team || 'default'
+            if (!acc[teamId]) {
+                acc[teamId] = {
+                    id: teamId,
+                    members: [],
+                    order: member.teamOrder || 0, // Default high order for unspecified
+                }
+            }
+            acc[teamId].members.push(member)
+            return acc
+        }, {} as Record<string, { id: string; members: TeamMember[]; order: number }>)
+
+        const teamOrdered = Object.values(teamGroups)
+            .map((team) => ({
+                id: team.id,
+                order: team.order,
+                members: [...team.members].sort((a, b) => (a.order || 999) - (b.order || 999)),
+            }))
+            .sort((a, b) => a.order - b.order)
+
+        // Sort teams by teamOrder and flatten the structure
+        return {
+            team: members,
+            teams: teamOrdered,
+        }
+    }
+}

functions/src/api/index.ts

@@ -4,7 +4,7 @@ import { setupFastify } from './setupFastify'
 
 export const fastify = setupFastify()
 
-export const fastifyFunction = onRequest({ timeoutSeconds: 300 }, async (request, reply) => {
+export const fastifyFunction = onRequest({ timeoutSeconds: 300, region: 'europe-west1' }, async (request, reply) => {
     fastify.ready((error) => {
         if (error) throw error
         fastify.server.emit('request', request, reply)

functions/src/api/other/dateConverter.ts

@@ -0,0 +1,27 @@
+import { Timestamp } from 'firebase/firestore'
+import { DateTime } from 'luxon'
+
+export const dateToString = (date: Timestamp | Date | DateTime | string | null | undefined): string => {
+    if (!date) {
+        return ''
+    }
+    return unknownToDateTime(date).toISO() || ''
+}
+
+export const unknownToDateTime = (date: Timestamp | Date | DateTime | string | null | undefined): DateTime => {
+    if (!date) {
+        return DateTime.now()
+    }
+    if (typeof date === 'string') {
+        return DateTime.fromISO(date)
+    }
+    if (date instanceof Date) {
+        return DateTime.fromJSDate(date)
+    }
+    if ('toISO' in date) {
+        // Already a DateTime object
+        return date as DateTime
+    }
+    // Firestore Timestamp
+    return DateTime.fromJSDate(date.toDate())
+}

functions/src/api/other/fastifyErrorHandler.ts

@@ -15,18 +15,25 @@ export const fastifyErrorHandler = (
     console.error(request.originalUrl, error)
     if (error instanceof HttpError) {
         reply.header('content-type', 'application/json')
-        reply.status(error.statusCode).send(JSON.stringify({ error: error.message }))
+        reply.status(error.statusCode).send(JSON.stringify({ error: error.message, success: false }))
     } else {
         reply.header('content-type', 'application/json')
         if (error.code && error.statusCode) {
             reply.status(error.statusCode).send(
                 JSON.stringify({
                     error: error.code,
                     reason: error.toString(),
+                    success: false,
                 })
             )
         } else {
-            reply.status(400).send(JSON.stringify({ error: error, reason: error.message || JSON.stringify(error) }))
+            reply.status(400).send(
+                JSON.stringify({
+                    error: error,
+                    reason: error.message || JSON.stringify(error),
+                    success: false,
+                })
+            )
         }
     }
 }