@gbl-uzh/platform 0.4.21 → 0.4.23

package/dist/services/GameService.js

@@ -4,10 +4,12 @@ import { repeat, none } from 'ramda';
 import logger from '../lib/logger.js';
 import { receiveEvents } from './EventService.js';
 
-async function createGame({ name, playerCount }, ctx, { roleAssigner }) {
+async function createGame({ name, playerCount, facts }, ctx, { schema, roleAssigner, }) {
+    const validatedFacts = schema.validateSync(facts);
     return ctx.prisma.game.create({
         data: {
             name,
+            facts: validatedFacts,
             owner: {
                 connect: {
                     id: ctx.user.sub,
@@ -64,7 +66,8 @@ async function addGamePeriod({ gameId, facts, segmentCount }, ctx, { schema, ser
     const index = (game.periods[0]?.index ?? -1) + 1;
     // TODO(JJ): Why do we provide validatedFacts twice?
     // - remove periodFacts from payload for initialize?
-    const { resultFacts: initializedFacts } = services.Period.initialize(validatedFacts, {
+    const { resultFacts: initializedFacts, updatedGameFacts } = services.Period.initialize(validatedFacts, {
+        gameFacts: game.facts,
         // TODO(JJ): replace with undefined
         // At RS: If we replace validatedFacts with periodFacts the
         // Derivative Game will be broken, as it computes the trend from
@@ -75,49 +78,63 @@ async function addGamePeriod({ gameId, facts, segmentCount }, ctx, { schema, ser
         periodIx: index,
     });
     console.log(game.periods[0]?.facts, game.periods[0]?.segments[0]?.facts, initializedFacts);
-    // create or update the facts and settings of a game period
-    return ctx.prisma.period.upsert({
-        where: {
-            gameId_index: {
-                gameId,
-                index,
+    const res = await ctx.prisma.$transaction(async (tx) => {
+        const updatedPeriod = await tx.period.upsert({
+            where: {
+                gameId_index: {
+                    gameId,
+                    index,
+                },
             },
-        },
-        create: {
-            index,
-            facts: initializedFacts,
-            game: {
-                connect: {
-                    id: gameId,
+            create: {
+                index,
+                facts: initializedFacts,
+                game: {
+                    connect: {
+                        id: gameId,
+                    },
+                },
+                segmentCount,
+                previousPeriod: {
+                    connect: index > 0
+                        ? {
+                            gameId_index: {
+                                gameId,
+                                index: index - 1,
+                            },
+                        }
+                        : [],
                 },
             },
-            segmentCount,
-            previousPeriod: {
-                connect: index > 0
-                    ? {
-                        gameId_index: {
-                            gameId,
-                            index: index - 1,
-                        },
-                    }
-                    : [],
+            update: {
+                facts: initializedFacts,
             },
-        },
-        update: {
-            facts: initializedFacts,
-        },
-        include: {
-            segments: {
-                include: {
-                    learningElements: true,
-                    storyElements: true,
+            include: {
+                segments: {
+                    include: {
+                        learningElements: true,
+                        storyElements: true,
+                    },
                 },
             },
-        },
+        });
+        if (updatedGameFacts) {
+            await ctx.prisma.game.update({
+                where: { id: gameId },
+                data: { facts: updatedGameFacts },
+            });
+        }
+        return updatedPeriod;
+        // NOTE(JJ): We don't a serialization isolation level here, as only one admin adds
+        // a period at a time
     });
+    return res;
 }
 async function addPeriodSegment({ gameId, periodIx, facts, learningElements, storyElements, }, ctx, { schema, services }) {
     const validatedFacts = schema.validateSync(facts);
+    const game = await ctx.prisma.game.findUnique({ where: { id: gameId } });
+    if (!game)
+        return null;
     const period = await ctx.prisma.period.findUnique({
         where: {
             gameId_index: {
@@ -137,79 +154,90 @@ async function addPeriodSegment({ gameId, periodIx, facts, learningElements, sto
     if (!period)
         return null;
     const index = (period.segments[0]?.index ?? -1) + 1;
-    const { resultFacts: initializedFacts } = services.Segment.initialize(validatedFacts, {
+    const { resultFacts: initializedFacts, updatedGameFacts } = services.Segment.initialize(validatedFacts, {
+        gameFacts: game.facts,
         periodFacts: period.facts,
         previousSegmentFacts: period.segments[0]?.facts,
         segmentIx: index,
         segmentCount: period.segmentCount,
         periodIx,
     });
-    // create or update the facts and settings of a period segment
-    return ctx.prisma.periodSegment.upsert({
-        where: {
-            gameId_periodIx_index: {
-                gameId,
-                periodIx,
-                index,
-            },
-        },
-        create: {
-            index,
-            facts: initializedFacts,
-            learningElements: {
-                connect: learningElements
-                    ? learningElements.map((item) => ({ id: item }))
-                    : [],
-            },
-            storyElements: {
-                connect: storyElements
-                    ? storyElements.map((item) => ({ id: item }))
-                    : [],
-            },
-            game: {
-                connect: {
-                    id: gameId,
+    const res = await ctx.prisma.$transaction(async (tx) => {
+        // create or update the facts and settings of a period segment
+        const updatedSegment = ctx.prisma.periodSegment.upsert({
+            where: {
+                gameId_periodIx_index: {
+                    gameId,
+                    periodIx,
+                    index,
                 },
             },
-            periodIx: periodIx,
-            period: {
-                connect: {
-                    gameId_index: {
-                        gameId,
-                        index: periodIx,
+            create: {
+                index,
+                facts: initializedFacts,
+                learningElements: {
+                    connect: learningElements
+                        ? learningElements.map((item) => ({ id: item }))
+                        : [],
+                },
+                storyElements: {
+                    connect: storyElements
+                        ? storyElements.map((item) => ({ id: item }))
+                        : [],
+                },
+                game: {
+                    connect: {
+                        id: gameId,
                     },
                 },
-            },
-            previousSegment: {
-                connect: index > 0
-                    ? {
-                        gameId_periodIx_index: {
+                periodIx: periodIx,
+                period: {
+                    connect: {
+                        gameId_index: {
                             gameId,
-                            periodIx,
-                            index: index - 1,
+                            index: periodIx,
                         },
-                    }
-                    : [],
+                    },
+                },
+                previousSegment: {
+                    connect: index > 0
+                        ? {
+                            gameId_periodIx_index: {
+                                gameId,
+                                periodIx,
+                                index: index - 1,
+                            },
+                        }
+                        : [],
+                },
             },
-        },
-        update: {
-            facts: initializedFacts,
-            learningElements: {
-                connect: learningElements
-                    ? learningElements.map((item) => ({ id: item }))
-                    : [],
+            update: {
+                facts: initializedFacts,
+                learningElements: {
+                    connect: learningElements
+                        ? learningElements.map((item) => ({ id: item }))
+                        : [],
+                },
+                storyElements: {
+                    connect: storyElements
+                        ? storyElements.map((item) => ({ id: item }))
+                        : [],
+                },
             },
-            storyElements: {
-                connect: storyElements
-                    ? storyElements.map((item) => ({ id: item }))
-                    : [],
+            include: {
+                learningElements: true,
+                storyElements: true,
             },
-        },
-        include: {
-            learningElements: true,
-            storyElements: true,
-        },
+        });
+        if (updatedGameFacts) {
+            await ctx.prisma.game.update({
+                where: { id: gameId },
+                data: { facts: updatedGameFacts },
+            });
+        }
+        return updatedSegment;
     });
+    return res;
 }
 async function activateNextPeriod({ gameId }, ctx, { services }) {
     logger.info('activating next period');
@@ -275,16 +303,32 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
     switch (game.status) {
         // SCHEDULED -> PREPARATION
         // if the game is scheduled, initialize period results and move to PREPARATION
+        // TODO(JJ):
+        // - The game facts should now be updated by the results
+        // - They should be updated by the game status, e.g. when going to the next
+        //   period or segment
+        // - Done: the game facts are updated on user interaction in PlayService
         case DB.GameStatus.SCHEDULED: {
             const { results, extras } = computePeriodStartResults({
                 results: undefined,
                 players: game.players,
                 activePeriodIx: currentPeriodIx,
-                gameId: game.id,
+                game,
                 periodFacts: game.periods?.[0]?.facts,
             }, ctx, { services });
             // update the status and active period of the current game
             // and prepare PERIOD_START results
+            const gameData = {
+                status: DB.GameStatus.PREPARATION,
+                activePeriodIx: nextPeriodIx,
+                activePeriod: {
+                    connect: { gameId_index: { gameId, index: nextPeriodIx } },
+                },
+            };
+            // TODO(JJ): Somewhere here we need to have a gameFactsUpdateService
+            // if (Object.keys(gameFactsToUpdate).length > 0) {
+            //   gameData.facts = gameFactsToUpdate
+            // }
             const result = await ctx.prisma.$transaction([
                 ctx.prisma.game.update({
                     where: {
@@ -297,18 +341,7 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
                             },
                         },
                     },
-                    data: {
-                        status: DB.GameStatus.PREPARATION,
-                        activePeriodIx: nextPeriodIx,
-                        activePeriod: {
-                            connect: {
-                                gameId_index: {
-                                    gameId,
-                                    index: nextPeriodIx,
-                                },
-                            },
-                        },
-                    },
+                    data: gameData,
                 }),
                 ctx.prisma.period.update({
                     where: {
@@ -336,16 +369,16 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
             const { results, extras } = computeSegmentEndResults(game, ctx, {
                 services,
             });
+            // TODO(JJ): Check if we need to update the game facts as well
             // update period facts when starting consolidation
             const { resultFacts: consolidatedFacts } = services.Period.consolidate(game.activePeriod.facts, {
+                gameFacts: game.facts,
                 previousSegmentFacts: game.activePeriod.activeSegment.facts,
                 periodIx: currentPeriodIx,
             });
             const result = await ctx.prisma.$transaction([
                 ctx.prisma.game.update({
-                    data: {
-                        status: DB.GameStatus.CONSOLIDATION,
-                    },
+                    data: { status: DB.GameStatus.CONSOLIDATION },
                     include: {
                         periods: {
                             include: {
@@ -408,7 +441,7 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
                 periodDecisions: game.activePeriod.decisions,
                 activePeriodIx: currentPeriodIx,
                 activeSegmentIx: currentSegmentIx,
-                gameId: game.id,
+                game,
             }, ctx, { services });
             await Promise.all(promises);
             // TODO(JJ): The error happens here for the last consolidation
@@ -439,6 +472,13 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
             //     },
             //   }
             // }
+            const gameData = {
+                status: DB.GameStatus.RESULTS,
+                activePeriodIx: periodIx,
+                activePeriod: {
+                    connect: { gameId_index: { gameId, index: periodIx } },
+                },
+            };
             // TODO(JJ): Check with RS
             // - when updating the game with the nextPeriodIx it crashes
             const result = await ctx.prisma.$transaction([
@@ -454,18 +494,7 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
                             },
                         },
                     },
-                    data: {
-                        status: DB.GameStatus.RESULTS,
-                        activePeriodIx: periodIx,
-                        activePeriod: {
-                            connect: {
-                                gameId_index: {
-                                    gameId,
-                                    index: periodIx,
-                                },
-                            },
-                        },
-                    },
+                    data: gameData,
                 }),
                 // create PERIOD_END results based on the previous SEGMENT_END results
                 ctx.prisma.period.update({
@@ -522,7 +551,7 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
                 results: game.activePeriod.previousPeriod[0]?.results,
                 players: game.players,
                 activePeriodIx: currentPeriodIx,
-                gameId: game.id,
+                game,
                 periodFacts: game.activePeriod.facts,
             }, ctx, { services });
             const result = await ctx.prisma.$transaction([
@@ -538,9 +567,7 @@ async function activateNextPeriod({ gameId }, ctx, { services }) {
                             },
                         },
                     },
-                    data: {
-                        status: DB.GameStatus.PREPARATION,
-                    },
+                    data: { status: DB.GameStatus.PREPARATION },
                 }),
                 // create PERIOD_START results based on the previous PERIOD_END results
                 ctx.prisma.period.update({
@@ -610,6 +637,15 @@ async function activateNextSegment({ gameId }, ctx, { services }) {
         // PAUSED -> RUNNING
         case DB.GameStatus.PREPARATION:
         case DB.GameStatus.PAUSED: {
+            // NOTE(JJ): Update game facts per segment, but not for the initialization
+            const { updatedGameFacts } = services.GameFacts.update(game.facts, {
+                periodIx: currentPeriodIx,
+                segmentIx: nextSegmentIx, // TODO(JJ): Double-check if this is right
+            });
+            const isVeryFirst = currentPeriodIx === 0 && currentSegmentIx === -1;
+            if (updatedGameFacts && !isVeryFirst) {
+                game.facts = updatedGameFacts;
+            }
             const { results, extras } = computeSegmentStartResults(game, ctx, {
                 services,
             });
@@ -628,6 +664,7 @@ async function activateNextSegment({ gameId }, ctx, { services }) {
                     },
                     data: {
                         status: DB.GameStatus.RUNNING,
+                        ...(updatedGameFacts ? { facts: game.facts } : {}),
                     },
                 }),
                 // update the active segment of the current period
@@ -691,9 +728,7 @@ async function activateNextSegment({ gameId }, ctx, { services }) {
                         },
                         players: true,
                     },
-                    data: {
-                        status: DB.GameStatus.PAUSED,
-                    },
+                    data: { status: DB.GameStatus.PAUSED },
                 }),
                 ctx.prisma.periodSegment.update({
                     where: {
@@ -881,9 +916,11 @@ function mapAction({ ctx, gameId, activePeriodIx, playerId }) {
         },
     });
 }
-function computePeriodStartResults({ results, players, activePeriodIx, gameId, periodFacts }, ctx, { services }) {
+function computePeriodStartResults({ results, players, activePeriodIx, game, periodFacts }, ctx, { services }) {
     const currentPeriodIx = activePeriodIx;
     const nextPeriodIx = currentPeriodIx + 1;
+    // TODO(JJ): Instead of creating prisma queries, just save the parameters
+    // of mapAction and call it later in an async transaction fn
     let extras = [];
     // if the game is running, transform previous results to next
     if (currentPeriodIx >= 0) {
@@ -893,12 +930,13 @@ function computePeriodStartResults({ results, players, activePeriodIx, gameId, p
             .map((result, ix, allResults) => {
             const { resultFacts: facts, actions } = services.PeriodResult.start(result.facts, {
                 playerRole: result.player?.role ?? result.player.connect?.role,
+                gameFacts: game.facts,
                 periodFacts,
             });
             if (actions && actions.length > 0) {
                 const mapper = mapAction({
                     ctx,
-                    gameId,
+                    gameId: game.id,
                     activePeriodIx: currentPeriodIx,
                     playerId: result.player.id,
                 });
@@ -915,7 +953,7 @@ function computePeriodStartResults({ results, players, activePeriodIx, gameId, p
                 },
                 game: {
                     connect: {
-                        id: gameId,
+                        id: game.id,
                     },
                 },
             };
@@ -927,11 +965,11 @@ function computePeriodStartResults({ results, players, activePeriodIx, gameId, p
     }
     // if the game has not started yet, generate initial PERIOD_START results
     const result = players.map((player, ix, allPlayers) => {
-        const { resultFacts: facts, actions } = services.PeriodResult.initialize({}, { playerRole: player.role, periodFacts });
+        const { resultFacts: facts, actions } = services.PeriodResult.initialize({}, { playerRole: player.role, gameFacts: game.facts, periodFacts });
         if (actions && actions.length > 0) {
             const mapper = mapAction({
                 ctx,
-                gameId,
+                gameId: game.id,
                 activePeriodIx: nextPeriodIx,
                 playerId: player.id,
             });
@@ -948,7 +986,7 @@ function computePeriodStartResults({ results, players, activePeriodIx, gameId, p
             },
             game: {
                 connect: {
-                    id: gameId,
+                    id: game.id,
                 },
             },
         };
@@ -958,7 +996,7 @@ function computePeriodStartResults({ results, players, activePeriodIx, gameId, p
         extras,
     };
 }
-async function computePeriodEndResults({ segmentEndResults, players, activeSegmentResults, periodFacts, periodDecisions, segmentFacts, activePeriodIx, activeSegmentIx, gameId, }, ctx, { services }) {
+async function computePeriodEndResults({ segmentEndResults, players, activeSegmentResults, periodFacts, periodDecisions, segmentFacts, activePeriodIx, activeSegmentIx, game, }, ctx, { services }) {
     let extras = [];
     let promises = [];
     const perPlayer = {};
@@ -975,6 +1013,7 @@ async function computePeriodEndResults({ segmentEndResults, players, activeSegme
         const consolidationDecisions = perPlayer[result.playerId].consolidationDecisions;
         const { resultFacts: facts, actions, events, } = services.PeriodResult.end(result.facts, {
             segmentEndResults,
+            gameFacts: game.facts,
             periodFacts,
             segmentFacts,
             playerRole: result.player.role,
@@ -988,7 +1027,7 @@ async function computePeriodEndResults({ segmentEndResults, players, activeSegme
         if (actions && actions.length > 0) {
             const mapper = mapAction({
                 ctx,
-                gameId,
+                gameId: game.id,
                 activePeriodIx,
                 playerId: result.player.id,
             });
@@ -1002,7 +1041,7 @@ async function computePeriodEndResults({ segmentEndResults, players, activeSegme
                     args: {
                         playerId: result.player.id,
                         periodIx: activePeriodIx,
-                        gameId,
+                        gameId: game.id,
                     },
                     user: ctx.user,
                     achievements: result.player.achievementKeys,
@@ -1023,7 +1062,7 @@ async function computePeriodEndResults({ segmentEndResults, players, activeSegme
             },
             game: {
                 connect: {
-                    id: gameId,
+                    id: game.id,
                 },
             },
         };
@@ -1045,6 +1084,7 @@ function computeSegmentStartResults(game, ctx, { services }) {
             .reduce((acc, result, ix, allResults) => {
             const { resultFacts: facts, actions } = services.SegmentResult.start(result.facts, {
                 playerRole: result.player.role,
+                gameFacts: game.facts,
                 periodFacts: game.activePeriod.facts,
                 segmentFacts: game.activePeriod.activeSegment.facts,
                 nextSegmentFacts: game.activePeriod.activeSegment.nextSegment?.facts,
@@ -1057,6 +1097,7 @@ function computeSegmentStartResults(game, ctx, { services }) {
                     activePeriodIx: game.activePeriodIx,
                     playerId: result.player.id,
                 });
+                // TODO(JJ): @RS Careful, here!!! We add this array to $transaction
                 extras = [...extras, ...actions.map(mapper)];
             }
             const common = {
@@ -1106,6 +1147,7 @@ function computeSegmentStartResults(game, ctx, { services }) {
         .reduce((acc, result, ix, allResults) => {
         let { resultFacts: facts } = services.SegmentResult.initialize(result.facts, {
             playerRole: result.player.role,
+            gameFacts: game.facts,
             periodFacts: activePeriod.facts,
             segmentFacts: aboutToBeactiveSegment.facts,
             nextSegmentFacts: aboutToBeactiveSegment.nextSegment?.facts,
@@ -1150,11 +1192,14 @@ function computeSegmentStartResults(game, ctx, { services }) {
 }
 function computeSegmentEndResults(game, ctx, { services }) {
     let extras = [];
+    // NOTE(JJ): We go through all results of the active segment of each player
+    // and update the game facts if needed
     const results = game.activePeriod.activeSegment.results
         .filter((result) => result.type === DB.PlayerResultType.SEGMENT_END)
         .map((result, ix, allResults) => {
         const { resultFacts: facts, actions } = services.SegmentResult.end(result.facts, {
             playerRole: result.player.role,
+            gameFacts: game.facts,
             periodFacts: game.activePeriod.facts,
             segmentFacts: game.activePeriod.activeSegment.facts,
             segmentIx: game.activePeriod.activeSegmentIx,