User Analytics (CS IA)

lib/Auth.ts

@@ -14,7 +14,7 @@ import CollectionId from "./client/CollectionId";
 import { AdapterUser } from "next-auth/adapters";
 import { wait } from "./client/ClientUtils";
 
-var db = getDatabase();
+const db = getDatabase();
 
 const adapter = MongoDBAdapter(clientPromise, { databaseName: process.env.DB });
 
@@ -123,21 +123,36 @@ export const AuthenticationOptions: AuthOptions = {
 						if (!foundUser) await wait(50);
 					}
 
-					console.log(
-						"User is incomplete, filling in missing fields. User:",
-						typedUser,
-					);
+					console.log("User is incomplete, filling in missing fields.");
 
 					typedUser._id = foundUser._id;
+					typedUser.lastSignInDateTime = new Date();
 
 					typedUser = await repairUser(await db, typedUser);
 
-					console.log("User updated:", typedUser);
+					console.log("User updated:", typedUser._id?.toString());
 				};
 
 				repairUserOnceItIsInDb();
 			}
 
+			const today = new Date();
+			if (
+				(typedUser as User).lastSignInDateTime?.toDateString() !==
+				today.toDateString()
+			) {
+				// We use user.id since user._id strangely doesn't exist on user.
+				await getDatabase().then((db) =>
+					db.updateObjectById(
+						CollectionId.Users,
+						new ObjectId(typedUser._id?.toString()),
+						{
+							lastSignInDateTime: today,
+						},
+					),
+				);
+			}
+
 			new ResendUtils().createContact(typedUser as User);
 
 			return true;

lib/Types.ts

