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 { v4 as uuidv4 } from 'uuid';

import { db } from './dbService';

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

	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 vorgangToken
 * @returns vorgangObj with keys `token`, `name`, `pin` || undefined
 */
export const getVorgangByToken = (
	vorgangToken: string
): { token: string; name: string; pin: string } | undefined => {
	const getVorgangSQLStmt = `SELECT token, name, pin
														 FROM cases
														 WHERE token = ?`;
	const statement = db.prepare(getVorgangSQLStmt);
	const result = statement.get(vorgangToken) as
		| { token: string; name: string; pin: string }
		| undefined;

	return result;
};

/**
 * Create Vorgang, using a vorgangName and vorgangPIN
 * @param vorgangName
 * @param vorgangPIN
 * @returns {string || false} vorgangToken if successful
 */
export const createVorgang = (vorgangName: string, vorgangPIN: string): string | boolean => {
	const vorgangExists = vorgangNameExists(vorgangName);
	if (vorgangExists) {
		return false;
	}

	const vorgangToken = uuidv4();

	const insertSQLStatement = `INSERT INTO cases (token, name, pin) VALUES (?, ?, ?)`;
	const statement = db.prepare(insertSQLStatement);
	const info = statement.run(vorgangToken, vorgangName, vorgangPIN);

	if (info.changes) {
		return vorgangToken;
	} else {
		return false;
	}
};

/**
 * Get Vorgang
 * @param vorgangName
 * @returns vorgangObj with keys `token`, `name`, `pin` || undefined
 */
export const getVorgangByName = (
	vorgangName: string
): { token: string; name: string; pin: string } | undefined => {
	const getVorgangByNameSQLStmt = `SELECT token, name, pin
																	 FROM cases
																	 WHERE name = ?`;
	const statement = db.prepare(getVorgangByNameSQLStmt);
	const result = statement.get(vorgangName) as
		| { token: string; name: string; pin: string }
		| undefined;

	return result;
};

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

	return info.changes;
};

/**
 * Fetches list of vorgänge from s3 bucket
 * @returns list of available vorgaenge
 */
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 vorgaenge
 */
export const getVorgaenge = (): {
	vorgangToken: string;
	vorgangName: string;
	vorgangPIN: string;
}[] => {
	const getVorgaengeSQLStmt = `SELECT token, name, pin
															 from cases`;
	const statement = db.prepare(getVorgaengeSQLStmt);
	const result = statement.all() as { token: string; name: string; pin: string }[];
	const vorgaenge_list: { vorgangToken: string; vorgangName: string; vorgangPIN: string }[] = [];
	for (const resultItem of result) {
		const vorg = {
			vorgangToken: resultItem.token,
			vorgangName: resultItem.name,
			vorgangPIN: resultItem.pin
		};
		vorgaenge_list.push(vorg);
	}

	return vorgaenge_list;
};

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

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

	return true;
};

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

	const vorgaenge = getVorgaenge();
	const vorgaengeTokens = vorgaenge.map((vorgang) => vorgang.vorgangToken);

	const found = vorgaengeTokens.indexOf(vorgangToken) != -1;

	return found;
};

export const vorgangNameExists = (vorgangName: string) => {
	const vorgaenge = getVorgaenge();
	const vorgaengeNames = vorgaenge.map((vorgang) => vorgang.vorgangName);

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

	return found;
};

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

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

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

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

export const vorgangPINValidation = function (vorgangToken: string, vorgangPIN: string) {
	if (!vorgangPIN) {
		return false;
	}

	const vorgang = getVorgangByToken(vorgangToken);

	if (!vorgang || vorgang.pin !== vorgangPIN) {
		return false;
	}

	return true;
};

/**
 * Change VorgangName or VorgangPIN
 * @param vorgangToken
 * @param newValue
 * @returns {int} number of affected lines
 */
export const updateVorgangAttrByToken = function (vorgangToken: string,
											newValue: string,
											column: string) {
	const renameSQLStmt = `UPDATE cases set ${column} = ? WHERE token = ?`;
	const statement = db.prepare(renameSQLStmt);

	let info;
	
	try {
		info = statement.run(newValue, vorgangToken);
	} catch (err) {
		console.log(`error: ${err}`)
		return 0;
	}

	return info.changes;
};