feature(events): extended event list to support directories, save events by their id

This commit adds the ability to add events sorted by directories generated by
https://github.com/Malex14/hio_timetable_extractor. Each directory consists of a name
and potentially containing events and/or subdirectories. Events are stored in the
userconfig by their id. The event's name is now being saved in the corresponding
eventDetails. The filter functionality has been updated to support directories as well.

Author: Malex14

source/lib/all-events.ts

@@ -1,40 +1,120 @@
 import {readFile} from 'node:fs/promises';
+import type {EventDirectory, EventDirectoryEvent} 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;
+async function getAll(): Promise<EventDirectory[]> {
+	const data = await readFile('eventfiles/directory.json', 'utf8');
+	return JSON.parse(data) as EventDirectory[];
 }
 
 export async function count(): Promise<number> {
-	const allEvents = await getAll();
+	const allEvents = (await find('', [], []));
 	return allEvents.length;
 }
 
-export async function exists(name: string): Promise<boolean> {
-	const allEvents = await getAll();
-	return allEvents.includes(name);
+export async function exists(id: string): Promise<EventDirectoryEvent | undefined> {
+	const allDirectories = await getAll();
+
+	function traverse(directory: EventDirectory): EventDirectoryEvent | undefined {
+		const event = directory.Events?.find(event => event.Id === id);
+		if (event !== undefined) {
+			return event;
+		}
+
+		for (const subDirectory of directory.SubDirectories ?? []) {
+			const eventInSubdirectory = traverse(subDirectory);
+			if (eventInSubdirectory !== undefined) {
+				return eventInSubdirectory;
+			}
+		}
+
+		return undefined;
+	}
+
+	for (const subDirectory of allDirectories) {
+		const event = traverse(subDirectory);
+		if (event !== undefined) {
+			return event;
+		}
+	}
+
+	return undefined;
 }
 
-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);
+export async function nonExisting(ids: readonly string[]): Promise<string[]> {
+	const allEvents = await getAll();
+	const result = [...ids];
+
+	function traverse(directory: EventDirectory) {
+		for (const event of directory.Events ?? []) {
+                        const eventId = event.Id;
+                        if (result.includes(eventId)) {
+                                result.splice(result.indexOf(eventId), 1);
+                        }
+                }
+
+		for (const subDirectory of directory.SubDirectories ?? []) {
+			traverse(subDirectory);
 		}
 	}
 
+	for (const directory of allEvents) {
+		traverse(directory);
+	}
+
 	return result;
 }
 
 export async function find(
+	pattern: string | RegExp | undefined,
+	ignoreIds: readonly string[] = [],
+	startAt: number[] = [],
+): Promise<ReadonlyArray<EventDirectoryEvent | [EventDirectory, number[]]>> {
+	if (pattern !== undefined) {
+		const accumulator: EventDirectoryEvent[] = [];
+		await _find(pattern, ignoreIds, await resolvePath(startAt), accumulator);
+		return [...new Set(accumulator)].sort((a, b) =>
+			a.Name.localeCompare(b.Name));
+	}
+
+	const dir = await resolvePath(startAt);
+
+	return [
+		...(dir.SubDirectories ?? []).map((dir, i) => [dir, [...startAt, i]] as [EventDirectory, number[]]),
+		...(dir.Events ?? []).filter(event => !ignoreIds.includes(event.Id)),
+	];
+}
+
+async function _find(
 	pattern: string | RegExp,
-	ignore: readonly string[] = [],
-): Promise<readonly string[]> {
-	const allEvents = await getAll();
-	const regex = new RegExp(pattern, 'i');
-	const filtered = allEvents.filter(event =>
-		regex.test(event) && !ignore.includes(event));
-	return filtered;
+	ignoreIds: readonly string[],
+	startAt: EventDirectory,
+	accumulator: EventDirectoryEvent[],
+) {
+	if (startAt?.Events !== undefined) {
+		const regex = new RegExp(pattern, 'i');
+		accumulator.push(...startAt?.Events
+			.filter(event => regex.test(event.Name) && !ignoreIds.includes(event.Id)) ?? []);
+	}
+
+	await Promise.all(startAt.SubDirectories
+		?.map(async subDirectory => _find(pattern, ignoreIds, subDirectory, accumulator))
+		?? []);
+}
+
+export async function resolvePath(path: number[]): Promise<EventDirectory> {
+	let Name = 'HAW Hamburg';
+	let Events: EventDirectoryEvent[] | undefined;
+	let SubDirectories: EventDirectory[] | undefined = await getAll();
+
+	for (const part of path) {
+		if (SubDirectories === undefined || SubDirectories.length <= part) {
+			throw new Error('Ungültiger Pfad');
+		}
+
+		Name = SubDirectories[part]!.Name;
+		Events = SubDirectories[part]!.Events;
+		SubDirectories = SubDirectories[part]!.SubDirectories;
+	}
+
+	return {Name, SubDirectories, Events};
 }

source/lib/calendar-helper.ts

@@ -15,6 +15,15 @@ export function getUrlFromContext(ctx: MyContext): string {
 	return getUrl(ctx.from!.id, ctx.userconfig.mine);
 }
 
