started on dynamic event view

src/lib/server/cacheManager.ts

@@ -0,0 +1,24 @@
+import * as database from './databaseManager.ts';
+import { globalEmitter } from './databaseManager.ts';
+
+// TODO Implement caching of info at some point
+// structure:
+// databaseManager gets raw data from backend
+// stored in variables in cacheManager
+// sent to frontend using same function names in dataManager (not made)
+
+let teamsCache;
+
+export async function updateTeamsCache() {
+	teamsCache = database.getTeams();
+}
+
+globalEmitter.on('invalTeamsCache', updateTeamsCache);
+
+let eventsCache;
+
+export async function updateEventsCache() {
+	eventsCache = database.getRegisteredEvents();
+}
+
+globalEmitter.on('invalEventsCache', updateEventsCache);

src/lib/server/databaseManager.ts

@@ -43,15 +43,21 @@ export async function getTeams() {
 }
 
 // Get all registered events from database
-export async function getRegisteredEvents() {
+export async function getRegisteredEvents(eventId?: number) {
-	const allEvents = await db.select().from(schema.registeredEventsView);
+	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
+			completed: events.timeCompleted || 0,
+			resultPreset: events.resultPreset
 		}))
 	};
 }
@@ -61,6 +67,7 @@ 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,
@@ -90,3 +97,60 @@ export async function getAllBrackets() {
 		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;
+}

src/lib/server/db/schema.ts

@@ -130,11 +130,12 @@ export const registeredEventsView = sqliteView('registeredEventsView').as((qb) =
 			eventName: eventTypes.name,
 			division: divisions.name,
 			state: registeredEvents.state,
-			timeCompleted: registeredEvents.timeCompleted
+			timeCompleted: registeredEvents.timeCompleted,
+			resultPreset: eventTypes.resultPreset
 		})
 		.from(registeredEvents)
 		.innerJoin(eventTypes, eq(registeredEvents.eventType, eventTypes.id))
-		.innerJoin(divisions, eq(registeredEvents.division, divisions.id));
+		.innerJoin(divisions, eq(registeredEvents.division, divisions.id))
 });
 
 export const registeredEventPlayersView = sqliteView('registeredEventPlayersView').as((qb) => {

src/routes/+page.server.ts

@@ -1,4 +1,4 @@
-import { getAllInitialInfo } from '$lib/server/eventManager';
+import { getAllInitialInfo } from '$lib/server/databaseManager';
 
 // Literally only here so that the frontend has the right structure
 export const load = async () => {

src/routes/api/registeredEvents/+server.ts

@@ -1,55 +1,21 @@
 import {
 	globalEmitter,
 	getRegisteredEvents,
-	getAllRegisteredEventPlayers,
+	getRegisteredEventsWithPlayers
-	getAllBrackets
+} from '$lib/server/databaseManager';
-} from '$lib/server/eventManager';
 import { generateEndpoint } from '$lib/server/endpoint';
 
 export async function GET() {
 	// Generate stream endpoint
 	const endpoint = generateEndpoint(async (enqueue) => {
-		const eventList = async () => {
+		// Get the all the events with the players seperated into brackets
-			// Get updated events from database
+		let eventList = async () => {
-			let newEvents = await getRegisteredEvents();
+			let newEventList = await getRegisteredEventsWithPlayers();
-			let registeredEventList = newEvents['events'];
+			enqueue(newEventList);
-
-			// 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 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 to the event object
-				let eventWithPlayers = {
-					...event,
-					registeredPlayers: bracketOrder
-				};
-				// combine all of the events into one array
-				fullEventList.push(eventWithPlayers);
-			}
-			// Send to client
-			enqueue(fullEventList);
 		};
 
-		// Initial Sync
+		// Send the eventList to the client when a connection is made
+		// TODO make it so that this only happens on an initial post request
 		eventList();
 		globalEmitter.on('eventUpdate', eventList);
 
@@ -60,3 +26,12 @@ export async function GET() {
 	});
 	return (await endpoint).response;
 }
+
+export async function POST({ request }: any) {
+	let responseBody = await request.json();
+	let eventRequested = responseBody.eventId;
+
+	let eventList = await getRegisteredEventsWithPlayers(eventRequested);
+
+	return new Response(JSON.stringify(eventList));
+}

src/routes/api/registeredPlayers/+server.ts

@@ -1,4 +1,4 @@
-import { globalEmitter, getAllRegisteredEventPlayers } from '$lib/server/eventManager';
+import { globalEmitter, getAllRegisteredEventPlayers } from '$lib/server/databaseManager';
 import { generateEndpoint } from '$lib/server/endpoint';
 
 // Expose post request

src/routes/api/teams/+server.ts

@@ -1,4 +1,4 @@
-import { globalEmitter, getTeams } from '$lib/server/eventManager';
+import { globalEmitter, getTeams } from '$lib/server/databaseManager';
 import { generateEndpoint } from '$lib/server/endpoint';
 
 // Expose post request

src/routes/event/[eventId]/+page.svelte

@@ -0,0 +1,40 @@
+<script lang="ts">
+	import { onMount, onDestroy } from 'svelte';
+	import type { PageProps } from './$types';
+	let { params }: PageProps = $props();
+
+	let eventId = params.eventId;
+
+	let eventEndpoint: EventSource;
+
+	async function getEventData() {
+		let response = await fetch('/api/registeredEvents', {
+			method: 'POST',
+			body: JSON.stringify({
+				eventId: eventId
+			}),
+			headers: {
+				'Content-type': 'application/json; charset=UTF-8'
+			}
+		});
+		return response.json();
+	}
+
+	let eventDataPromise = getEventData();
+
+	onMount(() => {
+		eventEndpoint = new EventSource('/api/registeredEvents');
+
+		// eventEndpoint.onmessage = (e) => {
+		// 	const eventData = JSON.parse(e.data);
+		// 	console.log(eventData);
+		// };
+	});
+</script>
+
+{#await eventDataPromise}
+	<div>loading</div>
+{:then eventData}
+	{@const event = eventData[0]}
+	<div>{console.log(event)} {event.name}</div>
+{/await}