Orderunterstützung für Veranstaltungsauswahl, Integration von myHAW Scraper

init-debug-environment.sh

@@ -2,7 +2,7 @@
 set -e
 
 # assumes other repos were cloned next to this repo (and executed)
-ln -rfs ../downloader/eventfiles .
+ln -rfs ../eventfiles .
 ln -rfs ../mensa-data .
 
 mkdir -p userconfig

source/lib/all-events.ts

@@ -1,40 +1,113 @@
 import {readFile} from 'node:fs/promises';
+import {pull} from './git.ts';
+import {typedEntries} from './javascript-helper.ts';
+import type {EventDirectory, EventEntry, EventId} from './types.ts';
 
-async function getAll(): Promise<string[]> {
-	const data = await readFile('eventfiles/all.txt', 'utf8');
-	const list = data.split('\n').filter(element => element !== '');
-	return list;
-}
+let directory: EventDirectory = {};
+let namesOfEvents: Readonly<Record<EventId, string>> = {};
+
+setInterval(async () => update(), 1000 * 60 * 30); // Every 30 minutes
+await update();
+console.log(new Date(), 'eventfiles loaded');
 
-export async function count(): Promise<number> {
-	const allEvents = await getAll();
-	return allEvents.length;
+async function update() {
+	await pull(
+		'eventfiles',
+		'https://github.com/HAWHHCalendarBot/eventfiles.git',
+	);
+	const directoryString = await readFile('eventfiles/directory.json', 'utf8');
+	directory = JSON.parse(directoryString) as EventDirectory;
+	namesOfEvents = await generateMapping();
 }
 
-export async function exists(name: string): Promise<boolean> {
-	const allEvents = await getAll();
-	return allEvents.includes(name);
+async function generateMapping(): Promise<Readonly<Record<EventId, string>>> {
+	const namesOfEvents: Record<EventId, string> = {};
+
+	function collect(directory: EventDirectory) {
+		for (const subDirectory of Object.values(directory.subDirectories ?? {})) {
+			collect(subDirectory);
+		}
+
+		Object.assign(namesOfEvents, directory.events ?? {});
+	}
+
+	collect(directory);
+	return namesOfEvents;
 }
 
-export async function nonExisting(names: readonly string[]): Promise<string[]> {
-	const allEvents = new Set(await getAll());
-	const result: string[] = [];
-	for (const event of names) {
-		if (!allEvents.has(event)) {
-			result.push(event);
+function getSubdirectory(path: string[]): EventDirectory | undefined {
+	let resolvedDirectory = directory;
+
+	for (const part of path) {
+		const subDirectory = resolvedDirectory.subDirectories?.[part];
+		if (subDirectory === undefined) {
+			return undefined;
 		}
+
+		resolvedDirectory = subDirectory;
+	}
+
+	return resolvedDirectory;
+}
+
+export function directoryHasContent(directory: EventDirectory): boolean {
+	const events = Object.keys(directory.events ?? {}).length;
+	const subDirectories = Object.keys(directory.subDirectories ?? {}).length;
+	return events > 0 || subDirectories > 0;
+}
+
+export function directoryExists(path: string[]): boolean {
+	if (path.length === 0) {
+		// Toplevel always exists
+		return true;
 	}
 
-	return result;
+	const directory = getSubdirectory(path);
+	return Boolean(directory && directoryHasContent(directory));
 }
 
-export async function find(
-	pattern: string | RegExp,
-	ignore: readonly string[] = [],
-): Promise<readonly string[]> {
-	const allEvents = await getAll();
+export function getEventName(id: EventId): string {
+	return namesOfEvents[id] ?? id;
+}
+
+export function count(): number {
+	return Object.keys(namesOfEvents).length;
+}
+
+export function exists(id: EventId): boolean {
+	return id in namesOfEvents;
+}
+
+export function find(
+	path: string[],
+	pattern: string | RegExp | undefined,
+): EventDirectory {
+	if (!pattern) {
+		return getSubdirectory(path) ?? {};
+	}
+
 	const regex = new RegExp(pattern, 'i');
-	const filtered = allEvents.filter(event =>
-		regex.test(event) && !ignore.includes(event));
-	return filtered;
+	const accumulator: Record<EventId, string> = {};
+
+	function collect(directory: EventDirectory) {
+		for (const [eventId, name] of typedEntries(directory.events ?? {})) {
+			if (regex.test(name)) {
+				accumulator[eventId] = name;
+			}
+		}
+
+		for (const subDirectory of Object.values(directory.subDirectories ?? {})) {
+			collect(subDirectory);
+		}
+	}
+
+	collect(getSubdirectory(path) ?? {});
+	return {
+		events: Object.fromEntries(typedEntries(accumulator).sort((a, b) => a[1].localeCompare(b[1]))),
+	};
+}
+
+export async function loadEvents(eventId: EventId): Promise<EventEntry[]> {
+	const content = await readFile(`eventfiles/events/${eventId}.json`, 'utf8');
+	return JSON.parse(content) as EventEntry[];
 }

source/lib/change-helper.ts

@@ -1,6 +1,6 @@
-import {readFile} from 'node:fs/promises';
 import {html as format} from 'telegram-format';
-import type {Change, EventEntry, NaiveDateTime} from './types.ts';
+import {getEventName} from './all-events.ts';
+import type {Change, EventId, NaiveDateTime} from './types.ts';
 
 export function generateChangeDescription(change: Change): string {
 	let text = '';
@@ -28,11 +28,11 @@ export function generateChangeDescription(change: Change): string {
 }
 
 export function generateChangeText(
-	name: string,
+	eventId: EventId,
 	date: NaiveDateTime | undefined,
 	change: Change,
 ): string {
-	let text = generateChangeTextHeader(name, date);
+	let text = generateChangeTextHeader(eventId, date);
 
 	if (Object.keys(change).length > 0) {
 		text += '\nÄnderungen:\n';
@@ -43,13 +43,13 @@ export function generateChangeText(
 }
 
 export function generateChangeTextHeader(
-	name: string,
+	eventId: EventId,
 	date: NaiveDateTime | undefined,
 ): string {
 	let text = '';
 	text += format.bold('Veranstaltungsänderung');
 	text += '\n';
-	text += format.bold(format.escape(name));
+	text += format.bold(format.escape(getEventName(eventId)));
 	if (date) {
 		text += ` ${date}`;
 	}
@@ -59,19 +59,8 @@ export function generateChangeTextHeader(
 }
 
 export function generateShortChangeText(
-	name: string,
+	eventId: EventId,
 	date: NaiveDateTime,
 ): string {
-	return `${name} ${date}`;
-}
-
-export async function loadEvents(eventname: string): Promise<EventEntry[]> {
-	try {
-		const filename = eventname.replaceAll('/', '-');
-		const content = await readFile(`eventfiles/${filename}.json`, 'utf8');
-		return JSON.parse(content) as EventEntry[];
-	} catch (error) {
-		console.error('ERROR while loading events for change date picker', error);
-		return [];
-	}
+	return `${getEventName(eventId)} ${date}`;
 }

source/lib/git.ts

@@ -0,0 +1,16 @@
+import {exec} from 'node:child_process';
+import {existsSync} from 'node:fs';
+import {promisify} from 'node:util';
+
+const run = promisify(exec);
+
+export async function pull(
+	directory: string,
+	remoteUrl: string,
+): Promise<void> {
+	try {
+		await (existsSync(`${directory}/.git`)
+			? run(`git -C ${directory} pull`)
+			: run(`git clone -q --depth 1 ${remoteUrl} ${directory}`));
+	} catch {}
+}

source/lib/javascript-helper.ts

@@ -0,0 +1,11 @@
+export function typedKeys<K extends keyof any>(record: Readonly<Partial<Record<K, unknown>>>): K[] {
+	return Object.keys(record) as K[];
+}
+
+export function typedEntries<K extends keyof any, V>(record: Readonly<Partial<Record<K, V>>>): Array<[K, V]> {
+	if (!record) {
+		return [];
+	}
+
+	return (Object.entries(record) as unknown[]) as Array<[K, V]>;
+}

source/lib/mensa-helper.ts

@@ -1,4 +1,5 @@
 import {arrayFilterUnique} from 'array-filter-unique';
+import {typedEntries} from './javascript-helper.ts';
 import type {Meal} from './meal.ts';
 import type {MealWishes, MensaPriceClass, MensaSettings} from './types.ts';
 
@@ -74,7 +75,7 @@ export function mealNameToHtml(
 export function mealAdditivesToHtml(meals: readonly Meal[]): string {
 	return meals
 		.flatMap(meal =>
-			Object.entries(meal.Additives).map(([short, full]) => `${short}: ${full}`))
+			typedEntries(meal.Additives).map(([short, full]) => `${short}: ${full}`))
 		.sort()
 		.filter(arrayFilterUnique())
 		.join('\n');

source/lib/mensa-meals.ts

@@ -1,6 +1,18 @@
 import {readdir, readFile} from 'node:fs/promises';
+import {pull} from './git.ts';
 import type {Meal} from './meal.ts';
 
+setInterval(async () => pullMensaData(), 1000 * 60 * 30); // Every 30 minutes
+await pullMensaData();
+console.log(new Date(), 'mensa-data loaded');
+
+async function pullMensaData(): Promise<void> {
+	await pull(
+		'mensa-data',
+		'https://github.com/HAWHHCalendarBot/mensa-data.git',
+	);
+}
+
 export async function getCanteenList(): Promise<string[]> {
 	const found = await readdir('mensa-data', {withFileTypes: true});
 	const dirs = found

source/lib/types.ts

@@ -19,11 +19,17 @@ export type MyContext =
 	& ContextFlavour;
 
 export type Session = {
-	adminBroadcast?: number; // Message ID
-	adminuserquicklook?: number; // User ID
+	/** Message ID */
+	adminBroadcast?: number;
+	/** User ID */
+	adminuserquicklook?: number;
 	adminuserquicklookfilter?: string;
-	eventfilter?: string;
-	generateChangeName?: string;
+	eventAdd?: {
+		filter?: string;
+		/** Currently selected subdirectory */
+		path: string[];
+	};
+	generateChangeEventId?: EventId;
 	generateChangeDate?: NaiveDateTime;
 	generateChange?: Change;
 	page?: number;
@@ -37,7 +43,7 @@ export type Session = {
 export type Userconfig = {
 	readonly admin?: true;
 	calendarfileSuffix: string;
-	events: Record<string, EventDetails>;
+	events: Record<EventId, EventDetails>;
 	mensa: MensaSettings;
 	removedEvents?: RemovedEventsDisplayStyle;
 };
@@ -82,6 +88,15 @@ export type MensaSettings = MealWishes & {
 	showAdditives?: boolean;
 };
 
+export type EventId = `${number}_${number | string}`;
+
+export type EventDirectory = {
+	/** Maps the directory name to its content */
+	readonly subDirectories?: Readonly<Record<string, EventDirectory>>;
+	/** Maps `EventId` to the human-readable name */
+	readonly events?: Readonly<Record<EventId, string>>;
+};
+
 export type EventEntry = {
 	readonly name: string;
 	readonly location: string;

source/menu/about.ts

@@ -10,7 +10,7 @@ export const menu = new MenuTemplate<MyContext>(async ctx => {
 
 	const canteens = await getCanteenList();
 	const canteenCount = canteens.length;
-	const eventCount = await allEvents.count();
+	const eventCount = allEvents.count();
 
 	const websiteLink = format.url(
 		'hawhh.de/calendarbot/',

source/menu/admin/user-quicklook.ts

@@ -110,7 +110,7 @@ menu.select('u', {
 		return Object.fromEntries(allChats.map(chat => [chat.id, nameOfUser(chat)]));
 	},
 	isSet: (ctx, selected) => ctx.session.adminuserquicklook === Number(selected),
-	async set(ctx, selected) {
+	set(ctx, selected) {
 		ctx.session.adminuserquicklook = Number(selected);
 		return true;
 	},