Add a scoreboard widget to the backstages of physical auditoriums (#178)

Author: reivilibre

src/Scheduler.ts

@@ -318,6 +318,8 @@ export class Scheduler {
     }
 
     private async _execute(task: ITask) {
+        // This is undefined when we're either just plain missing a talk room when we shouldn't,
+        // or when the auditorium is physical (in which case talks don't have rooms).
         const confTalk: Talk | undefined = this.conference.getTalk(task.talk.id);
         const confAud = this.conference.getAuditorium(task.talk.auditoriumId);
         const confAudBackstage = this.conference.getAuditoriumBackstage(task.talk.auditoriumId);

src/commands/WidgetsCommand.ts

@@ -41,6 +41,17 @@ export class WidgetsCommand implements ICommand {
             await client.sendStateEvent(talk.roomId, scoreboardWidget.type, scoreboardWidget.state_key, scoreboardWidget.content);
             await client.sendStateEvent(talk.roomId, talkLayout.type, talkLayout.state_key, talkLayout.content);
         }
+
+        if ((await aud.getDefinition()).isPhysical) {
+            // For physical auditoriums, the talks don't have anywhere to display a Q&A scoreboard.
+            // So what we do instead is add a Q&A scoreboard to the backstage room, so that an organiser can read off
+            // any questions if necessary.
+            const backstage = conference.getAuditoriumBackstage(await aud.getId());
+            const audScoreboardWidget = await LiveWidget.scoreboardForAuditorium(aud, client);
+            const backstageLayout = LiveWidget.layoutForPhysicalAudBackstage(audScoreboardWidget);
+            await client.sendStateEvent(backstage.roomId, audScoreboardWidget.type, audScoreboardWidget.state_key, audScoreboardWidget.content);
+            await client.sendStateEvent(backstage.roomId, backstageLayout.type, backstageLayout.state_key, backstageLayout.content);
+        }
     }
 
     public async run(conference: Conference, client: MatrixClient, roomId: string, event: any, args: string[]) {

src/models/LiveWidget.ts

@@ -104,9 +104,17 @@ export class LiveWidget {
     }
 
     public static async scoreboardForTalk(talk: Talk, client: MatrixClient): Promise<IStateEvent<IWidget>> {
-        const widgetId = sha256(JSON.stringify(await talk.getDefinition()) + "_SCOREBOARD");
-        const aud = await config.RUNTIME.conference.getAuditorium(await talk.getAuditoriumId());
-        const title = aud ? `Messages from ${await aud.getCanonicalAlias()}` : `Messages from ${await talk.getAuditoriumId()}`;
+        const aud = config.RUNTIME.conference.getAuditorium(await talk.getAuditoriumId());
+        if (aud === undefined) {
+            throw new Error(`No auditorium ${await talk.getAuditoriumId()} for talk ${await talk.getId()}`);
+        }
+        return this.scoreboardForAuditorium(aud, client, talk);
+    }
+
+    public static async scoreboardForAuditorium(aud: Auditorium, client: MatrixClient, talk?: Talk): Promise<IStateEvent<IWidget>> {
+        // note: this is a little bit awkward, but there's nothing special about the widget ID, it just needs to be unique
+        const widgetId = sha256(JSON.stringify([await aud.getId(), talk ? await talk.getId() : ""]) + "_SCOREBOARD");
+        const title = `Messages from ${await aud.getCanonicalAlias()}`;
         return {
             type: "im.vector.modular.widgets",
             state_key: widgetId,
@@ -120,8 +128,8 @@ export class LiveWidget {
                 url: config.webserver.publicBaseUrl + "/widgets/scoreboard.html?widgetId=$matrix_widget_id&auditoriumId=$auditoriumId&talkId=$talkId&theme=$theme",
                 data: {
                     title: title,
-                    auditoriumId: await talk.getAuditoriumId(),
-                    talkId: await talk.getId(),
+                    auditoriumId: await aud.getId(),
+                    talkId: talk ? await talk.getId() : null
                 },
             } as IWidget,
         };
@@ -168,6 +176,23 @@ export class LiveWidget {
         };
     }
 
+    public static layoutForPhysicalAudBackstage(scoreboard: IStateEvent<IWidget>): IStateEvent<ILayout> {
+        return {
+            type: "io.element.widgets.layout",
+            state_key: "",
+            content: {
+                widgets: {
+                    [scoreboard.state_key]: {
+                        container: "top",
+                        index: 0,
+                        width: 100,
+                        height: 60,
+                    },
+                },
+            },
+        };
+    }
+
     public static layoutForTalk(qa: IStateEvent<IWidget>, scoreboard: IStateEvent<IWidget> | null): IStateEvent<ILayout> {
         const val: IStateEvent<ILayout> = {
             type: "io.element.widgets.layout",

src/web.ts

@@ -197,23 +197,31 @@ export async function renderScoreboardWidget(req: Request, res: Response) {
     if (!audId || Array.isArray(audId)) {
         return res.sendStatus(404);
     }
-    const talkId = req.query?.['talkId'] as string;
-    if (!talkId || Array.isArray(talkId)) {
-        return res.sendStatus(404);
-    }
 
     const aud = config.RUNTIME.conference.getAuditorium(audId);
     if (!aud) {
         return res.sendStatus(404);
     }
 
-    const talk = config.RUNTIME.conference.getTalk(talkId);
-    if (!talk) {
-        return res.sendStatus(404);
-    }
+    if (!(await aud.getDefinition()).isPhysical) {
+        // For physical auditoriums, the widget sits in the backstage room and so there isn't any talk ID to cross-reference, so skip
+        // these checks for physical auditoriums.
+        // I'm not sure why we want to check a talk ID anyway — 'security'?
+        // But I'll leave it be.
 
-    if (await talk.getAuditoriumId() !== await aud.getId()) {
-        return res.sendStatus(404);
+        const talkId = req.query?.['talkId'] as string;
+        if (!talkId || Array.isArray(talkId)) {
+            return res.sendStatus(404);
+        }
+
+        const talk = config.RUNTIME.conference.getTalk(talkId);
+        if (!talk) {
+            return res.sendStatus(404);
+        }
+
+        if (await talk.getAuditoriumId() !== await aud.getId()) {
+            return res.sendStatus(404);
+        }
     }
 
     return res.render('scoreboard.liquid', {