@@ -47,6 +47,7 @@ export class User implements NextAuthUser {
 	level: number = 1;
 	onboardingComplete: boolean = false;
 	resendContactId: string | undefined = undefined;
+	lastSignInDateTime: Date | undefined = undefined;
 
 	constructor(
 		name: string | undefined,
@@ -567,6 +568,126 @@ export type CompPicklistGroup = {
 	strikethroughs: number[];
 };
 
+type LinkedNode<T> = T & {
+	prev?: LinkedNode<T>;
+	next?: LinkedNode<T>;
+};
+
+/**
+ * @tested_by tests/lib/Types.test.ts
+ */
+export class LinkedList<T> {
+	private head?: LinkedNode<T> = undefined;
+
+	constructor(head?: T | T[]) {
+		if (Array.isArray(head) && head.length > 0) {
+			let node: LinkedNode<T>;
+
+			for (const element of head) {
+				if (!this.head) {
+					this.head = {
+						...element,
+						next: undefined,
+						prev: undefined,
+					};
+
+					node = this.head;
+				} else node = this.insertAfter(node!, element);
+			}
+		} else if (head)
+			this.head = {
+				...(head as T),
+				next: undefined,
+				prev: undefined,
+			};
+	}
+
+	size() {
+		let count = 0;
+
+		for (let node = this.head; node !== undefined; node = node.next) count++;
+
+		return count;
+	}
+
+	isEmpty() {
+		return this.head === undefined;
+	}
+
+	first() {
+		return this.head;
+	}
+
+	last() {
+		let node = this.head;
+		while (node?.next) node = node.next;
+
+		return node;
+	}
+
+	// Add to criterion B
+	/**
+	 * Will reset the list to just be head
+	 */
+	setHead(insertedVal: T) {
+		this.head = {
+			...insertedVal,
+			prev: undefined,
+			next: undefined,
+		};
+	}
+
+	insertBefore(existingNode: LinkedNode<T>, insertedVal: T) {
+		const insertedNode: LinkedNode<T> = {
+			...insertedVal,
+			next: existingNode,
+		};
+
+		if (existingNode.prev) {
+			existingNode.prev.next = insertedNode;
+			insertedNode.prev = existingNode.prev;
+		}
+		existingNode.prev = insertedNode;
+
+		if (this.head === existingNode) this.head = insertedNode;
+
+		return insertedNode;
+	}
+
+	insertAfter(existingNode: LinkedNode<T>, insertedVal: T) {
+		const insertedNode: LinkedNode<T> = {
+			...insertedVal,
+			prev: existingNode,
+		};
+
+		if (existingNode.next) {
+			existingNode.next.prev = insertedNode;
+			insertedNode.next = existingNode.next;
+		}
+		existingNode.next = insertedNode;
+
+		return insertedNode;
+	}
+
+	// Add to criterion B
+	forEach(func: (node: LinkedNode<T>) => any) {
+		for (let node = this.head; node; node = node.next) {
+			func(node);
+		}
+	}
+
+	// Add to criterion B
+	map<TMap>(func: (node: LinkedNode<T>) => TMap) {
+		const array: TMap[] = [];
+
+		for (let node = this.head; node; node = node.next) {
+			array.push(func(node));
+		}
+
+		return array;
+	}
+}
+
 /**
  * DO NOT GIVE TO CLIENTS!
  */

lib/api/ClientApi.ts

@@ -21,6 +21,7 @@ import {
 	WebhookHolder,
 	LeaderboardUser,
 	LeaderboardTeam,
+	LinkedList,
 } from "@/lib/Types";
 import { NotLinkedToTba, removeDuplicates } from "../client/ClientUtils";
 import {
@@ -2179,4 +2180,103 @@ export default class ClientApi extends NextApiTemplate<ApiDependencies> {
 				.send({ users: leaderboardUsers, teams: leaderboardTeamsArray });
 		},
 	});
+
+	getUserAnalyticsData = createNextRoute<
+		[],
+		{ [team: string]: { date: Date; count: number }[] },
+		ApiDependencies,
+		void
+	>({
+		isAuthorized: AccessLevels.IfDeveloper,
+		handler: async (req, res, { db: dbPromise }, authData, args) => {
+			const db = await dbPromise;
+
+			// Find data from DB
+			const [teams, users] = await Promise.all([
+				db.findObjects(CollectionId.Teams, {}),
+				db.findObjects(CollectionId.Users, {
+					lastSignInDateTime: { $exists: true },
+				}),
+			]);
+
+			// Create a linked list for each team
+			const signInDatesByTeam: {
+				[team: string]: LinkedList<{ date: string; count: number }>;
+			} = teams.reduce(
+				(acc, team) => {
+					acc[team._id!.toString()] = new LinkedList<{
+						date: string;
+						count: number;
+					}>();
+					return acc;
+				},
+				{ All: new LinkedList() } as {
+					[team: string]: LinkedList<{ date: string; count: number }>;
+				},
+			);
+
+			for (const user of users) {
+				// Add the user to each of their teams
+				for (const team of [...user.teams, "All"]) {
+					const signInDates = signInDatesByTeam[team];
+
+					// Iterate through the team's linked list
+					for (let node = signInDates.first(); true; node = node.next) {
+						if (!node) {
+							// We're either at the end of the list, or the list is empty
+
+							// Can't just update signInDates, as that will reference a new object and not change the old one!
+							signInDates.setHead({
+								date: user.lastSignInDateTime!.toDateString(),
+								count: 1,
+							});
+							break;
+						}
+
+						if (
+							node &&
+							node?.date === user.lastSignInDateTime!.toDateString()
+						) {
+							// Found the node with the same date
+							node.count++;
+							break;
+						}
+
+						if (
+							!node?.next ||
+							new Date(user.lastSignInDateTime!.toDateString())! <
+								new Date(node.next.date)
+						) {
+							// The next node's date is after the user's sign-in date
+							signInDates.insertAfter(node!, {
+								date: user.lastSignInDateTime!.toDateString(),
+								count: 1,
+							});
+							break;
+						}
+					}
+				}
+			}
+
+			// Convert linked lists to arrays
+			const responseObj: { [team: string]: { date: Date; count: number }[] } =
+				{};
+			for (const obj of [...teams, "All"]) {
+				// Convert ObjectIds to strings
+				const id = typeof obj === "object" ? obj._id!.toString() : obj;
+				// Pull relevant data from the team to create a label
+				const label =
+					typeof obj === "object" ? `${obj.league} ${obj.number}` : obj;
+
+				// Convert date strings to Date objects
+				responseObj[label] = signInDatesByTeam[id].map((node) => ({
+					date: new Date(node.date),
+					count: node.count,
+				}));
+			}
+
+			// Send the response
+			res.status(200).send(responseObj);
+		},
+	});
 }

lib/dev/FakeData.ts

@@ -55,6 +55,7 @@ export async function fakeUser(
 		"",
 		10,
 	);
+	user.lastSignInDateTime = new Date();
 	return await db.addObject(CollectionId.Users, user);
 }