backend/source/services/member.ts

namespace _espe.service.member
{
	
	/**
	 */
	var _hooks_change : Array<() => void> = [];
	
	
	/**
	 */
	export function listen_change(
		procedure : () => void
	) : void
	{
		_hooks_change.push(procedure);
	}
	
	
	/**
	 */
	function notify_change(
	) : void
	{
		_hooks_change.forEach(
			procedure => {
				procedure();
			}
		);
	}
	
	
	/**
	 */
	export async function draft(
		data : {
			membership_number : string;
			name_real_value : string;
			email_address_private : (null | string);
		}
	) : Promise<_espe.type.member.id>
	{
		const name_real_index : int = await _espe.service.name_index.next(object.name_real_value);
		const object : _espe.type.member.object = {
			"membership_number": data.membership_number,
			"name_real_value": data.name_real_value,
			"name_real_index": name_real_index,
			"email_address_private": data.email_address_private,
			"registered": false,
			"enabled": false,
			"email_use_veiled_address": false,
			"email_use_nominal_address": false,
			"email_redirect_to_private_address": false,
			"email_allow_sending": false,
			"password_image": null,
		};
		const id : _espe.type.member.id = _espe.repository.member.create(object);
		notify_change();
		return id;
	}
	
	
	/*
	export async function dump(
	) : Promise<Array<{id : _espe.type.member.id; value : _espe.type.member.object;}>>
	{
		return _espe.repository.member.dump();
	}
	
	
	export async function list(
	) : Promise<Array<{id : _espe.type.member.id; preview : {membership_number : string, name_real_value : string;};}>>
	{
		return _espe.repository.member.list();
	}
	
	
	export async function get(
		id : _espe.type.member.id
	) : Promise<_espe.type.member.object>
	{
		return _espe.repository.member.read(id);
	}
	
	
	export async function modify(
		id : _espe.type.member.id,
		object : _espe.type.member.object
	) : Promise<void>
	{
		await _espe.repository.member.update(id, object);
		notify_change();
	}
	
	
	export async function remove(
		id : _espe.type.member.id
	) : Promise<void>
	{
		await _espe.repository.member.delete(id);
		notify_change();
	}
	
	
	export async function register(
		id : _espe.type.member.id,
		data : {
			name_login : string;
			name_display : string;
			salutation : string;
			email_address_numberbased_use : boolean;
			email_address_namebased_use : boolean;
			email_redirect_to_private : boolean;
			password : string;
		}
	) : Promise<void>
	{
		const member : _espe.type.member.object = await get(id);
		
		if (member.name_login !== null) {
			return Promise.reject(new Error("already registered"));
		}
		else {
			member.name_login = data.name_login;
			member.name_display = data.name_display;
			member.salutation = data.salutation;
			member.email_address_numberbased_use = data.email_address_numberbased_use
			member.email_address_namebased_use = data.email_address_namebased_use
			member.email_redirect_to_private = data.email_redirect_to_private;
			member.password_image = await _espe.helpers.bcrypt_compute(data.password);
			member.registered = true;
			
			await modify(id, member);
		}
	}
	
	
	export function derive_login_name(
		value : _espe.type.member.object
	) : string
	{
		return lib_plankton.string.coin(
			"{{value}}{{extension}}",
			{
				"value": value.name_real_value.toLowerCase().replace(new RegExp(" ", "g"), "."),
				"extension": (
					(
						(value.name_real_extension === null)
						||
						(value.name_real_extension === "")
					)
					? ""
					: ("." + value.name_real_extension)
				),
			}
		);
	}
	
	
	export function derive_email_address_namely(
		value : _espe.type.member.object
	) : string
	{
		return lib_plankton.string.coin(
			"{{value}}{{extension}}@{{domain}}",
			{
				"value": value.name_real_value.toLowerCase().replace(new RegExp(" ", "g"), "."),
				"extension": (
					(
						(value.name_real_extension === null)
						||
						(value.name_real_extension === "")
					)
					? ""
					: ("." + value.name_real_extension)
				),
				"domain": _espe.conf.get().settings.target_domain,
			}
		);
	}
	
	
	export function derive_email_address_numerical(
		value : _espe.type.member.object
	) : string
	{
		return lib_plankton.string.coin(
			"{{prefix}}{{membership_number}}@{{domain}}",
			{
				"prefix": _espe.conf.get().settings.prefix_for_numberbased_email_addresses,
				"membership_number": value.membership_number,
				"domain": _espe.conf.get().settings.target_domain,
			}
		);
	}
	
	
	function derive_email_address_to_use(
		value : _espe.type.member.object
	) : (null | string)
	{
		return (
			value.email_address_namebased_use
			? derive_email_address_namely(value)
			: (
				value.email_address_numberbased_use
				? derive_email_address_numerical(value)
				: value.email_address_private_value
			)
		);
	}
	
	
	 * @todo check validity (e.g. username characters)
	export async function export_authelia_user_file(
	) : Promise<string>
	{
		const nm_yaml = require("yaml");
		
		return lib_plankton.call.convey(
			await dump(),
			[
				x => x.map(
					entry => Object.assign(
						entry,
						{"email_address": derive_email_address_to_use(entry.value)}
					)
				),
				x => x.filter(
					entry => (
						(
							(entry.value.name_login !== null)
							&&
							(entry.value.name_login !== "")
						)
						&&
						(
							(entry.value.password_image !== null)
							&&
							(entry.value.password_image !== "")
						)
						&&
						(entry.email_address !== null)
					)
				),
				x => x.map(
					entry => ([
						entry.value.name_login,
						{
							"disabled": (! entry.value.enabled),
							"displayname": (
								(
									(entry.value.name_display !== null)
									&&
									(entry.value.name_display !== "")
								)
								? entry.value.name_display
								: entry.value.name_real_value
							),
							"email": entry.email_address,
							"groups": [],
							"password": entry.value.password_image,
						}
					])
				),
				Object.fromEntries,
				x => ({"users": x}),
				x => nm_yaml.stringify(x),
			]
		);
	}
	 */
	
}