Update

.env.template

@@ -14,3 +14,5 @@ API_KEYS=ADDUIDSYOUWANTTOUSEASAPIKEYS_AS_A_COMMA_SEPERATED_LIST
 MONGODB_PORT=26182
 MONGODB_USER=recapp
 MONGODB_PW=YOURMONGOPW
+
+JWT_SECRET=YOURJWTSECRET

packages/backend/src/actors/FingerprintStore.ts

@@ -0,0 +1,136 @@
+import { Timestamp, Unit, toTimestamp, unit } from "itu-utils";
+import { ActorRef, ActorSystem } from "ts-actors";
+import { create } from "mutative";
+import { ActorUri, Fingerprint, FingerprintStoreMessage, FingerprintStoreMessages, FingerprintUpdateMessage, Id, User, UserStoreMessage, UserStoreMessages } from "@recapp/models";
+import { identity, pick } from "rambda";
+import { CollecionSubscription, SubscribableActor } from "./SubscribableActor";
+
+type FingerprintStoreResult = Unit | Error | Fingerprint | boolean;
+
+type FingerprintStoreState = {
+	cache: Map<Id, Fingerprint>;
+	lastTouched: Map<Id, Timestamp>;
+	subscribers: Map<Id, Set<ActorUri>>;
+	collectionSubscribers: Map<ActorUri, CollecionSubscription>;
+	lastSeen: Map<ActorUri, Timestamp>;
+};
+
+export class FingerprintStore extends SubscribableActor<Fingerprint, FingerprintStoreMessage, FingerprintStoreResult> {
+	protected override state: FingerprintStoreState = { cache: new Map(), lastTouched: new Map(), subscribers: new Map(), collectionSubscribers: new Map(), lastSeen: new Map() };
+
+	public constructor(name: string, system: ActorSystem) {
+		super(name, system, "fingerprints");
+	}
+
+	protected override updateIndices(_draft: FingerprintStoreState, _entity: Fingerprint): void {
+		// No index needed for fingerprints
+	}
+
+	private updateSubscribers(fingerprint: Partial<Fingerprint> & { uid : Id }) {
+		for (const [subscriber, subscription] of this.state.collectionSubscribers) {
+			this.send(
+				subscriber,
+				new FingerprintUpdateMessage(
+					subscription.properties.length > 0
+						? pick(subscription.properties, fingerprint)
+						: fingerprint
+				)
+			);
+		}
+		for (const subscriber of this.state.subscribers.get(fingerprint.uid) ?? new Set()) {
+			this.send(subscriber, new FingerprintUpdateMessage(fingerprint));
+		}
+	}
+
+	public async receive(from: ActorRef, message: FingerprintStoreMessage): Promise<FingerprintStoreResult> {
+		const [clientUserRole, clientUserId] = await this.determineRole(from);
+		if (!["ADMIN", "SYSTEM"].includes(clientUserRole)) {
+			return new Error(`Operation not allowed`);
+		}
+		const result = await FingerprintStoreMessages.match<Promise<FingerprintStoreResult>>(message, {
+			StoreFingerprint: async fingerprint => {
+				this.state = await create(this.state, async draft => {
+					const currentFingerprint = (await this.getEntity(fingerprint.uid)).orElse({} as Fingerprint);
+					fingerprint.updated = toTimestamp();
+					const newFingerprint = { ...currentFingerprint, ...fingerprint };
+					draft.cache.set(fingerprint.uid, newFingerprint);
+					console.debug("SToring new fingerprint", newFingerprint);
+					this.storeEntity(newFingerprint);
+				});
+				return unit();
+			},
+			Get: async id => {
+				const result = await this.getEntity(id);
+				const retVal = result.match<Error | Fingerprint>(identity, () => new Error(`Unknown fingerprint id ${id}`));
+				return Promise.resolve(retVal)
+			},
+			Block: async id => {
+				const mbFingerprint = await this.getEntity(id)
+				const {uid} = await this.ask<UserStoreMessage, User>("actors://recapp-backend/UserStore", UserStoreMessages.GetByFingerprint(id));
+				return mbFingerprint.match<Unit|Error>(
+					fp => {
+						this.storeEntity({...fp, blocked: true});
+						this.updateSubscribers({...fp, blocked: true})
+						if (uid)
+							this.send("actors://recapp-backend/UserStore", UserStoreMessages.Update({ uid: fp.uid, active: false }));
+						return unit();
+					},
+					() => {
+						return new Error(`Unknown fingerprint id ${id}`);
+					}
+				)
+			},
+			Unblock: async id => {
+				const mbFingerprint = await this.getEntity(id)
+				const {uid} = await this.ask<UserStoreMessage, User>("actors://recapp-backend/UserStore", UserStoreMessages.GetByFingerprint(id));
+				return mbFingerprint.match<Unit|Error>(
+					fp => {
+						this.storeEntity({...fp, blocked: false});
+						this.updateSubscribers({...fp, blocked: false})
+						if (uid)
+							this.send("actors://recapp-backend/UserStore", UserStoreMessages.Update({ uid: fp.uid, active: true }));
+						return unit();
+					},
+					() => {
+						return new Error(`Unknown fingerprint id ${id}`);
+					}
+				)
+			},
+			IncreaseCount: async ({fingerprint, userUid, initialQuiz}) => {
+				const mbFingerprint = await this.getEntity(fingerprint)
+				return mbFingerprint.match<Unit|Error>(
+					fp => {
+						this.storeEntity({...fp, usageCount: fp.usageCount + 1, lastSeen: toTimestamp(), userUid, initialQuiz: initialQuiz ?? fp.initialQuiz});
+						this.updateSubscribers({...fp, usageCount: fp.usageCount + 1, lastSeen: toTimestamp(), userUid, initialQuiz: initialQuiz ?? fp.initialQuiz})
+						return unit();
+					},
+					() => {
+						return new Error(`Unknown fingerprint id ${fingerprint}`);
+					}
+				)
+			},
+			GetMostRecent: async () => {
+				const db = await this.connector.db();
+				const fps = await db.collection<Fingerprint>(this.collectionName).find({}).sort({lastSeen: 1}).limit(100).toArray();
+				fps.forEach(fp => {
+					const { _id, ...rest } = fp;
+					this.send(from, new FingerprintUpdateMessage(rest));
+				});
+				return unit();
+			},
+			SubscribeToCollection: async () => {
+				this.state = create(this.state, draft => {
+					draft.lastSeen.set(from.name as ActorUri, toTimestamp());
+					draft.collectionSubscribers.set(from.name as ActorUri, {
+						properties: [],
+						userId: clientUserId,
+						userRole: clientUserRole,
+					});
+				});
+				return unit();
+			},
+			default: async () => new Error(`Unknown message from ${from.name}: ${JSON.stringify(message, undefined, 2)}`),
+		});
+		return result;
+	}
+}