+export function getEventNameFromContext(ctx: MyContext, eventId: string): string {
+	const name = ctx.userconfig.mine.events[eventId]?.name;
+	if (name === undefined) {
+		throw new Error('Konnte Veranstaltungsnamen nicht finden');
+	}
+
+	return name;
+}
+
 export function formatDateToHumanReadable(isoDateString: string): string {
 	const date = new Date(Date.parse(isoDateString + 'Z'));
 	return date.toLocaleString('de-DE', {

source/lib/change-helper.ts

@@ -2,12 +2,14 @@ import {readFile} from 'node:fs/promises';
 import {html as format} from 'telegram-format';
 import {
 	formatDateToHumanReadable,
+	getEventNameFromContext,
 	parseDateTimeToDate,
 } from './calendar-helper.ts';
 import type {
 	Change,
 	EventEntryFileContent,
 	EventEntryInternal,
+	MyContext,
 } from './types.ts';
 
 export function generateChangeDescription(change: Change): string {
@@ -35,8 +37,8 @@ export function generateChangeDescription(change: Change): string {
 	return text;
 }
 
-export function generateChangeText(change: Change): string {
-	let text = generateChangeTextHeader(change);
+export function generateChangeText(ctx: MyContext, change: Change): string {
+	let text = generateChangeTextHeader(ctx, change);
 
 	if (Object.keys(change).length > 2) {
 		text += '\nÄnderungen:\n';
@@ -46,11 +48,11 @@ export function generateChangeText(change: Change): string {
 	return text;
 }
 
-export function generateChangeTextHeader(change: Change): string {
+export function generateChangeTextHeader(ctx: MyContext, change: Change): string {
 	let text = '';
 	text += format.bold('Veranstaltungsänderung');
 	text += '\n';
-	text += format.bold(format.escape(change.name));
+	text += format.bold(format.escape(getEventNameFromContext(ctx, change.eventId)));
 	if (change.date) {
 		text += ` ${formatDateToHumanReadable(change.date)}`;
 	}
@@ -59,14 +61,13 @@ export function generateChangeTextHeader(change: Change): string {
 	return text;
 }
 
-export function generateShortChangeText(change: Change): string {
-	return `${change.name} ${formatDateToHumanReadable(change.date)}`;
+export function generateShortChangeText(ctx: MyContext, change: Change): string {
+	return `${getEventNameFromContext(ctx, change.eventId)} ${formatDateToHumanReadable(change.date)}`;
 }
 
-export async function loadEvents(eventname: string): Promise<EventEntryInternal[]> {
+export async function loadEvents(eventId: string): Promise<EventEntryInternal[]> {
 	try {
-		const filename = eventname.replaceAll('/', '-');
-		const content = await readFile(`eventfiles/${filename}.json`, 'utf8');
+		const content = await readFile(`eventfiles/${eventId}.json`, 'utf8');
 		const array = JSON.parse(content) as EventEntryFileContent[];
 		const parsed = array.map((o): EventEntryInternal => ({
 			...o,

source/lib/inline-menu-filter.ts

@@ -2,7 +2,7 @@ export const DEFAULT_FILTER = '.+';
 
 export function filterButtonText<T>(getCurrentFilterFunction: (ctx: T) => string | undefined): (ctx: T) => string {
 	return ctx => {
-		let text = '🔎 Filter';
+		let text = '🔎 Ab hier filtern';
 		const currentFilter = getCurrentFilterFunction(ctx);
 		if (currentFilter && currentFilter !== '.+') {
 			text += ': ' + currentFilter;

source/lib/types.ts

@@ -19,6 +19,7 @@ export type Session = {
 	adminuserquicklook?: number; // User ID
 	adminuserquicklookfilter?: string;
 	eventfilter?: string;
+	eventPath?: number[]; // Path to the selected subdirectory
 	generateChange?: Partial<Change>;
 	page?: number;
 	privacySection?: 'telegram' | 'persistent' | 'tmp';
@@ -44,13 +45,14 @@ export type Userconfig = {
 export type RemovedEventsDisplayStyle = 'cancelled' | 'removed' | 'emoji';
 
 export type EventDetails = {
+	name: string;
 	alertMinutesBefore?: number;
 	notes?: string;
 };
 
 export type Change = {
 	add?: true;
-	name: string;
+	eventId: string;
 	date: string;
 	remove?: true;
 	namesuffix?: string;
@@ -83,7 +85,19 @@ export type MensaSettings = MealWishes & {
 	showAdditives?: boolean;
 };
 
+export type EventDirectory = {
+	readonly Name: string;
+	readonly SubDirectories: EventDirectory[] | undefined;
+	readonly Events: EventDirectoryEvent[] | undefined;
+};
+
+export type EventDirectoryEvent = {
+	readonly Id: string;
+	readonly Name: string;
+};
+
 export type EventEntryFileContent = {
+	readonly Id: string;
 	readonly Name: string;
 	readonly Location: string;
 	readonly Description: string;
@@ -92,6 +106,7 @@ export type EventEntryFileContent = {
 };
 
 export type EventEntryInternal = {
+	readonly Id: string;
 	readonly Name: string;
 	readonly Location: string;
 	readonly Description: string;