moved eventManager to databaseManager and started prep for caching

src/lib/server/databaseManager.ts

@@ -0,0 +1,156 @@
+import { EventEmitter } from 'node:events';
+import { db } from '$lib/server/db';
+import { eq } from 'drizzle-orm';
+import * as schema from '$lib/server/db/schema';
+
+// Emitter that emits
+export const globalEmitter = new EventEmitter();
+
+//// REFERENCE CODE
+// Increment score for testing (remove ts)
+// const increment = () => {
+// 	testScore++;
+// 	console.log('score incremented', testScore);
+// 	globalEmitter.emit('scoreUpdate');
+// };
+// Increment scores when there is an emit
+// globalEmitter.on('incrementScores', increment);
+
+// For page.server.ts so that it doesnt look weird before loading
+export async function getAllInitialInfo() {
+	return {
+		teams: await getTeams(),
+		events: await getRegisteredEvents()
+	};
+}
+
+// Get teams object from database
+export async function getTeams() {
+	const allTeams = await db.select().from(schema.teamScoresView);
+	for (let team in allTeams) {
+		let currentTeam = allTeams[team];
+		if (!currentTeam.totalPoints) {
+			currentTeam.totalPoints = 0;
+		}
+	}
+	return {
+		teams: allTeams.map((team) => ({
+			name: team.teamName,
+			color: team.teamColor,
+			points: team.totalPoints
+		}))
+	};
+}
+
+// Get all registered events from database
+export async function getRegisteredEvents(eventId?: number) {
+	console.log('eventId: ', eventId);
+	const allEvents = await db
+		.select()
+		.from(schema.registeredEventsView)
+		// If event id specified, get that event, otherwise get all events
+		.where(eventId ? eq(schema.registeredEventsView.eventId, eventId) : undefined);
+	return {
+		events: allEvents.map((events) => ({
+			id: events.eventId,
+			name: events.eventName,
+			division: events.division,
+			state: events.state,
+			completed: events.timeCompleted || 0,
+			resultPreset: events.resultPreset
+		}))
+	};
+}
+
+// Get all players with an event id specified
+export async function getAllRegisteredEventPlayers(eventId: number) {
+	const eventPlayers = await db
+		.select()
+		.from(schema.registeredEventPlayersView)
+		// where the registered player is registered for that event
+		.where(eq(schema.registeredEventPlayersView.eventId, eventId))
+		.orderBy(
+			schema.registeredEventPlayersView.bracket,
+			schema.registeredEventPlayersView.placement,
+			schema.registeredEventPlayersView.teamName
+		);
+	return {
+		eventPlayers: eventPlayers.map((players) => ({
+			id: players.playerId,
+			firstName: players.firstName,
+			lastName: players.lastName,
+			placement: players.placement,
+			bracket: players.bracket,
+			eventId: players.eventId,
+			eventName: players.eventName,
+			teamId: players.teamId,
+			teamName: players.teamName,
+			teamColor: players.teamColor
+		}))
+	};
+}
+
+export async function getAllBrackets() {
+	const brackets = await db.select().from(schema.brackets);
+
+	return {
+		brackets: brackets
+	};
+}
+
+export async function getResultPreset(presetId: number) {
+	const resultPresets = await db
+		.select()
+		.from(schema.resultPresets)
+		.where(eq(schema.resultPresets.id, presetId));
+
+	return {
+		resultPresets: resultPresets
+	};
+}
+
+// Moved the function the registeredEvents endpoint
+// Just merges the results of the previous 3 functions into a standard format
+export async function getRegisteredEventsWithPlayers(eventId?: number) {
+	// Get updated events from database
+	let newEvents = await getRegisteredEvents(eventId);
+	let registeredEventList = newEvents['events'];
+
+	// Get all possible brackets from the database
+	let brackets = await getAllBrackets();
+
+	// Initilise the final eventList
+	let fullEventList: any[] = [];
+
+	// For every event
+	for (let registeredEvent in registeredEventList) {
+		let event = registeredEventList[registeredEvent];
+
+		// Get the info about the result preset for the ui
+		let resultPreset = await getResultPreset(event.resultPreset);
+
+		// Get all players for the event
+		let registeredPlayers = await getAllRegisteredEventPlayers(event.id);
+
+		// Map the players into an [] with structure {id: number, name: string, items: any[]}
+		// So that the players are sorted by bracket for the frontend
+		const bracketOrder = brackets.brackets.map((category) => {
+			return {
+				...category,
+				// Filter the items that match the current bracket name
+				items: registeredPlayers.eventPlayers.filter((item) => item.bracket === category.name)
+			};
+		});
+
+		// append the player info and result preset to the event object
+		let eventWithPlayers = {
+			...event,
+			registeredPlayers: bracketOrder,
+			...resultPreset
+		};
+		// combine all of the events into one array
+		fullEventList.push(eventWithPlayers);
+	}
+	// Send to client
+	return fullEventList;
+}