Merge branch 'user-tokens-wallet' into develop

Author: fcamblor

cloud/functions/package-lock.json

@@ -4,7 +4,7 @@
     "lint": "eslint --ext .js,.ts .",
     "build": "tsc",
     "build:watch": "tsc --watch",
-    "serve": "npm run build && firebase emulators:start  --import data --export-on-exit --inspect-functions",
+    "serve": "npm run build && MIGRATION_TOKEN=42 firebase emulators:start  --import data --export-on-exit --inspect-functions",
     "shell": "npm run build && firebase functions:shell",
     "start": "npm run shell",
     "deploy": "firebase deploy --only functions",
@@ -24,9 +24,11 @@
     "firebase-functions": "^4.2.0",
     "lodash": "^4.17.21",
     "ts-pattern": "4.3.0",
+    "uuid": "9.0.0",
     "zod": "3.21.4"
   },
   "devDependencies": {
+    "@types/uuid": "9.0.2",
     "@typescript-eslint/eslint-plugin": "^5.12.0",
     "@typescript-eslint/parser": "^5.12.0",
     "eslint": "^8.9.0",

cloud/functions/package.json

@@ -9,6 +9,9 @@ import {WEB2DAY_CRAWLER} from "./web2day/crawler";
 import {Temporal} from "@js-temporal/polyfill";
 import {CAMPING_DES_SPEAKERS_CRAWLER} from "./camping-des-speakers/crawler";
 import {DEVOXX_SCALA_CRAWLER} from "./devoxx-scala/crawler";
+import {match} from "ts-pattern";
+import {v4 as uuidv4} from "uuid"
+import {ConferenceOrganizerSpace} from "../../../../shared/conference-organizer-space.firestore";
 const axios = require('axios');
 
 export type CrawlerKind<ZOD_TYPE extends z.ZodType> = {
@@ -106,6 +109,28 @@ const saveEvent = async function(event: FullEvent) {
     await db.collection("events").doc(event.id).set(event.info)
 
     const firestoreEvent = await db.collection("events").doc(event.id);
+    const organizerSpaceEntries = await firestoreEvent
+        .collection('organizer-space')
+        .listDocuments();
+
+    const { organizerSpaceContent, organizerSecretToken }  = await match(organizerSpaceEntries.length)
+        .with(0, async () => {
+            const organizerSecretToken = uuidv4();
+            const organizerSpaceContent: ConferenceOrganizerSpace = {
+                organizerSecretToken,
+                talkFeedbackViewerTokens: []
+            }
+
+            await firestoreEvent.collection('organizer-space').doc(organizerSecretToken).set(organizerSpaceContent)
+            return {organizerSecretToken, organizerSpaceContent};
+        }).with(1, async () => {
+            const organizerSecretToken = await organizerSpaceEntries[0].id;
+            const organizerSpaceContent = (await firestoreEvent.collection('organizer-space').doc(organizerSecretToken).get()).data() as ConferenceOrganizerSpace;
+            return {organizerSecretToken, organizerSpaceContent};
+        }).otherwise(async () => {
+            throw new Error(`More than 1 organizer-space entries detected (${organizerSpaceEntries.length}) for event ${event.id}`);
+        })
+
     await Promise.all(event.daySchedules.map(async daySchedule => {
         try {
             await firestoreEvent
@@ -121,6 +146,26 @@ const saveEvent = async function(event: FullEvent) {
             await firestoreEvent
                 .collection("talks").doc(talk.id)
                 .set(talk)
+
+            const existingTalkFeedbackViewerToken = organizerSpaceContent.talkFeedbackViewerTokens
+                .find(tfvt => tfvt.eventId === event.id && tfvt.talkId === talk.id)
+
+            // If token already exists for the talk, let's not add it
+            if(!existingTalkFeedbackViewerToken) {
+                const talkFeedbackViewerSecretToken = uuidv4();
+
+                await firestoreEvent
+                    .collection("talks").doc(talk.id)
+                    .collection("feedbacks-access").doc(talkFeedbackViewerSecretToken)
+                    // Creating a fake entry so that feedbacks-access/{secretToken} node is created
+                    .collection('_empty').add({ _: 42 })
+
+                organizerSpaceContent.talkFeedbackViewerTokens.push({
+                    eventId: event.id,
+                    talkId: talk.id,
+                    secretToken: talkFeedbackViewerSecretToken
+                });
+            }
         }catch(e) {
             error(`Error while saving talk ${talk.id}: ${e?.toString()}`)
         }
@@ -133,6 +178,12 @@ const saveEvent = async function(event: FullEvent) {
     }catch(e) {
         error(`Error while storing conference descriptor ${event.conferenceDescriptor.id}: ${e?.toString()}`)
     }
+
+    try {
+        await firestoreEvent.collection('organizer-space').doc(organizerSecretToken).set(organizerSpaceContent)
+    }catch(e) {
+        error(`Error while storing event's organizer-space content`)
+    }
 }
 
 export default crawlAll;

cloud/functions/src/crawlers/crawl.ts

@@ -0,0 +1,10 @@
+import {db} from "../../firebase";
+
+export async function getSecretTokenDoc<T>(path: string) {
+    const list = await db.collection(path).listDocuments()
+    if(list.length !== 1) {
+        throw new Error(`Unexpected size=${list.length} for path [${path}] (expected=1)`)
+    }
+
+    return (await db.doc(`${path}/${list[0].id}`).get()).data() as T;
+}

cloud/functions/src/functions/firestore/firestore-utils.ts

@@ -0,0 +1,16 @@
+import {createUserInfos} from "../onUserCreated";
+import {db} from "../../../firebase";
+
+export async function createExistingUsersInfos(): Promise<"OK"|"Error"> {
+    const existingUsers = await db.collection("users").listDocuments()
+
+    await Promise.all(existingUsers.map(async existingUser => {
+        const userInfos = await db.collection('users').doc(existingUser.id).get()
+
+        if(!userInfos.exists) {
+            await createUserInfos(existingUser.id);
+        }
+    }))
+
+    return "OK";
+}

cloud/functions/src/functions/firestore/migrations/createExistingUsersInfos.ts

@@ -0,0 +1,19 @@
+import {db} from "../../../firebase";
+import {createEmptyUserTokenWallet} from "../onUserCreated";
+
+export async function createExistingUsersTokensWallet(): Promise<"OK"|"Error"> {
+    const existingUsers = await db.collection("users").listDocuments()
+
+    await Promise.all(existingUsers.map(async existingUser => {
+        const tokensWallet = await db
+            .collection("users").doc(existingUser.id)
+            .collection("tokens-wallet").doc("self")
+            .get()
+
+        if(!tokensWallet.exists) {
+            await createEmptyUserTokenWallet(existingUser.id);
+        }
+    }))
+
+    return "OK";
+}

cloud/functions/src/functions/firestore/migrations/createExistingUsersTokensWallet.ts

@@ -0,0 +1,67 @@
+import * as functions from "firebase-functions";
+import {UserDailyFeedbacks, UserFeedback} from "../../../../../shared/feedbacks.firestore";
+import {db} from "../../firebase";
+import {getSecretTokenDoc} from "./firestore-utils";
+import {ConferenceOrganizerSpace} from "../../../../../shared/conference-organizer-space.firestore";
+import {TalkAttendeeFeedback} from "../../../../../shared/talk-feedbacks.firestore";
+import {UserTokensWallet} from "../../../../../shared/user-tokens-wallet.firestore";
+
+
+export const onTalkFeedbackUpdated = functions.firestore
+    .document(`users/{userId}/events/{eventId}/days/{dayId}/feedbacks/self`)
+    .onUpdate(async (change, context) => {
+        const eventId = context.params.eventId;
+        const userId = context.params.userId;
+
+        const feedbacksBefore = change.before.data() as UserDailyFeedbacks;
+        const feedbacksAfter = change.after.data() as UserDailyFeedbacks;
+
+        const lastModificationTimestampBefore = Math.max(...feedbacksBefore.feedbacks.map(f => Date.parse(f.lastUpdatedOn)));
+        const feedbacksModifiedAfter = feedbacksAfter.feedbacks.filter(f => Date.parse(f.lastUpdatedOn) > lastModificationTimestampBefore);
+
+        await updateTalkFeedbacksFromUserFeedbacks(userId, eventId, feedbacksModifiedAfter);
+    })
+
+export const onTalkFeedbackCreated = functions.firestore
+    .document(`users/{userId}/events/{eventId}/days/{dayId}/feedbacks/self`)
+    .onCreate(async (snapshot, context) => {
+        const eventId = context.params.eventId;
+        const userId = context.params.userId;
+
+        const userDailyFeedbacks = snapshot.data() as UserDailyFeedbacks
+
+        await updateTalkFeedbacksFromUserFeedbacks(userId, eventId, userDailyFeedbacks.feedbacks);
+    })
+
+async function updateTalkFeedbacksFromUserFeedbacks(userId: string, eventId: string, userFeedbacks: UserFeedback[]) {
+    const organizerSpace: ConferenceOrganizerSpace = await getSecretTokenDoc(`events/${eventId}/organizer-space`);
+    await Promise.all(userFeedbacks.map(async feedback => {
+        if(feedback.status === 'provided') {
+            const talkFeedbackViewerToken = organizerSpace.talkFeedbackViewerTokens
+                .find(tfvt => tfvt.eventId === eventId && tfvt.talkId === feedback.talkId);
+
+            if(!talkFeedbackViewerToken) {
+                throw new Error(`No organizer talk token found for eventId=${eventId}, talkId=${feedback.talkId}`);
+            }
+
+            const userTokensWallet = (await db.doc(`users/${userId}/tokens-wallet/self`).get()).data() as UserTokensWallet|undefined;
+            if(!userTokensWallet) {
+                throw new Error(`Unexpected unexistant user token wallet for userId=${userId}`);
+            }
+
+            const userPublicTokensHavingProvidedFeedback = ((await db.collection(`events/${eventId}/talks/${feedback.talkId}/feedbacks-access/${talkFeedbackViewerToken.secretToken}/feedbacks`).listDocuments())
+                || []).map(d => d.id)
+
+            const attendeeFeedback: TalkAttendeeFeedback = {
+                talkId: feedback.talkId,
+                comment: feedback.comment,
+                createdOn: feedback.createdOn,
+                lastUpdatedOn: feedback.lastUpdatedOn,
+                ratings: feedback.ratings,
+                attendeePublicToken: userTokensWallet.publicUserToken
+            }
+
+            await db.doc(`events/${eventId}/talks/${feedback.talkId}/feedbacks-access/${talkFeedbackViewerToken.secretToken}/feedbacks/${userTokensWallet.publicUserToken}`).set(attendeeFeedback)
+        }
+    }))
+}

cloud/functions/src/functions/firestore/onTalkFeedbackProvided.ts

@@ -0,0 +1,48 @@
+import * as functions from "firebase-functions";
+import {db, info} from "../../firebase"
+import {UserTokensWallet} from "../../../../../shared/user-tokens-wallet.firestore";
+import {v4 as uuidv4} from "uuid";
+import {User} from "../../../../../shared/user.firestore";
+import {ISODatetime} from "../../../../../shared/type-utils";
+
+
+/**
+ * Purpose of this function is to initialize a public user token for every users entries
+ */
+export const onUserCreated = functions.auth.user().onCreate(async (user, context) => {
+    info(`User created triggered: ${user.uid}`)
+    await createEmptyUserTokenWallet(user.uid);
+    await createUserInfos(user.uid);
+});
+
+export async function createEmptyUserTokenWallet(userId: string) {
+    const publicUserToken = uuidv4();
+    const userTokensWallet: UserTokensWallet = {
+        publicUserToken,
+        secretTokens: {
+            eventOrganizerTokens: [],
+            talkFeedbacksViewerTokens: []
+        }
+    };
+
+    await db
+        .collection('users').doc(userId)
+        .collection('tokens-wallet').doc('self')
+        .set(userTokensWallet)
+}
+
+export async function createUserInfos(userId: string) {
+    const user: User = {
+        userCreation: new Date().toISOString() as ISODatetime,
+        username: `Anonymous${generateRandom15DigitInteger()}`
+    }
+
+    await db.collection('users').doc(userId).set(user);
+}
+
+function generateRandom15DigitInteger() {
+    const nineDigits = Math.floor(Math.random() * 1e9).toString().padStart(9, '0');
+    const sixDigits = Math.floor(Math.random() * 1e6).toString().padStart(6, '0');
+
+    return nineDigits + sixDigits;
+}

cloud/functions/src/functions/firestore/onUserCreated.ts

@@ -1,16 +1,7 @@
 import * as functions from "firebase-functions";
 
 import crawlAll from "../../crawlers/crawl"
-
-function extractSingleQueryParam(request: functions.https.Request, paramName: string) {
-    const value  = request.query[paramName];
-    return Array.isArray(value)?value[0]?.toString():value?.toString();
-}
-
-function extractMultiQueryParam(request: functions.https.Request, paramName: string): string[] {
-    const value  = request.query[paramName];
-    return (Array.isArray(value)?value.map(v => v.toString()):[ value?.toString() ].filter(v => !!v)) as string[];
-}
+import {extractMultiQueryParam, extractSingleQueryParam} from "./utils";
 
 const crawl = functions.https.onRequest(async (request, response) => {
     const crawlingToken = extractSingleQueryParam(request, 'crawlingToken')