packages/backend/src/actors/QuizActor.ts

@@ -200,9 +200,12 @@ export class QuizActor extends SubscribableActor<Quiz, QuizActorMessage, ResultT
 	public async receive(from: ActorRef, message: QuizActorMessage): Promise<ResultType> {
 		console.log("QUIZACTOR", from.name, message);
 		try {
-			const [clientUserRole, clientUserId] = await this.determineRole(from);
+			const [clientUserRole, clientUserId, clientIsTemporary] = await this.determineRole(from);
 			return await QuizActorMessages.match<Promise<ResultType>>(message, {
 				Create: async quiz => {
+					if (clientIsTemporary){
+						return serializeError(new Error("Cannot export as a temporary user"));
+					}			
 					return this.create(quiz, clientUserRole, clientUserId);
 				},
 				GetUserRun: async ({ studentId, quizId }) => {
@@ -385,6 +388,9 @@ export class QuizActor extends SubscribableActor<Quiz, QuizActorMessage, ResultT
 					return unit();
 				},
 				Import: async ({ filename, titlePrefix, userId, userRole }) => {
+					if (clientIsTemporary){
+						return serializeError(new Error("Cannot export as a temporary user"));
+					}
 					console.log(filename);
 					const jsonBuffer = await readFile(path.join("./downloads", filename));
 					const importedObject = JSON.parse(jsonBuffer.toString());
@@ -446,6 +452,7 @@ export class QuizActor extends SubscribableActor<Quiz, QuizActorMessage, ResultT
 							q.quiz = uid;
 							q.authorId = userId ?? clientUserId;
 							q.authorName = userData.username;
+							q.authorFingerprint = userData.fingerprint;
 							q.created = toTimestamp();
 							q.updated = toTimestamp();
 							await db.collection("questions").insertOne(q);
@@ -469,6 +476,9 @@ export class QuizActor extends SubscribableActor<Quiz, QuizActorMessage, ResultT
 					return uid;
 				},
 				Export: async uid => {
+					if (clientIsTemporary){
+						return serializeError(new Error("Cannot export as a temporary user"));
+					}
 					const db = await this.connector.db();
 					const mbQuiz = maybe(await db.collection<Quiz>(this.collectionName).findOne({ uid }));
 					return mbQuiz.match<Promise<Error | string>>(
@@ -516,6 +526,9 @@ export class QuizActor extends SubscribableActor<Quiz, QuizActorMessage, ResultT
 					);
 				},
 				Duplicate: async uid => {
+					if (clientIsTemporary){
+						return serializeError(new Error("Cannot export as a temporary user"));
+					}
 					try {
 						const filename = (await this.ask(this.ref, QuizActorMessages.Export(uid))) as string | Error;
 						if (typeof filename === "string") {

packages/backend/src/actors/StoringActor.ts

@@ -39,13 +39,13 @@ export abstract class StoringActor<Entity extends Document & { updated: Timestam
 		clearInterval(this.checkInterval);
 	}
 
-	protected determineRole = async (from: ActorRef): Promise<[AccessRole, Id]> => {
+	protected determineRole = async (from: ActorRef): Promise<[UserRole: AccessRole, UserID: Id, IsTemporaryAccount: boolean]> => {
 		if (systemEquals(this.actorRef!, from)) {
-			return ["SYSTEM", "SYSTEM" as Id];
+			return ["SYSTEM", "SYSTEM" as Id, false];
 		}
 		if (extractSystemName(this.actorRef!.name) === from.name.replace("actors://", "")) {
 			// It's our actor system that's asking directly
-			return ["SYSTEM", "SYSTEM" as Id];
+			return ["SYSTEM", "SYSTEM" as Id, false];
 		}
 
 		const session: Session = await this.ask(
@@ -55,9 +55,9 @@ export abstract class StoringActor<Entity extends Document & { updated: Timestam
 			.then(s => s as Session)
 			.catch((e: Error): Session => {
 				console.error(e);
-				return { role: "STUDENT", uid: "" } as Session;
+				return { role: "STUDENT", uid: "", fingerprint: "-"} as Session;
 			});
-		return [session.role, session.uid];
+		return [session.role, session.uid, !!session.fingerprint];
 	};
 
 	protected async afterEntityRemovedFromCache(_uid: Id) {

packages/backend/src/actors/UserStore.ts

@@ -19,6 +19,9 @@ import { CollecionSubscription, SubscribableActor } from "./SubscribableActor";
 import { AccessRole } from "./StoringActor";
 import { maybe } from "tsmonads";
 import { createActorUri } from "../utils";
+import { DateTime } from "luxon";
+
+const REMOVE_TEMPS_INTERVAL = 1; // 30; // 30 days
 
 type ListedUser = Omit<User, "quizUsage">;
 
@@ -66,6 +69,25 @@ export class UserStore extends SubscribableActor<User, UserStoreMessage, ResultT
 		draft.teachers.set(user.uid, { uid: user.uid, username: user.username, nickname: user.nickname });
 	}
 
+	protected override cleanup(): void {
+		super.cleanup();
+		const cleanupTemps = async () => { 
+			const cleanupTimestamp = toTimestamp(DateTime.utc().minus({ days: REMOVE_TEMPS_INTERVAL }));
+			const db = await this.connector.db()
+			const temporaryUsers = await db.collection<User>(this.collectionName).find({ isTemporary: true }).toArray();
+			temporaryUsers.forEach(user => {
+				if (user.lastLogin < cleanupTimestamp) {
+					this.logger.debug(`Deleting old temporary user ${user.uid} ${user.username}`);
+					db.collection<User>(this.collectionName).deleteOne({ uid: user.uid });
+					this.state.lastTouched.delete(user.uid);
+					this.state.cache.delete(user.uid);
+					this.afterEntityRemovedFromCache(user.uid);
+				}
+			})
+		}
+		cleanupTemps();	
+	}
+
 	public async receive(from: ActorRef, message: UserStoreMessage): Promise<ResultType> {
 		console.log("USERSTORE", from.name, message);
 		try {
@@ -134,6 +156,19 @@ export class UserStore extends SubscribableActor<User, UserStoreMessage, ResultT
 					const maybeUser = await this.getEntity(userId);
 					return maybeUser.match<User | Error>(identity, () => new Error(`User id ${userId} does not exist`));
 				},
+				GetByFingerprint: async fp => {
+					if (!["ADMIN", "SYSTEM"].includes(clientUserRole)) {
+						return new Error(`Operation not allowed`);
+					}
+					const db = await this.connector.db();
+					const maybeUser = maybe(
+						await db.collection<User>(this.collectionName).findOne({ fingerprint: fp })
+					);
+					return maybeUser.match<User | Error>(
+						identity,
+						() => new Error(`User fingerprint ${fp} does not exist`)
+					);
+				},
 				GetAll: async () => {
 					if (!["ADMIN", "SYSTEM"].includes(clientUserRole)) {
 						return new Error(`Operation not allowed`);
@@ -142,7 +177,9 @@ export class UserStore extends SubscribableActor<User, UserStoreMessage, ResultT
 					const users = await db.collection<User>(this.collectionName).find({}).toArray();
 					users.forEach(user => {
 						const { _id, quizUsage, ...rest } = user;
-						this.send(from, new UserUpdateMessage(rest));
+						//if (clientUserRole === "SYSTEM" || !rest.isTemporary) {
+							this.send(from, new UserUpdateMessage(rest));
+						//}
 					});
 					return unit();
 				},
@@ -232,6 +269,25 @@ export class UserStore extends SubscribableActor<User, UserStoreMessage, ResultT
 						.toArray();
 					return users;
 				},
+				Remove: async uid => {
+					const db = await this.connector.db();
+					const mbUser = maybe(await db.collection<User>(this.collectionName).findOne({uid}));
+					return mbUser.match<Unit | Error>(
+						user => {
+							if (user.isTemporary) {
+								this.deleteEntity(user.uid);
+								this.state.lastTouched.delete(uid);
+								this.state.cache.delete(uid);
+							} else {
+								this.logger.warn(`Trying to remove non-temporary user ${uid}. Operation not allowed and therefore skipped.`);
+							}
+							return unit();
+						},
+						() => {
+							return new Error(`User not found with id <${uid}>`);
+						}
+					)
+				},
 				default: async () => {
 					return new Error(`Unknown message ${JSON.stringify(message)} from ${from.name}`);
 				},

packages/backend/src/index.ts

@@ -16,14 +16,15 @@ import multer from "@koa/multer";
 import type { File } from "@koa/multer";
 import type { IncomingMessage } from "http";
 import koaLogger from "koa-logger-winston";
-import { authLogin, authLogout, authProviderCallback, authRefresh } from "./middlewares/authRoutes";
+import { authLogin, authLogout, authProviderCallback, authRefresh, authTempAccount } from "./middlewares/authRoutes";
 import { errorHandler } from "./middlewares/errorHandler";
 import { logger } from "./logger";
 import { authenticationMiddleware } from "./middlewares/authMiddleware";
 import { QuizActor } from "./actors/QuizActor";
 import { ErrorActor } from "./actors/ErrorActor";
 import { createReadStream, existsSync } from "fs";
 import * as path from "path";
+import { FingerprintStore } from "./actors/FingerprintStore";
 
 const config = {
 	port: parseInt(process.env.SERVER_PORT ?? "3123"),
@@ -56,6 +57,7 @@ router
 	.get("/auth/callback", authProviderCallback)
 	.get("/auth/logout", authLogout)
 	.get("/auth/refresh", authRefresh)
+	.get("/auth/temp", authTempAccount)
 	.get("/ping", ctx => {
 		ctx.status = 200;
 		ctx.body = "PONG";
@@ -105,6 +107,7 @@ const start = async () => {
 		const system = await DistributedActorSystem.create({ distributor, systemName, logger });
 		Container.set("actor-system", system);
 		await system.createActor(SessionStore, { name: "SessionStore", strategy: "Restart" });
+		await system.createActor(FingerprintStore, { name: "FingerprintStore", strategy: "Restart" });
 		await system.createActor(UserStore, { name: "UserStore", strategy: "Restart" });
 		await system.createActor(QuizActor, { name: "QuizActor", strategy: "Restart" });
 		await system.createActor(ErrorActor, { name: "ErrorActor", strategy: "Restart", errorReceiver: true });