tatort/src/lib/server/vorgangService.ts

import { fail } from '@sveltejs/kit';
import { BUCKET, client, CONFIGFILENAME, TOKENFILENAME } from '$lib/minio';
import { checkIfExactDirectoryExists, getContentOfTextObject } from './s3ClientService';

import { db } from './dbService';

/**
 * Get Vorgang and corresponend list of tatorte
 * @param caseToken
 * @returns
 */
export const getCrimesListByToken = async (caseToken: string) => {
	const prefix = `${caseToken}/`;

	const stream = client.listObjectsV2(BUCKET, prefix, false, '');

	const list = [];
	for await (const chunk of stream) {
		const splittedNameParts = chunk.name.split('/');
		const prefix = splittedNameParts[0];
		const name = splittedNameParts[1];

		if (name === CONFIGFILENAME || name === TOKENFILENAME) continue;
		list.push({ ...chunk, name: name, prefix: prefix, show_button: true });
	}
	return list;
};

/**
 * Get Vorgang
 * @param caseToken
 * @returns caseObj with keys `token`, `name`, `pw` || undefined
 */
export const getVorgangByToken = function (caseToken: string) {
	let getVorgangSQLStmt = `SELECT token, name, pw FROM cases WHERE token = ?`;
	const statement = db.prepare(getVorgangSQLStmt);
	const result = statement.get(caseToken);

	return result;
};

/**
 * Get Vorgang
 * @param caseName
 * @returns caseObj with keys `token`, `name`, `pw` || undefined
 */
export const getVorgangByName = function (caseName: string) {
	let getVorgangByNameSQLStmt = `SELECT token, name, pw FROM cases WHERE name = ?`;
	const statement = db.prepare(getVorgangByNameSQLStmt);
	const result = statement.get(caseName);

	return result;
};

/**
 * Delete Vorgang
 * @param caseToken
 * @returns int: number of changes
 */
export const deleteVorgangByToken = function (caseToken: string) {
	let deleteSQLStmt = 'DELETE FROM cases WHERE token = ?';
	const statement = db.prepare(deleteSQLStmt);
	const info = statement.run(caseToken);

	return info.changes;
};

/**
 * Fetches list of vorgänge from s3 bucket
 * @returns list of available cases
 */
export const getListOfVorgänge = async () => {
	const stream = client.listObjectsV2(BUCKET, '', false, '');

	const list = [];
	for await (const chunk of stream) {
		const objPath = `${chunk.prefix}${TOKENFILENAME}`;

		const token = await getContentOfTextObject(BUCKET, objPath);

		const cleanedChunkPrefix = chunk.prefix.replace(/\/$/, '');
		list.push({ name: cleanedChunkPrefix, token: token });
	}
	return list;
};

/**
 * Fetches list of vorgänge from database
 * @returns list with of available cases
 */
export const getVorgaenge = function () {
	let getVorgaengeSQLStmt = `SELECT token, name, pw from cases`;
	const statement = db.prepare(getVorgaengeSQLStmt);
	const result = statement.all();
	const vorgaenge_list = [];
	for (const r of result) {
		const vorg = { token: r.token, name: r.name, pw: r.pw };
		vorgaenge_list.push(vorg);
	}

	return vorgaenge_list;
};

/**
 * Checks if Vorgang exists
 * @param request
 * @returns fail or true
 */
export const checkIfVorgangExists = async (caseId: string | null) => {
	if (!caseId) {
		return fail(400, {
			success: false,
			caseId,
			error: { message: 'Die Vorgangsnummer darf nicht leer sein.' }
		});
	}

	if (typeof caseId === 'string' && !(await checkIfExactDirectoryExists(caseId))) {
		return fail(400, {
			success: false,
			caseId,
			error: { message: 'Die Vorgangsnummer existiert in dieser Anwendung nicht.' }
		});
	}

	return true;
};

export const vorgangExists = function (caseToken: string | null) {
	if (!caseToken) {
		return fail(400, {
			success: false,
			caseId: caseToken,
			error: { message: 'Die Vorgangsnummer darf nicht leer sein.' }
		});
	}

	let vorgaenge = getVorgaenge();
	const vorgaenge_tokens = vorgaenge.map((vorg) => vorg.token);

	const found = vorgaenge_tokens.indexOf(caseToken) != -1;

	return found;
};

export const vorgangNameExists = function (caseName: string) {
	let vorgaenge = getVorgaenge();
	const vorgaengeNames = vorgaenge.map((vorg) => vorg.name);

	const found = vorgaengeNames.indexOf(caseName) != -1;

	return found;
};

export const hasValidToken = async (caseId: string, caseToken: string) => {
	const objPath = `${caseId}/${TOKENFILENAME}`;

	try {
		if (!caseToken) {
			return false;
		}

		const token = await getContentOfTextObject(BUCKET, objPath);
		if (!token || token !== caseToken) {
			return false;
		}

		return true;
	} catch (error) {
		if (error.name == 'S3Error') {
			console.log(error);
			return false;
		}
	}
};

export const passwordValid = function (caseToken, casePassword) {
	if (!casePassword) {
		return false;
	}

	const vorg = getVorgangByToken(caseToken);

	if (!vorg || vorg.pw !== casePassword) {
		return false;
	}

	return true;
};