feat(v2): vote and estimation tracking

The RoomState TRPC endpoints now are used to track those events.

src/hooks/use-room-state.hook.ts

@@ -39,9 +39,7 @@ export const useRoomState = ({
       },
       {
         onSuccess: (roomStateJson) => {
-          updateRoomState(
-            RoomStateClient.fromJson(roomStateJson as RoomStateDto),
-          );
+          updateRoomState(RoomStateClient.fromJson(roomStateJson));
           setIsConnecting(false);
         },
       },

src/server/api/routers/vote.router.ts

@@ -1,54 +1,11 @@
 import { createTRPCRouter, publicProcedure } from "fpp/server/api/trpc";
-import { z } from "zod";
-import { fibonacciSequence } from "fpp/constants/fibonacci.constant";
 import { DateTime } from "luxon";
-import { type ICreateVote, votes } from "fpp/server/db/schema";
+import { votes } from "fpp/server/db/schema";
 import { sql } from "drizzle-orm";
 import { round } from "fpp/utils/number.utils";
 import { countTable } from "fpp/utils/db-api.util";
 
 export const voteRouter = createTRPCRouter({
-  vote: publicProcedure
-    .input(
-      z.object({
-        roomId: z.number(),
-        estimations: z
-          .array(z.number())
-          .min(1)
-          .refine(
-            (values) =>
-              values.every((value) => fibonacciSequence.includes(value)),
-            {
-              message: "Every vote must be a valid fibonacci number",
-            },
-          ),
-        duration: z.number().min(0),
-        amountOfSpectators: z.number().min(0),
-      }),
-    )
-    .mutation(
-      async ({
-        ctx: { db },
-        input: { roomId, estimations, duration, amountOfSpectators },
-      }) => {
-        const vote: ICreateVote = {
-          roomId,
-          avgEstimation: String(
-            estimations.reduce((a, b) => a + b, 0) / estimations.length,
-          ),
-          maxEstimation: String(
-            estimations.reduce((a, b) => Math.max(a, b), 1),
-          ),
-          minEstimation: String(
-            estimations.reduce((a, b) => Math.min(a, b), 21),
-          ),
-          amountOfEstimations: String(estimations.length),
-          amountOfSpectators,
-          duration,
-        };
-        await db.insert(votes).values(vote);
-      },
-    ),
   getVotes: publicProcedure.query(async ({ ctx: { db } }) => {
     const averages = (await db.execute(sql`
         SELECT AVG(avg_estimation)  as avg_avgEstimation,

src/server/db/schema.ts

@@ -48,18 +48,9 @@ export const votes = mysqlTable("votes", {
     precision: 4,
     scale: 2,
   }).notNull(),
-  maxEstimation: decimal("max_estimation", {
-    precision: 4,
-    scale: 2,
-  }).notNull(),
-  minEstimation: decimal("min_estimation", {
-    precision: 4,
-    scale: 2,
-  }).notNull(),
-  amountOfEstimations: decimal("amount_of_estimations", {
-    precision: 4,
-    scale: 2,
-  }).notNull(),
+  maxEstimation: smallint("max_estimation").notNull(),
+  minEstimation: smallint("min_estimation").notNull(),
+  amountOfEstimations: smallint("amount_of_estimations").notNull(),
   amountOfSpectators: smallint("amount_of_spectators").notNull(),
   duration: smallint("duration").notNull(),
   votedAt: timestamp("voted_at").defaultNow().notNull(),

src/server/room-state/room-state.entity.ts

@@ -1,3 +1,5 @@
+import { type ICreateVote } from "fpp/server/db/schema";
+
 export interface CreateUserDto {
   id: string;
   name: string;
@@ -7,10 +9,12 @@ export interface CreateUserDto {
 
 export interface RoomStateDto {
   id: number;
+  startedAt: number;
   lastUpdated: number;
   users: CreateUserDto[];
   isFlipped: boolean;
   isAutoFlip: boolean;
+  isFlippable: boolean;
 }
 
 export class User {
@@ -39,29 +43,20 @@ export class User {
 
 class RoomStateBase {
   readonly id: number;
+  startedAt: number;
   lastUpdated: number;
 
   users: User[] = [];
   isFlipped = false;
   isAutoFlip = false;
 
-  static fromJson<T extends RoomStateBase>(
-    this: new (id: number) => T,
-    roomStateJson: RoomStateDto,
-  ) {
-    const roomState = new this(roomStateJson.id);
-    roomState.lastUpdated = roomStateJson.lastUpdated;
-    roomState.users = roomStateJson.users.map((user) => new User(user));
-    roomState.isFlipped = roomStateJson.isFlipped;
-    roomState.isAutoFlip = roomStateJson.isAutoFlip;
-    return roomState;
-  }
-
   get isFlippable() {
     return (
       this.users.every(
         (user) => user.estimation !== null || user.isSpectator,
-      ) && this.users.some((user) => !user.isSpectator)
+      ) &&
+      this.users.some((user) => !user.isSpectator) &&
+      !this.isFlipped
     );
   }
 
@@ -78,11 +73,28 @@ class RoomStateBase {
 
   constructor(id: number) {
     this.id = id;
+    this.startedAt = Date.now();
     this.lastUpdated = Date.now();
   }
 
-  toJson() {
+  static fromJson<T extends RoomStateBase>(
+    this: new (id: number) => T,
+    roomStateJson: RoomStateDto,
+  ) {
+    const roomState = new this(roomStateJson.id);
+    roomState.startedAt = roomStateJson.startedAt;
+    roomState.lastUpdated = roomStateJson.lastUpdated;
+    roomState.users = roomStateJson.users.map((user) => new User(user));
+    roomState.isFlipped = roomStateJson.isFlipped;
+    roomState.isAutoFlip = roomStateJson.isAutoFlip;
+    return roomState;
+  }
+
+  toJson(): RoomStateDto {
     return {
+      id: this.id,
+      startedAt: this.startedAt,
+      lastUpdated: this.lastUpdated,
       users: this.users,
       isFlipped: this.isFlipped,
       isAutoFlip: this.isAutoFlip,
@@ -122,6 +134,7 @@ export class RoomStateClient extends RoomStateBase {
 
 export class RoomStateServer extends RoomStateBase {
   hasChanged = false;
+  isFlipAction = false;
 
   /**
   /* USER MANAGEMENT
@@ -151,6 +164,7 @@ export class RoomStateServer extends RoomStateBase {
     this.users = this.users.map((user) => {
       if (user.id === userId) {
         user.estimation = estimation;
+        user.isSpectator = false;
         this.hasChanged = true;
       }
       return user;
@@ -162,6 +176,7 @@ export class RoomStateServer extends RoomStateBase {
     this.users = this.users.map((user) => {
       if (user.id === userId) {
         user.isSpectator = isSpectator;
+        user.estimation = null;
         this.hasChanged = true;
       }
       return user;
@@ -175,10 +190,11 @@ export class RoomStateServer extends RoomStateBase {
     }
     this.isFlipped = true;
     this.hasChanged = true;
+    this.isFlipAction = true;
   }
 
   private autoFlip() {
-    if (this.isFlippable && this.isAutoFlip) {
+    if (this.isAutoFlip && this.isFlippable && !this.isFlipped) {
       this.flip();
     }
   }
@@ -190,19 +206,41 @@ export class RoomStateServer extends RoomStateBase {
   }
 
   reset() {
+    this.startedAt = Date.now();
+    this.lastUpdated = Date.now();
     this.users = this.users.map((user) => {
       user.estimation = null;
       return user;
     });
     this.isFlipped = false;
-    this.isAutoFlip = false;
     this.hasChanged = true;
   }
 
-  fullReset() {
-    this.users = [];
-    this.isFlipped = false;
-    this.isAutoFlip = false;
-    this.hasChanged = true;
+  /**
+   * ANALYTICS
+   */
+  calculateVote(): ICreateVote {
+    const estimations = this.users
+      .map((user) => user.estimation)
+      .filter((estimation) => estimation !== null) as number[];
+    if (estimations.length === 0) {
+      throw new Error("Cannot calculateCreateVote when no estimations");
+    }
+
+    return {
+      roomId: this.id,
+      avgEstimation: String(
+        estimations.reduce((a, b) => a + b, 0) / estimations.length,
+      ),
+      maxEstimation: String(
+        estimations.reduce((a, b) => Math.max(a, b), 1),
+      ) as unknown as number,
+      minEstimation: String(
+        estimations.reduce((a, b) => Math.min(a, b), 21),
+      ) as unknown as number,
+      amountOfEstimations: String(estimations.length) as unknown as number,
+      amountOfSpectators: this.users.filter((user) => user.isSpectator).length,
+      duration: Math.ceil((Date.now() - this.startedAt) / 1000),
+    };
   }
 }