[task-193] [int]

misc/conf.example.json

@@ -2,7 +2,7 @@
 	"general": {
 		"language": null,
 		"verbosity": "info",
-		"verification_secret": null
+		"verification_secret": "foobar"
 	},
 	"log": [
 		{
@@ -26,7 +26,7 @@
 	"database": {
 		"kind": "sqlite",
 		"data": {
-			"path": "data.sqlite"
+			"path": "../espe.sqlite"
 		}
 	},
 	"email_sending": {
@@ -67,7 +67,7 @@
 			"salt": null
 		},
 		"connections": {
-			"frontend_url_base": null,
+			"frontend_url_base": "http://localhost:8888",
 			"login_url": null
 		}
 	},

misc/sampledata.json

@@ -0,0 +1,63 @@
+{
+	"groups": [
+		{
+			"id": 1,
+			"name": "auto"
+		},
+		{
+			"id": 2,
+			"name": "zug"
+		},
+		{
+			"id": 3,
+			"name": "flugzeug"
+		},
+		{
+			"id": 4,
+			"name": "fahrrad"
+		},
+		{
+			"id": 5,
+			"name": "zu_fuß"
+		}
+	],
+	"admins": [
+		{
+			"name": "admin",
+			"email_address": "admin@example.org",
+			"password": "admin"
+		}
+	],
+	"members": [
+		{
+			"id": 1,
+			"name": "Alexandra Ahorn",
+			"email_address_private": "alex-rockt@example.org",
+			"groups": [1, 2, 3]
+		},
+		{
+			"id": 2,
+			"name": "Berthold Buche",
+			"email_address_private": "bert-ohne-ernie@example.org",
+			"groups": [4, 5, 2]
+		},
+		{
+			"id": 3,
+			"name": "Charlotte Castania",
+			"email_adress_private": "charly-the-unicorn@example.org",
+			"groups": [4, 1]
+		}
+	],
+	"invites": [
+		{
+			"id": 1,
+			"name_changeable": true,
+			"name_value": "Daniel Distel",
+			"email_address_changeable": true,
+			"email_address_value": "duesentrieb@example.org",
+			"groups_changeable": false,
+			"groups_value": [3, 5]
+		}
+	]
+}
+

source/api/actions/invite_accept.ts

@@ -0,0 +1,96 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	/**
+	 */
+	export function register_invitation_accept(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			{
+				key : string;
+				data : {
+					name : (null | string);
+					groups : (null | Array<int>);
+					email_address : (null | string);
+					password : (null | string);
+				};
+			},
+			Array<
+				{
+					incident : string;
+					details : Record<string, any>;
+				}
+			>
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.post,
+			_espe.api.full_path("/invitation/accept"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "nimmt eine Einladung an",
+				/**
+				 * @todo
+				 */
+				"input_schema": () => ({
+					"nullable": true,
+				}),
+				/**
+				 * @todo
+				 */
+				"output_schema": () => ({
+					"nullable": true,
+				}),
+				"restriction": () => restriction_none,
+				"execution": () => async ({"input": input}) => {
+					if (input === null)
+					{
+						return Promise.resolve({
+							"status_code": 400,
+							"data": null
+						});
+					}
+					else
+					{
+						try
+						{
+							const flaws = await _espe.service.invitation.accept(
+								input.key,
+								input.data
+							);
+							return Promise.resolve({
+								"status_code": 200,
+								"data": flaws
+							});
+						}
+						catch (error)
+						{
+							return Promise.resolve({
+								"status_code": 404,
+								"data": null
+							});
+						}
+					}
+				}
+			}
+		);
+	}
+	
+}

source/api/actions/invite_create.ts

@@ -0,0 +1,185 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	
+	/**
+	 */
+	export function register_invitation_create(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			{
+				data : {
+					name_changeable : boolean;
+					name_value : string;
+					email_address_changeable : boolean;
+					email_address_value : (null | string);
+					groups_changeable : boolean;
+					groups_value : Array<int>;
+					expiry : (null | int);
+				};
+				notification_target_url_template ?: (null | string);
+				send_immediatly : boolean;
+			},
+			(
+				string
+				|
+				{
+					id : _espe.type.member_id;
+					key : string;
+				}
+			)
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.post,
+			_espe.api.full_path("/invitation/create"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "erstellt eine Einladung und gibt die erzeugte ID und den erzeugten Schlüssel aus",
+				"input_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"additionalProperties": false,
+					"properties": {
+						"data": {
+							"nullable": false,
+							"type": "object",
+							"additionalProperties": false,
+							"properties": {
+								"expiry": {
+									"nullable": true,
+									"type": "intiger",
+									"description": "Ablaufzeitpunkt"
+								},
+								"name_changeable": {
+									"type": "boolean",
+									"nullable": false,
+									"description": "Name | änderbar"
+								},
+								"name_value": {
+									"type": "string",
+									"nullable": true,
+									"description": "Name | Wert"
+								},
+								"email_address_changeable": {
+									"type": "boolean",
+									"nullable": false,
+									"description": "E-Mail-Adresse | änderbar"
+								},
+								"email_address_value": {
+									"type": "string",
+									"nullable": true,
+									"description": "E-Mail-Adresse | Wert"
+								},
+								"groups_integer": {
+									"type": "integer",
+									"nullable": true,
+									"description": "Gruppen | Modus"
+								},
+								"groups_value": {
+									"nullable": false,
+									"type": "array",
+									"items": {
+										"type": "integer",
+										"nullable": false,
+									},
+									"description": "Gruppen | Wert"
+								},
+							},
+							"required": [
+								"membership_number_changeable",
+								"membership_number_value",
+								"name_changeable",
+								"name_value",
+								"email_address_changeable",
+								"email_address_value",
+								"groups_changeable",
+								"groups_value",
+								"expiry",
+							]
+						},
+						"notification_target_url_template": {
+							"type": "string",
+							"nullable": true,
+							"description": "Platz-Halter: key"
+						},
+						"send_immediatly": {
+							"nullable": false,
+							"type": "boolean",
+							"description": "Einladungs-Link direkt an angegebene E-Mail-Adresse versenden"
+						},
+					},
+					"required": [
+						"data",
+						"send_immediatly",
+					]
+				}),
+				"output_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"properties": {
+						"id": {
+							"type": "number",
+							"nullable": false,
+						},
+						"key": {
+							"type": "string",
+							"nullable": false,
+						},
+					},
+					"additionalProperties": false,
+					"required": [
+						"id",
+						"key",
+					]
+				}),
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({"input": input}) => {
+					if (input === null) {
+						return Promise.reject(new Error("impossible"));
+					}
+					else {
+						const invitation_info : {id : _espe.type.invitation_id; key : _espe.type.invitation_key;} = await _espe.service.invitation.create(
+							{
+								"name_changeable": input.data.name_changeable,
+								"name_value": input.data.name_value,
+								"email_address_changeable": input.data.email_address_changeable,
+								"email_address_value": input.data.email_address_value,
+								"groups_changeable": input.data.groups_changeable,
+								"groups_value": input.data.groups_value,
+							},
+							{
+								"expiry": input.data.expiry,
+								"notification_target_url_template": input.notification_target_url_template,
+								"send_immediatly": input.send_immediatly,
+							}
+						);
+						return Promise.resolve({
+							"status_code": 201,
+							"data": invitation_info
+						});
+					}
+				}
+			}
+		);
+	}
+	
+}
+

source/api/actions/invite_examine.ts

@@ -0,0 +1,129 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	/**
+	 */
+	export function register_invitation_examine(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			any,
+			any
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.get,
+			_espe.api.full_path("/invitation/examine"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "gibt die Daten einer Einladung anhand ihres Schlüssels aus",
+				"query_parameters": () => [
+					{
+						"name": "key",
+						"required": true,
+						"description": "key",
+					}
+				],
+				"output_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"additionalProperties": false,
+					"properties": {
+						"expiry": {
+							"nullable": true,
+							"type": "integer",
+							"description": "Ablaufzeitpunkt"
+						},
+						"name_changeable": {
+							"type": "boolean",
+							"nullable": false,
+							"description": "Name | änderbar"
+						},
+						"name_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "Name | Wert"
+						},
+						"email_address_changeable": {
+							"type": "boolean",
+							"nullable": false,
+							"description": "E-Mail-Adresse | änderbar"
+						},
+						"email_address_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "E-Mail-Adresse | Wert"
+						},
+						"groups_changeable": {
+							"type": "boolean",
+							"nullable": false,
+							"description": "Gruppen | änderbar"
+						},
+						"groups_value": {
+							"nullable": false,
+							"type": "array",
+							"items": {
+								"type": "string",
+								"nullable": false,
+							},
+							"description": "Gruppen | Wert"
+						},
+					},
+					"required": [
+						"expiry",
+						"name_changeable",
+						"name_value",
+						"email_address_changeable",
+						"email_address_value",
+						"groups_changeable",
+						"groups_value",
+					]
+				}),
+				"restriction": () => restriction_none,
+				"execution": () => ({"query_parameters": query_parameters, "input": input}) => {
+					const invitation_key : _espe.type.invitation_key = query_parameters["key"];
+					return (
+						_espe.service.invitation.examine(invitation_key)
+						.then(
+							(invitation_object) => Promise.resolve({
+								"status_code": 200,
+								"data": {
+									"expiry": invitation_object.expiry,
+									"name_changeable": invitation_object.name_changeable,
+									"name_value": invitation_object.name_value,
+									"email_address_changeable": invitation_object.email_address_changeable,
+									"email_address_value": invitation_object.email_address_value,
+									"groups_changeable": invitation_object.groups_changeable,
+									"groups_value": invitation_object.groups_value,
+								}
+							})
+						)
+						.catch(
+							(error) => Promise.resolve({
+								"status_code": 404,
+								"data": "not found"
+							})
+						)
+					);
+				}
+			}
+		);
+	}
+	
+}

source/api/actions/invite_list.ts

@@ -0,0 +1,86 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	/**
+	 */
+	export function register_invitation_list(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			null,
+			Array<
+				{
+					id : _espe.type.invitation_id;
+					key : _espe.type.invitation_key;
+					expiry : (null | int);
+					name_value : (null | string);
+				}
+			>
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.get,
+			_espe.api.full_path("/invitation/list"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "listet alle Einladung auf",
+				"output_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"additionalProperties": false,
+					"properties": {
+						"id": {
+							"nullable": false,
+							"type": "intiger",
+							"description": "ID"
+						},
+						"key": {
+							"nullable": false,
+							"type": "string",
+							"description": "Schlüssel"
+						},
+						"expiry": {
+							"nullable": true,
+							"type": "integer",
+							"description": "Ablauf"
+						},
+						"name_value": {
+							"nullable": false,
+							"type": "string",
+							"description": "Name"
+						},
+					},
+					"required": [
+						"id",
+						"key",
+					]
+				}),
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({}) => {
+					const data = await _espe.service.invitation.list();
+					return Promise.resolve({
+						"status_code": 200,
+						"data": data
+					});
+				}
+			}
+		);
+	}
+	
+}

source/api/actions/invite_read.ts

@@ -0,0 +1,144 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	
+	/**
+	 */
+	export function register_invitation_read(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			int,
+			(
+				string
+				|
+				{
+					key : string;
+					expiry : (null | int);
+					name_changeable : boolean;
+					name_value : (null | string);
+					email_address_changeable : boolean;
+					email_address_value : (null | string);
+					groups_changeable : boolean;
+					groups_value : (null | Array<int>);
+				}
+			)
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.get,
+			_espe.api.full_path("/invitation/read"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "gibt die Daten einer Einladung anhand ihrer ID aus",
+				"query_parameters": () => [
+					{
+						"name": "id",
+						"required": true,
+						"description": "id",
+					}
+				],
+				"output_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"additionalProperties": false,
+					"properties": {
+						"expiry": {
+							"nullable": true,
+							"type": "integer",
+							"description": "Ablaufzeitpunkt"
+						},
+						"name_changeable": {
+							"type": "boolean",
+							"nullable": false,
+							"description": "Name | änderbar"
+						},
+						"name_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "Name | Wert"
+						},
+						"email_address_changeable": {
+							"type": "boolean",
+							"nullable": false,
+							"description": "E-Mail-Adresse | änderbar"
+						},
+						"email_address_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "E-Mail-Adresse | Wert"
+						},
+						"groups_changeable": {
+							"type": "boolean",
+							"nullable": false,
+							"description": "Gruppen | änderbar"
+						},
+						"groups_value": {
+							"nullable": false,
+							"type": "array",
+							"items": {
+								"type": "integer",
+								"nullable": false,
+							},
+							"description": "Gruppen | Wert"
+						},
+					},
+					"required": [
+						"expiry",
+						"name_mode",
+						"name_value",
+						"email_address_mode",
+						"email_address_value",
+						"groups_mode",
+						"groups_value",
+					]
+				}),
+				"restriction": () => restriction_logged_in,
+				"execution": () => ({"query_parameters": query_parameters, "input": input}) => {
+					const invitation_id : _espe.type.invitation_id = parseInt(query_parameters["id"]);
+					return (
+						_espe.service.invitation.get_by_id(invitation_id)
+						.then(
+							(invitation_object) => Promise.resolve({
+								"status_code": 200,
+								"data": {
+									"key": invitation_object.key,
+									"expiry": invitation_object.expiry,
+									"name_changeable": invitation_object.name_changeable,
+									"name_value": invitation_object.name_value,
+									"email_address_changeable": invitation_object.email_address_changeable,
+									"email_address_value": invitation_object.email_address_value,
+									"groups_changeable": invitation_object.groups_changeable,
+									"groups_value": invitation_object.groups_value,
+								}
+							})
+						)
+						.catch(
+							(error) => Promise.resolve({
+								"status_code": 404,
+								"data": "not found"
+							})
+						)
+					);
+				}
+			}
+		);
+	}
+	
+}

source/api/actions/member_info.ts

@@ -1,121 +0,0 @@
-/*
-Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
-Copyright (C) 2024 Christian Fraß
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
-License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
-warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program. If not, see 
-<https://www.gnu.org/licenses/>. 
- */
-
-namespace _espe.api
-{
-	
-	/**
-	 * @todo zeitliche Begrenzung?
-	 */
-	export function register_member_info(
-		rest_subject : lib_plankton.rest_http.type_rest
-	) : void
-	{
-		lib_plankton.rest_http.register<
-			int,
-			(
-				null
-				|
-				{
-					name_real_value : string;
-					name_real_index : int;
-					name_login : string;
-					email_address_veiled : (null | string);
-					email_address_nominal : string;
-				}
-			)
-		>(
-			rest_subject,
-			lib_plankton.http.enum_method.get,
-			_espe.api.full_path("/member/info/:id"),
-			{
-				"description": () => "gibt Angaben über ein Mitglied aus, die für die Registrierung verwendet werden dürfen",
-				"input_schema": () => ({
-					"type": "number",
-					"nullable": false,
-				}),
-				"output_schema": () => ({
-					"type": "object",
-					"nullable": false,
-					"additionalProperties": false,
-					"properties": {
-						"name_real_value": {
-							"type": "string",
-							"nullable": false,
-						},
-						"name_real_index": {
-							"type": "number",
-							"nullable": false,
-						},
-						"name_login": {
-							"type": "string",
-							"nullable": false,
-						},
-						"email_address_veiled": {
-							"type": "string",
-							"nullable": true,
-						},
-						"email_address_nominal": {
-							"type": "string",
-							"nullable": false,
-						},
-					},
-					"required": [
-						"name_real_value",
-						"name_real_index",
-						"name_login",
-						"email_address_veiled",
-						"email_address_nominal",
-					]
-				}),
-				"query_parameters": () => [
-					{
-						"name": "key",
-						"required": true,
-						"description": "Zugriffs-Schlüssel",
-					},
-				],
-				"restriction": () => restriction_verification(
-					stuff => parseInt(stuff.path_parameters["id"]),
-					stuff => stuff.query_parameters["key"]
-				),
-				"execution": () => async ({"path_parameters": path_parameters, "input": input}) => {
-					const member_id : _espe.type.member_id = parseInt(path_parameters["id"]);
-					const data : (
-						null
-						|
-						{
-							name_real_value : string;
-							name_real_index : int;
-							name_login : string;
-							email_address_veiled : (null | string);
-							email_address_nominal : string;
-						}
-					) = await _espe.service.member.info(member_id);
-					
-					return Promise.resolve({
-						"status_code": (
-							(data === null)
-							? 409
-							: 200
-						),
-						"data": data
-					});
-				},
-			}
-		)
-	}
-	
-}

source/api/actions/member_list.ts

@@ -28,9 +28,7 @@ namespace _espe.api
 				{
 					id : int;
 					preview : {
-						membership_number : string;
-						name_real_value : string;
-						name_real_index : int;
+						name : string;
 					};
 				}
 			>
@@ -62,18 +60,10 @@ namespace _espe.api
 								"type": "object",
 								"additionalProperties": false,
 								"properties": {
-									"membership_number": {
+									"name": {
 										"type": "string",
 										"nullable": false,
 									},
-									"name_real_value": {
-										"type": "string",
-										"nullable": false,
-									},
-									"name_real_index": {
-										"type": "number",
-										"nullable": false,
-									},
 								},
 								"required": [
 									"membership_number",

source/api/actions/member_modify.ts

@@ -24,9 +24,8 @@ namespace _espe.api
 	{
 		lib_plankton.rest_http.register<
 			{
-				email_address_private : (null | string);
-				groups ?: Array<string>;
-				registered : boolean;
+				email_address : (null | string);
+				groups ?: Array<int>;
 				enabled : boolean;
 			},
 			null
@@ -40,7 +39,7 @@ namespace _espe.api
 					"nullable": false,
 					"type": "object",
 					"properties": {
-						"email_address_private": {
+						"email_address": {
 							"nullable": true,
 							"type": "string"
 						},
@@ -52,10 +51,6 @@ namespace _espe.api
 								"nullable": false,
 							}
 						},
-						"registered": {
-							"nullable": false,
-							"type": "boolean"
-						},
 						"enabled": {
 							"nullable": false,
 							"type": "boolean"
@@ -63,8 +58,7 @@ namespace _espe.api
 					},
 					"additionalProperties": false,
 					"required": [
-						"email_address_private",
-						"registered",
+						"email_address",
 						"enabled",
 					]
 				}),
@@ -81,13 +75,12 @@ namespace _espe.api
 						await _espe.service.member.modify(
 							member_id,
 							{
-								"email_address_private": input.email_address_private,
+								"email_address": input.email_address,
 								"groups": (
 									(input.groups === undefined)
-									? lib_plankton.pod.make_empty<Array<string>>()
-									: lib_plankton.pod.make_filled<Array<string>>(input.groups)
+									? lib_plankton.pod.make_empty<Array<_espe.type.group_id>>()
+									: lib_plankton.pod.make_filled<Array<_espe.type.group_id>>(input.groups)
 								),
-								"registered": input.registered,
 								"enabled": input.enabled,
 							}
 						);

source/api/actions/member_project.ts

@@ -1,153 +0,0 @@
-/*
-Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
-Copyright (C) 2024 Christian Fraß
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
-License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
-warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program. If not, see 
-<https://www.gnu.org/licenses/>. 
- */
-
-namespace _espe.api
-{
-	
-	/**
-	 */
-	export function register_member_project(
-		rest_subject : lib_plankton.rest_http.type_rest
-	) : void
-	{
-		lib_plankton.rest_http.register<
-			{
-				membership_number : (null | string);
-				name_real_value : string;
-				email_address_private : (null | string);
-				groups ?: Array<string>;
-				notification_target_url_template ?: (null | string);
-			},
-			(
-				string
-				|
-				_espe.type.member_id
-			)
-		>(
-			rest_subject,
-			lib_plankton.http.enum_method.post,
-			_espe.api.full_path("/member/project"),
-			{
-				"description": () => "erstellt ein neues Mitglied und gibt die erzeugte ID aus",
-				"input_schema": () => ({
-					"type": "object",
-					"nullable": false,
-					"additionalProperties": false,
-					"properties": {
-						"membership_number": {
-							"type": "string",
-							"nullable": false,
-							"description": "Mitgliedsnummer"
-						},
-						"name_real_value": {
-							"type": "string",
-							"nullable": false,
-							"description": "Klarname"
-						},
-						"email_address_private": {
-							"type": "string",
-							"nullable": true,
-							"description": "private E-Mail-Adresse"
-						},
-						"groups": {
-							"nullable": false,
-							"type": "array",
-							"items": {
-								"type": "string",
-								"nullable": false,
-							}
-						},
-						"notification_target_url_template": {
-							"type": "string",
-							"nullable": true,
-							"description": "Platz-Halter: id"
-						},
-					},
-					"required": [
-						"membership_number",
-						"name_real_value",
-					]
-				}),
-				"output_schema": () => ({
-					"type": "number",
-					"nullable": false,
-				}),
-				"restriction": () => restriction_logged_in,
-				"execution": () => async ({"input": input}) => {
-					if (input === null) {
-						return Promise.reject(new Error("impossible"));
-					}
-					else {
-						if (
-							(! _espe.conf.get().settings.misc.facultative_membership_number)
-							&&
-							(
-								(input.membership_number === null)
-								||
-								(input.membership_number === "")
-							)
-						) {
-							return Promise.resolve({
-								"status_code": 400,
-								"data": "membership number required"
-							});
-						}
-						else {
-							const member_id : _espe.type.member_id = await _espe.service.member.project(
-								{
-									"membership_number": input.membership_number,
-									"name_real_value": input.name_real_value,
-									"email_address_private": (
-										("email_address_private" in input)
-										? (
-											(input.email_address_private !== "")
-											? input.email_address_private
-											: null
-										)
-										: null
-									),
-									"groups": (input.groups ?? []),
-								}
-							);
-							if (! _espe.conf.get().settings.misc.auto_register) {
-								// do nothing
-							}
-							else {
-								// TODO: Werte in Konfiguration auslagern
-								await _espe.service.member.register(
-									member_id,
-									{
-										"email_use_veiled_address": false,
-										"email_use_nominal_address": false,
-										"email_redirect_to_private_address": false,
-										"password": null,
-									},
-									{
-										"notification_target_url_template": input.notification_target_url_template,
-									}
-								);
-							}
-							return Promise.resolve({
-								"status_code": 201,
-								"data": member_id
-							});
-						}
-					}
-				}
-			}
-		);
-	}
-	
-}

source/api/actions/member_read.ts

@@ -25,21 +25,11 @@ namespace _espe.api
 		lib_plankton.rest_http.register<
 			null,
 			{
-				membership_number : (null | string);
-				name_real_value : string;
-				name_real_index : int;
-				email_address_private : (null | string);
-				groups : Array<string>;
-				registered : boolean;
+				name : string;
+				email_address : (null | string);
+				groups : Array<int>;
 				enabled : boolean;
-				email_use_veiled_address : boolean;
-				email_use_nominal_address : boolean;
-				email_redirect_to_private_address : boolean;
-				email_allow_sending : boolean;
 				password_set : boolean;
-				email_address_veiled : (null | string);
-				email_address_nominal : string;
-				name_login : string;
 			}
 		>(
 			rest_subject,
@@ -51,19 +41,11 @@ namespace _espe.api
 					"nullable": false,
 					"type": "object",
 					"properties": {
-						"membership_number": {
-							"nullable": true,
-							"type": "string"
-						},
-						"name_real_value": {
+						"name": {
 							"nullable": false,
 							"type": "string"
 						},
-						"name_real_index": {
-							"nullable": false,
-							"type": "number"
-						},
-						"email_address_private": {
+						"email_address": {
 							"nullable": true,
 							"type": "string"
 						},
@@ -72,67 +54,21 @@ namespace _espe.api
 							"type": "array",
 							"items": {
 								"nullable": false,
-								"type": "string"
+								"type": "int"
 							}
 						},
-						"registered": {
-							"nullable": false,
-							"type": "boolean"
-						},
 						"enabled": {
 							"nullable": false,
 							"type": "boolean"
 						},
-						"email_use_veiled_address": {
-							"nullable": false,
-							"type": "boolean"
-						},
-						"email_use_nominal_address": {
-							"nullable": false,
-							"type": "boolean"
-						},
-						"email_redirect_to_private_address": {
-							"nullable": false,
-							"type": "boolean"
-						},
-						"email_allow_sending": {
-							"nullable": false,
-							"type": "boolean"
-						},
-						"password_set": {
-							"nullable": false,
-							"type": "boolean"
-						},
-						"email_address_veiled": {
-							"nullable": true,
-							"type": "string"
-						},
-						"email_address_nominal": {
-							"nullable": false,
-							"type": "string"
-						},
-						"name_login": {
-							"nullable": false,
-							"type": "string"
-						},
 					},
 					"additionalProperties": false,
 					"required": [
-						"membership_number",
-						"name_real_value",
-						"name_real_index",
-						"email_address_private",
+						"name",
+						"email_address",
 						"groups",
-						"registered",
 						"enabled",
-						"email_use_veiled_address",
-						"email_use_nominal_address",
-						"email_redirect_to_private_address",
-						"email_allow_sending",
 						"password_set",
-						"email_address_veiled",
-						"email_address_nominal",
-						"name_login",
 					]
 				}),
 				"restriction": () => restriction_logged_in,
@@ -142,21 +78,11 @@ namespace _espe.api
 					return Promise.resolve({
 						"status_code": 200,
 						"data": {
-							"membership_number": member_object.membership_number,
-							"name_real_value": member_object.name_real_value,
-							"name_real_index": member_object.name_real_index,
-							"email_address_private": member_object.email_address_private,
+							"name": member_object.name,
+							"email_address": member_object.email_address,
 							"groups": member_object.groups,
-							"registered": member_object.registered,
 							"enabled": member_object.enabled,
-							"email_use_veiled_address": member_object.email_use_veiled_address,
-							"email_use_nominal_address": member_object.email_use_nominal_address,
-							"email_redirect_to_private_address": member_object.email_redirect_to_private_address,
-							"email_allow_sending": member_object.email_allow_sending,
 							"password_set": (member_object.password_image !== null),
-							"name_login": _espe.service.member.name_login(member_object),
-							"email_address_veiled": _espe.service.member.email_address_veiled(member_object),
-							"email_address_nominal": _espe.service.member.email_address_nominal(member_object),
 						},
 					});
 				}

source/api/actions/member_register.ts

@@ -1,159 +0,0 @@
-/*
-Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
-Copyright (C) 2024 Christian Fraß
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
-License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
-warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program. If not, see 
-<https://www.gnu.org/licenses/>. 
- */
-
-namespace _espe.api
-{
-	
-	/**
-	 * @todo zeitliche Begrenzung?
-	 */
-	export function register_member_register(
-		rest_subject : lib_plankton.rest_http.type_rest
-	) : void
-	{
-		lib_plankton.rest_http.register<
-			{
-				email_use_veiled_address : boolean;
-				email_use_nominal_address : boolean;
-				email_redirect_to_private_address : boolean;
-				password : (null | string);
-				notification_target_url_template ?: (null | string);
-			},
-			Array<
-				{
-					incident : string;
-					details : Record<string, any>;
-				}
-			>
-		>(
-			rest_subject,
-			lib_plankton.http.enum_method.post,
-			_espe.api.full_path("/member/register/:id"),
-			{
-				"description": () => "nimmt zusätzliche Angaben eines Mitglieds entgegen",
-				"input_schema": () => ({
-					"type": "object",
-					"nullable": false,
-					"additionalProperties": false,
-					"properties": {
-						"email_use_veiled_address": {
-							"type": "boolean",
-							"nullable": false,
-							"description": "ob die nummern-basierte E-Mail-Adresse eingerichtet werden soll",
-						},
-						"email_use_nominal_address": {
-							"type": "boolean",
-							"nullable": false,
-							"description": "ob die namens-basierte E-Mail-Adresse eingerichtet werden soll",
-						},
-						"email_redirect_to_private_address": {
-							"type": "boolean",
-							"nullable": false,
-							"description": "ob auf die Partei-Adressen eingehende E-Mails zur privaten Adresse weitergeleitet werden sollen",
-						},
-						"password": {
-							"type": "string",
-							"nullable": true,
-							"description": "Passwort für alle Netz-Dienste",
-						},
-						"notification_target_url_template": {
-							"type": "string",
-							"nullable": true,
-							"description": "Platz-Halter: id"
-						},
-					},
-					"required": [
-						"email_use_veiled_address",
-						"email_use_nominal_address",
-						"email_redirect_to_private_address",
-						"password",
-					]
-				}),
-				"output_schema": () => ({
-					"nullable": false,
-					"type": "array",
-					"items": {
-						"nullable": false,
-						"type": "object",
-						"properties": {
-							"incident": {
-								"nullable": false,
-								"type": "string"
-							},
-							"details": {
-								"nullable": false,
-								"type": "object",
-								"properties": {},
-								"additionalProperties": {
-									"nullable": true
-								},
-								"required": []
-							},
-						},
-						"additionalProperties": false,
-						"required": [
-							"incident",
-							"details",
-						]
-					}
-				}),
-				"query_parameters": () => [
-					{
-						"name": "key",
-						"required": true,
-						"description": "Zugriffs-Schlüssel",
-					},
-				],
-				"restriction": () => restriction_verification(
-					stuff => parseInt(stuff.path_parameters["id"]),
-					stuff => stuff.query_parameters["key"]
-				),
-				"execution": () => ({"path_parameters": path_parameters, "input": input}) => {
-					if (input === null) {
-						return Promise.reject(new Error("impossible"));
-					}
-					else {
-						const member_id : _espe.type.member_id = parseInt(path_parameters["id"]);
-						return (
-							_espe.service.member.register(
-								member_id,
-								{
-									"email_use_veiled_address": input.email_use_veiled_address,
-									"email_use_nominal_address": input.email_use_nominal_address,
-									"email_redirect_to_private_address": input.email_redirect_to_private_address,
-									"password": input.password,
-								},
-								{
-									"notification_target_url_template": (input.notification_target_url_template ?? null),
-								}
-							)
-							.then(
-								flaws => Promise.resolve({
-									"status_code": (
-										(flaws.length <= 0)
-										? 200
-										: 409
-									),
-									"data": flaws
-								})
-							)
-						);
-					}
-				},
-			}
-		)
-	}
-	
-}

source/api/functions.ts

@@ -45,10 +45,7 @@ namespace _espe.api
 		}
 		// member
 		{
-			_espe.api.register_member_project(rest_subject);
 			_espe.api.register_member_summon(rest_subject);
-			_espe.api.register_member_info(rest_subject);
-			_espe.api.register_member_register(rest_subject);
 			_espe.api.register_member_list(rest_subject);
 			_espe.api.register_member_read(rest_subject);
 			_espe.api.register_member_modify(rest_subject);
@@ -59,11 +56,13 @@ namespace _espe.api
 				_espe.api.register_member_password_change_execute(rest_subject);
 			}
 		}
-		// invite
+		// invitation
 		{
-			_espe.api.register_invite_create(rest_subject);
-			_espe.api.register_invite_examine(rest_subject);
-			_espe.api.register_invite_accept(rest_subject);
+			_espe.api.register_invitation_list(rest_subject);
+			_espe.api.register_invitation_read(rest_subject);
+			_espe.api.register_invitation_create(rest_subject);
+			_espe.api.register_invitation_examine(rest_subject);
+			_espe.api.register_invitation_accept(rest_subject);
 		}
 		
 		return rest_subject;

source/data/localization/deu.loc.json

@@ -14,9 +14,12 @@
 		"email.password_change.initialization.body": "Hi, {{name}}\n\nDie Funktion zum Ändern deines Passwortes wurde aufgerufen. Wenn du dein Passwort ändern willst, rufe folgenden Link auf:\n\n{{url}}\n",
 		"email.password_change.execution.subject": "Passwort-Änderung abgeschlossen",
 		"email.password_change.execution.body": "Hi, {{name}}\n\nDein Passwort wurde soeben geändert.\n",
+		"email.invitation.subject": "Einladung",
+		"email.invitation.body": "{{url}}",
 		"help.args.action.description": "auszuführende Aktion; Auswahl",
 		"help.args.action.options.serve": "Server starten",
 		"help.args.action.options.api_doc": "API-Dokumentation gemäß OpenAPI-Spezifikation auf Standard-Ausgabe schreiben",
+		"help.args.action.options.sample": "Datenbank mit Beispiel-Daten befüllen",
 		"help.args.action.options.email_test": "eine Test-E-Mail senden",
 		"help.args.action.options.expose_conf": "Vollständige Konfiguration ausgeben",
 		"help.args.action.options.password_image": "Passwort-Abbild errechnen und auf Standard-Ausgabe schreiben",

source/data/localization/eng.loc.json

@@ -14,9 +14,12 @@
 		"email.password_change.initialization.body": "Hi, {{name}}\n\nThe function for changing your password has been triggered. If you want to change your password, open the folloling link:\n\n{{url}}",
 		"email.password_change.execution.subject": "Password change concluded",
 		"email.password_change.execution.body": "Hi, {{name}}\n\nYour password has just been changed.\n",
+		"email.invitation.subject": "invitation",
+		"email.invitation.body": "{{url}}",
 		"help.args.action.description": "action to executo; options",
 		"help.args.action.options.serve": "start server",
 		"help.args.action.options.api_doc": "write API documentation according to OpenAPI specification to stdout",
+		"help.args.action.options.sample": "fill database with sample data",
 		"help.args.action.options.email_test": "send a test e-mail",
 		"help.args.action.options.expose_conf": "write complete configuration to stdout",
 		"help.args.action.options.password_image": "compute password image and write to stdout",

source/database.ts

@@ -19,7 +19,7 @@ namespace _espe.database
 	/**
 	 */
 	const _compatible_revisions : Array<string> = [
-		"r6",
+		"r7",
 	];
 	
 		

source/helpers.ts

@@ -16,6 +16,26 @@ You should have received a copy of the GNU General Public License along with thi
 namespace _espe.helpers
 {
 	
+	/**
+	 */
+	export function dbbool_encode(
+		value : boolean
+	) : int
+	{
+		return (value ? 1 : 0);
+	}
+	
+	
+	/**
+	 */
+	export function dbbool_decode(
+		value : int
+	) : boolean
+	{
+		return (value > 0);
+	}
+	
+	
 	/**
 	 */
 	export type type_smtp_credentials = {

source/main.ts

@@ -204,6 +204,10 @@ namespace _espe
 									"name": "api-doc",
 									"description": lib_plankton.translate.get("help.args.action.options.api_doc")
 								},
+								{
+									"name": "sample",
+									"description": lib_plankton.translate.get("help.args.action.options.sample"),
+								},
 								{
 									"name": "email-test",
 									"description": lib_plankton.translate.get("help.args.action.options.email_test")
@@ -271,7 +275,7 @@ namespace _espe
 				"hidden": true,
 			}),
 			"conf_path": lib_plankton.args.class_argument.volatile({
-				"indicators_long": ["conf_path"],
+				"indicators_long": ["conf-path"],
 				"indicators_short": ["c"],
 				"type": lib_plankton.args.enum_type.string,
 				"mode": lib_plankton.args.enum_mode.replace,
@@ -360,6 +364,14 @@ namespace _espe
 					);
 					break;
 				}
+				case "sample": {
+					const path : string = args["arg1"];
+					if (path === null) {
+						throw (new Error("SYNTAX: sample <source-file-path>"));
+					}
+					_espe.sample.fill_by_path(path);
+					break;
+				}
 				case "email-test": {
 					await _espe.helpers.email_send(
 						(

source/repositories/group.ts

@@ -0,0 +1,224 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.repository.group
+{
+	
+	/**
+	 */
+	var _store : (
+		null
+		|
+		lib_plankton.storage.type_store<
+			_espe.type.group_id,
+			Record<string, any>,
+			{},
+			lib_plankton.storage.type_sql_table_autokey_search_term,
+			Record<string, any>
+		>
+	) = null;
+	
+	
+	/**
+	 */
+	function get_store(
+	) : lib_plankton.storage.type_store<
+		_espe.type.group_id,
+		Record<string, any>,
+		{},
+		lib_plankton.storage.type_sql_table_autokey_search_term,
+		Record<string, any>
+	>
+	{
+		if (_store === null)
+		{
+			_store = lib_plankton.storage.sql_table_autokey_store(
+				{
+					"database_implementation": _espe.helpers.database_implementation(),
+					"table_name": "groups",
+					"key_name": "id",
+				}
+			);
+		}
+		else
+		{
+			// do nothing
+		}	
+		return _store;
+	}
+	
+	
+	/**
+	 */
+	type type_dispersal = Record<string, any>;
+	
+	
+	/**
+	 */
+	function encode(
+		object : _espe.type.group_object
+	) : type_dispersal
+	{
+		return {
+			"name": object.name,
+		};
+	}
+	
+	
+	/**
+	 */
+	function decode(
+		dispersal : type_dispersal
+	) : _espe.type.group_object
+	{
+		return {
+			"name": dispersal.core_row["name"],
+		};
+	}
+	
+	
+	/**
+	 * @todo optimize
+	 */
+	export async function list(
+		search_term : (null | string)
+	) : Promise<
+		Array<
+			{
+				id : _espe.type.group_id;
+				preview : {
+					name : string;
+				};
+			}
+		>
+	>
+	{
+		return (
+			(await get_store().search(null))
+			.filter(
+				({"key": key, "preview": preview}) => (
+					(
+						(search_term === null)
+						||
+						(search_term.length <= 1)
+					)
+					?
+					true
+					:
+					preview["name"].toLowerCase().includes(search_term.toLowerCase())
+				)
+			)
+			.map(
+				({"key": key, "preview": preview}) => ({
+					"id": key,
+					"preview": {
+						"name": preview["name"],
+					}
+				})
+			)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function read(
+		id : _espe.type.group_id
+	) : Promise<_espe.type.group_object>
+	{
+		const core_row : Record<string, any> = await get_store().read(id);
+		
+		const dispersal : type_dispersal = {
+			"core_row": core_row,
+		};
+		
+		return decode(dispersal);
+	}
+	
+	
+	/**
+	 */
+	export async function create(
+		value : _espe.type.group_object
+	) : Promise<_espe.type.group_id>
+	{
+		const dispersal : type_dispersal = encode(value);
+		
+		// core
+		const id : _espe.type.group_id = await get_store().create(dispersal.core_row);
+		
+		return id;
+	}
+	
+	
+	/**
+	 * @todo replace groups smartly
+	 */
+	export async function update(
+		id : _espe.type.group_id,
+		value : _espe.type.group_object
+	) : Promise<void>
+	{
+		const dispersal : type_dispersal = encode(value);
+		
+		// core
+		await get_store().update(id, dispersal.core_row);		
+	}
+	
+	
+	/**
+	 */
+	export async function delete_(
+		id : _espe.type.group_id
+	) : Promise<void>
+	{
+		// core
+		await get_store().delete(id);
+	}
+	
+	
+	/**
+	 */
+	export async function dump(
+	) : Promise<
+		Array<
+			{
+				id : _espe.type.group_id;
+				object : _espe.type.group_object;
+			}
+		>
+	>
+	{
+		return (
+			Promise.all(
+				(await get_store().search(null))
+				.map(hit => hit.key)
+				.map(
+					id => (
+						read(id)
+						.then(
+							(object) => ({
+								"id": id,
+								"object": object
+							})
+						)
+					)
+				)
+			)
+		);
+	}
+	
+}
+

source/repositories/invitation.ts

@@ -0,0 +1,329 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.repository.invitation
+{
+
+	/**
+	 */
+	type type_group_chest = lib_plankton.storage.type_chest<
+		Array<any>,
+		Record<string, any>,
+		lib_plankton.database.type_description_create_table,
+		lib_plankton.storage.sql_table_common.type_sql_table_common_search_term,
+		Record<string, any>
+	>;
+	
+	
+	/**
+	 */
+	var _core_store : (
+		null
+		|
+		lib_plankton.storage.type_store<
+			_espe.type.invitation_id,
+			Record<string, any>,
+			{},
+			lib_plankton.storage.type_sql_table_autokey_search_term,
+			Record<string, any>
+		>
+	) = null;
+	
+	
+	/**
+	 */
+	var _group_chest : (
+		null
+		|
+		type_group_chest
+	) = null;
+	
+	
+	/**
+	 */
+	function get_core_store(
+	) : lib_plankton.storage.type_store<
+		_espe.type.invitation_id,
+		Record<string, any>,
+		{},
+		lib_plankton.storage.type_sql_table_autokey_search_term,
+		Record<string, any>
+	>
+	{
+		if (_core_store === null) {
+			_core_store = lib_plankton.storage.sql_table_autokey_store(
+				{
+					"database_implementation": _espe.helpers.database_implementation(),
+					"table_name": "invitations",
+					"key_name": "id",
+				}
+			);
+		}
+		else {
+			// do nothing
+		}	
+		return _core_store;
+	}
+	
+	
+	/**
+	 */
+	function get_group_chest(
+	) : type_group_chest
+	{
+		if (_group_chest === null) {
+			_group_chest = lib_plankton.storage.sql_table_common.chest(
+				{
+					"database_implementation": _espe.helpers.database_implementation(),
+					"table_name": "invitation_groups",
+					"key_names": ["invitation_id","group_name"],
+				}
+			);
+		}
+		else {
+			// do nothing
+		}
+		return _group_chest;
+	}
+	
+	
+	/**
+	 */
+	type type_dispersal = {
+		core_row : Record<string, any>;
+		group_rows : Array<
+			Record<string, any>
+		>;
+	};
+	
+	
+	/**
+	 */
+	function encode(
+		object : _espe.type.invitation_object
+	) : type_dispersal
+	{
+		return {
+			"core_row": {
+				"key": object.key,
+				"expiry": object.expiry,
+				"name_changeable": _espe.helpers.dbbool_encode(object.name_changeable),
+				"name_value": object.name_value,
+				"email_address_changeable": _espe.helpers.dbbool_encode(object.email_address_changeable),
+				"email_address_value": object.email_address_value,
+				"groups_changeable": _espe.helpers.dbbool_encode(object.groups_changeable),
+			},
+			"group_rows": (
+				(object.groups_value ?? [])
+				.map(
+					group => ({
+						"group_name": group,
+					})
+				)
+			)
+		};
+	}
+	
+	
+	/**
+	 */
+	function decode(
+		dispersal : type_dispersal
+	) : _espe.type.invitation_object
+	{
+		return {
+			"key": dispersal.core_row["key"],
+			"expiry": dispersal.core_row["expiry"],
+			"name_changeable": _espe.helpers.dbbool_decode(dispersal.core_row["name_changeable"]),
+			"name_value": dispersal.core_row["name_value"],
+			"email_address_changeable": _espe.helpers.dbbool_decode(dispersal.core_row["email_address_changeable"]),
+			"email_address_value": dispersal.core_row["email_address_value"],
+			"groups_changeable": _espe.helpers.dbbool_decode(dispersal.core_row["groups_changeable"]),
+			"groups_value": lib_plankton.list.sorted<_espe.type.group_id>(
+				dispersal.group_rows.map(row => row["group_name"]),
+				{
+					"compare_element": (group1, group2) => (group1 <= group2)
+				}
+			),
+		};
+	}
+	
+	
+	/**
+	 * @todo optimize
+	 */
+	export async function list(
+		search_term : (null | string)
+	) : Promise<
+		Array<
+			{
+				id : _espe.type.invitation_id;
+				preview : {
+					name : string;
+				};
+			}
+		>
+	>
+	{
+		return (
+			(await get_core_store().search(null))
+			.filter(
+				({"key": key, "preview": preview}) => (
+					(search_term === null)
+					?
+					true
+					:
+					(preview["key"] === search_term)
+				)
+			)
+			.map(
+				({"key": key, "preview": preview}) => ({
+					"id": key,
+					"preview": {
+						"name": preview["name_value"],
+					}
+				})
+			)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function read(
+		id : _espe.type.invitation_id
+	) : Promise<_espe.type.invitation_object>
+	{
+		const core_row : Record<string, any> = await get_core_store().read(id);
+		const group_hits : Array<{key : Record<string, any>; preview : Record<string, any>;}> = await get_group_chest().search(
+			{
+				"expression": "invitation_id = $invitation_id",
+				"arguments": {"invitation_id": id}
+			}
+		);
+		
+		const dispersal : type_dispersal = {
+			"core_row": core_row,
+			"group_rows": group_hits.map(
+				hit => ({
+					"group_name": hit.preview["group_name"]
+				})
+			),
+		};
+		
+		return decode(dispersal);
+	}
+	
+	
+	/**
+	 */
+	export async function create(
+		value : _espe.type.invitation_object
+	) : Promise<_espe.type.invitation_id>
+	{
+		const dispersal : type_dispersal = encode(value);
+		
+		// core
+		const id : _espe.type.invitation_id = await get_core_store().create(dispersal.core_row);
+		
+		// groups
+		for await (const group_row of dispersal.group_rows) {
+			await get_group_chest().write(
+				[
+					id,
+					group_row["group_name"],
+				],
+				{
+					"_dummy": null,
+				}
+			);
+		}
+		
+		return id;
+	}
+	
+	
+	/**
+	 */
+	export async function delete_(
+		id : _espe.type.invitation_id
+	) : Promise<void>
+	{
+		// groups
+		const hits : Array<{key : Array<any>; preview : Record<string, any>;}> = await get_group_chest().search(
+			{
+				"expression": "invitation_id = $invitation_id",
+				"arguments": {"invitation_id": id}
+			}
+		);
+		for (const hit of hits) {
+			await get_group_chest().delete(hit.key);
+		}
+		
+		// core
+		await get_core_store().delete(id);
+	}
+	
+	
+	/**
+	 * @todo optimize
+	 */
+	export async function identify(
+		key : _espe.type.invitation_key
+	) : Promise<_espe.type.invitation_id>
+	{
+		const hits : Array<{id : _espe.type.invitation_id; preview : any;}> = await list(key);
+		return (
+			(hits.length !== 1)
+			?
+			Promise.reject<_espe.type.invitation_id>(new Error("not found"))
+			:
+			Promise.resolve<_espe.type.invitation_id>(hits[0].id)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function dump(
+	) : Promise<
+		Array<
+			{
+				id : _espe.type.invitation_id;
+				object : _espe.type.invitation_object;
+			}
+		>
+	>
+	{
+		return (
+			Promise.all(
+				(await get_core_store().search(null))
+				.map(hit => hit.key)
+				.map(
+					id => (
+						read(id)
+						.then(
+							(object) => ({
+								"id": id,
+								"object": object
+							})
+						)
+					)
+				)
+			)
+		);
+	}
+	
+}

source/repositories/member.ts

@@ -88,7 +88,7 @@ namespace _espe.repository.member
 				{
 					"database_implementation": _espe.helpers.database_implementation(),
 					"table_name": "member_groups",
-					"key_names": ["member_id","group_name"],
+					"key_names": ["member_id","group_id"],
 				}
 			);
 		}
@@ -117,16 +117,9 @@ namespace _espe.repository.member
 	{
 		return {
 			"core_row": {
-				"membership_number": object.membership_number,
-				"name_real_value": object.name_real_value,
-				"name_real_index": object.name_real_index,
-				"email_address_private": object.email_address_private,
-				"registered": (object.registered ? 1 : 0),
-				"enabled": (object.enabled ? 1 : 0),
-				"email_use_veiled_address": (object.email_use_veiled_address ? 1 : 0),
-				"email_use_nominal_address": (object.email_use_nominal_address ? 1 : 0),
-				"email_redirect_to_private_address": (object.email_redirect_to_private_address ? 1 : 0),
-				"email_allow_sending": (object.email_allow_sending ? 1 : 0),
+				"name": object.name,
+				"email_address": object.email_address,
+				"enabled": _espe.helpers.dbbool_encode(object.enabled),
 				"password_image": object.password_image,
 				"password_change_last_attempt": object.password_change_last_attempt,
 				"password_change_token": object.password_change_token,
@@ -135,7 +128,7 @@ namespace _espe.repository.member
 				object.groups
 				.map(
 					group => ({
-						"group_name": group,
+						"group_id": group,
 					})
 				)
 			)
@@ -150,22 +143,15 @@ namespace _espe.repository.member
 	) : _espe.type.member_object
 	{
 		return {
-			"membership_number": dispersal.core_row["membership_number"],
-			"name_real_value": dispersal.core_row["name_real_value"],
-			"name_real_index": dispersal.core_row["name_real_index"],
-			"email_address_private": dispersal.core_row["email_address_private"],
-			"groups": lib_plankton.list.sorted<string>(
-				dispersal.group_rows.map(row => row["group_name"]),
+			"name": dispersal.core_row["name"],
+			"email_address": dispersal.core_row["email_address"],
+			"groups": lib_plankton.list.sorted<_espe.type.group_id>(
+				dispersal.group_rows.map(row => row["group_id"]),
 				{
 					"compare_element": (group1, group2) => (group1 <= group2)
 				}
 			),
-			"registered": (dispersal.core_row["registered"] > 0),
-			"enabled": (dispersal.core_row["enabled"] > 0),
-			"email_use_veiled_address": (dispersal.core_row["email_use_veiled_address"] > 0),
-			"email_use_nominal_address": (dispersal.core_row["email_use_nominal_address"] > 0),
-			"email_redirect_to_private_address": (dispersal.core_row["email_redirect_to_private_address"] > 0),
-			"email_allow_sending": (dispersal.core_row["email_allow_sending"] > 0),
+			"enabled": _espe.helpers.dbbool_decode(dispersal.core_row["enabled"]),
 			"password_image": dispersal.core_row["password_image"],
 			"password_change_last_attempt": dispersal.core_row["password_change_last_attempt"],
 			"password_change_token": dispersal.core_row["password_change_token"],
@@ -183,9 +169,7 @@ namespace _espe.repository.member
 			{
 				id : _espe.type.member_id;
 				preview : {
-					membership_number : string;
-					name_real_value : string;
-					name_real_index : int;
+					name : string;
 				};
 			}
 		>
@@ -200,21 +184,17 @@ namespace _espe.repository.member
 						||
 						(search_term.length <= 1)
 					)
-					? true
-					: (
-						preview["membership_number"].toLowerCase().includes(search_term.toLowerCase())
-						||
-						preview["name_real_value"].toLowerCase().includes(search_term.toLowerCase())
-					)
+					?
+					true
+					:
+					preview["name"].toLowerCase().includes(search_term.toLowerCase())
 				)
 			)
 			.map(
 				({"key": key, "preview": preview}) => ({
 					"id": key,
 					"preview": {
-						"membership_number": preview["membership_number"],
-						"name_real_value": preview["name_real_value"],
-						"name_real_index": preview["name_real_index"],
+						"name": preview["name"],
 					}
 				})
 			)
@@ -240,7 +220,7 @@ namespace _espe.repository.member
 			"core_row": core_row,
 			"group_rows": group_hits.map(
 				hit => ({
-					"group_name": hit.preview["group_name"]
+					"group_id": hit.preview["group_id"]
 				})
 			),
 		};
@@ -265,7 +245,7 @@ namespace _espe.repository.member
 			await get_group_chest().write(
 				[
 					id,
-					group_row["group_name"],
+					group_row["group_id"],
 				],
 				{
 					"_dummy": null,
@@ -293,11 +273,10 @@ namespace _espe.repository.member
 		// groups
 		const hits : Array<{key : Array<any>; preview : Record<string, any>;}> = await get_group_chest().search(
 			{
-				"expression": "member_id = $member_id",
+				"expression": "group_id = $group_id",
 				"arguments": {"member_id": id}
 			}
 		);
-		lib_plankton.log.info("update_hit", hits);
 		for (const hit of hits) {
 			await get_group_chest().delete(hit.key);
 		}
@@ -305,7 +284,7 @@ namespace _espe.repository.member
 			await get_group_chest().write(
 				[
 					id,
-					group_row["group_name"],
+					group_row["group_id"],
 				],
 				{
 					"_dummy": null,

source/repositories/name_index.ts

@@ -1,108 +0,0 @@
-/*
-Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
-Copyright (C) 2024 Christian Fraß
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
-License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
-warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program. If not, see 
-<https://www.gnu.org/licenses/>. 
- */
-
-namespace _espe.repository.name_index
-{
-	
-	/**
-	 */
-	var _chest : (
-		null
-		|
-		lib_plankton.storage.type_chest<
-			Array<any>,
-			Record<string, any>,
-			lib_plankton.database.type_description_create_table,
-			lib_plankton.storage.sql_table_common.type_sql_table_common_search_term,
-			Record<string, any>
-		>
-	) = null;
-	
-	
-	/**
-	 */
-	function get_chest(
-	) : lib_plankton.storage.type_chest<
-		Array<any>,
-		Record<string, any>,
-		lib_plankton.database.type_description_create_table,
-		lib_plankton.storage.sql_table_common.type_sql_table_common_search_term,
-		Record<string, any>
-	>
-	{
-		if (_chest === null) {
-			_chest = lib_plankton.storage.sql_table_common.chest(
-				{
-					"database_implementation": _espe.helpers.database_implementation(),
-					"table_name": "name_indices",
-					"key_names": ["name_image"],
-				}
-			);
-		}
-		else {
-			// do nothing
-		}	
-		return _chest;
-	}
-	
-	
-	/**
-	 */
-	async function get_name_image(
-		name : string
-	) : Promise<string>
-	{
-		return (
-			(! _espe.conf.get().settings.name_index.veil)
-			? name
-			: await lib_plankton.sha256.get(
-				lib_plankton.json.encode(name),
-				(_espe.conf.get().settings.name_index.salt ?? undefined)
-			)
-		);
-	}
-	
-	
-	/**
-	 */
-	export async function read(
-		name : string
-	) : Promise<int>
-	{
-		const name_image : string = await get_name_image(name);
-		let row : Record<string, any>;
-		try {
-			row = await get_chest().read([name_image]);
-			return row["index"];
-		}
-		catch (error) {
-			return 0;
-		}
-	}
-	
-	
-	/**
-	 */
-	export async function write(
-		name : string,
-		index : int
-	) : Promise<void>
-	{
-		const name_image : string = await get_name_image(name);
-		await get_chest().write([name_image], {"index": index});
-	}
-	
-}
-

source/sample.ts

@@ -0,0 +1,138 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.sample
+{
+	
+	/**
+	 */
+	type type_data = {
+		groups : Array<
+			{
+				id : int;
+				name : string;
+			}
+		>;
+		admins : Array<
+			{
+				id : int;
+				name : string;
+				email_address : (null | string);
+				password : string;
+			}
+		>;
+		members : Array<
+			{
+				id : int;
+				name : string;
+				email_address : (null | string);
+				groups : Array<int>;
+			}
+		>;
+		invitations : Array<
+			{
+				id : int;
+				name_changeable : boolean;
+				name_value : string;
+				email_address_changeable : boolean;
+				email_address_value : (null | string);
+				groups_changeable : boolean;
+				groups_value : Array<int>;
+			}
+		>;
+	};
+
+	
+	/**
+	 */
+	export async function fill(
+		data : type_data
+	) : Promise<void>
+	{
+		const track_groups : Map<int, _espe.type.group_id> = new Map<int, _espe.type.group_id>();
+		// groups
+		{
+			for (const group_raw of data.groups)
+			{
+				const group_id : _espe.type.group_id = await _espe.service.group.add(
+					{
+						"name": group_raw.name,
+					}
+				);
+				track_groups.set(group_raw.id, group_id);
+			}
+		}
+		// admins
+		{
+			for (const admin_raw of data.admins)
+			{
+				const admin_id : _espe.type.admin_id = await _espe.service.admin.add(
+					admin_raw.name,
+					admin_raw.email_address,
+					admin_raw.password,
+				);
+			}
+		}
+		// members
+		{
+			for (const member_raw of data.members)
+			{
+				const member_id : _espe.type.member_id = await _espe.service.member.project(
+					{
+						"name": member_raw.name,
+						"email_address": member_raw.email_address,
+						"groups": member_raw.groups.map(track_groups.get),
+					},
+					{
+						"silent": true,
+					}
+				);
+			}
+			/**
+			 * @todo passwords
+			 */
+		}
+		// invitations
+		{
+			for (const invitation_raw of data.invitations)
+			{
+				const result : {id : _espe.type.invitation_id; key : _espe.type.invitation_key;} = await _espe.service.invitation.create(
+					{
+						"name_changeable": invitation_raw.name_changeable,
+						"name_value": invitation_raw.name_value,
+						"email_address_changeable": invitation_raw.email_address_changeable,
+						"email_address_value": invitation_raw.email_address_value,
+						"groups_changeable": invitation_raw.groups_changeable,
+						"groups_value": invitation_raw.groups_value.map(track_groups.get),
+					}
+				);
+			}
+		}
+	}
+
+
+	/**
+	 */
+	export async function fill_by_path(
+		path : string
+	) : Promise<void>
+	{
+		const content : string = await lib_plankton.file.read(path);
+		const data : type_data = (lib_plankton.json.decode(content) as type_data);
+		await fill(data);
+	}
+
+}
+

source/services/group.ts

@@ -13,19 +13,16 @@ You should have received a copy of the GNU General Public License along with thi
 <https://www.gnu.org/licenses/>. 
  */
 
-namespace _espe.service.name_index
+namespace _espe.service.group
 {
 	
 	/**
 	 */
-	export async function next(
-		name : string
-	) : Promise<int>
+	export function add(
+		group_object : _espe.type.group_object
+	) : Promise<_espe.type.group_id>
 	{
-		const current : int = await _espe.repository.name_index.read(name);
-		const result : int = (current + 1);
-		await _espe.repository.name_index.write(name, result);
-		return result;
+		return _espe.repository.group.create(group_object);
 	}
 	
 }

source/services/invitation.ts

@@ -0,0 +1,357 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.service.invitation
+{
+	
+	/**
+	 */
+	export function list(
+	) : Promise<
+		Array<
+			{
+				id : _espe.type.invitation_id;
+				key : _espe.type.invitation_key;
+				expiry : (null | int);
+				name_value : (null | string);
+			}
+		>
+	>
+	{
+		return (
+			_espe.repository.invitation.dump()
+			.then(
+				entries => Promise.resolve(
+					entries.map(
+						entry => ({
+							"id": entry.id,
+							"key": entry.object.key,
+							"expiry": entry.object.expiry,
+							"name_value": entry.object.name_value
+						})
+					)
+				)
+			)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function create(
+		{
+			"name_changeable": name_changeable,
+			"name_value": name_value,
+			"email_address_changeable": email_address_changeable,
+			"email_address_value": email_address_value,
+			"groups_changeable": groups_changeable,
+			"groups_value": groups_value,
+		} : {
+			name_changeable : boolean;
+			name_value : string;
+			email_address_changeable : boolean;
+			email_address_value : (null | string);
+			groups_changeable : boolean;
+			groups_value : Array<_espe.type.group_id>;
+		},
+		{
+			"expiry": expiry = -1,
+			"notification_target_url_template": notification_target_url_template = null,
+			"send_immediatly": send_immediatly = true,
+		} : {
+			expiry ?: (null | int);
+			notification_target_url_template ?: (null | string);
+			send_immediatly ?: boolean;
+		} = {
+		}
+	) : Promise<{id : _espe.type.invitation_id; key : _espe.type.invitation_key}>
+	{
+		/**
+		 * @todo outsource to conf
+		 */
+		const default_lifetime : int = (60 * 60 * 24 * 7 * 2);
+		/**
+		 * @todo proper salt
+		 */
+		const invitation_key : _espe.type.invitation_key = lib_plankton.sha256.get(
+			(
+				name_value
+				+
+				"/"
+				+
+				lib_plankton.base.get_current_timestamp(true).toFixed(0)
+			),
+			"secret"
+		);
+		const invitation_object : _espe.type.invitation_object = {
+			"key": invitation_key,
+			"expiry": (
+				((expiry !== null) && (expiry < 0))
+				?
+				(lib_plankton.base.get_current_timestamp(true) + default_lifetime)
+				:
+				expiry
+			),
+			"name_changeable": name_changeable,
+			"name_value": name_value,
+			"email_address_changeable": email_address_changeable,
+			"email_address_value": email_address_value,
+			"groups_changeable": groups_changeable,
+			"groups_value": groups_value,
+		};
+		const invitation_id : _espe.type.invitation_id = await _espe.repository.invitation.create(invitation_object);
+		// send link
+		{
+			if (! send_immediatly)
+			{
+				// do nothing
+			}
+			else
+			{
+				if (
+					! (
+						(
+							(email_address_value !== null)
+							&&
+							(email_address_value !== "")
+						)
+						&&
+						(notification_target_url_template !== null)
+					)
+				)
+				{
+					lib_plankton.log._warning(
+						"espe.service.invitation.create.email.condition_unmet",
+						{
+							"details": {
+								"provided_address": email_address_value,
+								"notification_target_url_template": notification_target_url_template,
+							},
+						}
+					);
+				}
+				else
+				{
+					const url : (null | string) = _espe.helpers.frontend_url_get(
+						notification_target_url_template,
+						{
+							"key": invitation_key,
+						}
+					);
+					try {
+						await _espe.helpers.email_send(
+							[email_address_value],
+							lib_plankton.translate.get(
+								"email.invitation.subject",
+								{
+								}
+							),
+							lib_plankton.translate.get(
+								"email.invitation.body",
+								{
+									"url": (url ?? "?"),
+								}
+							),
+						);
+					}
+					catch (error)
+					{
+						lib_plankton.log._error(
+							"espe.service.invitation.create.email.could_not_be_sent",
+							{
+								"details": {
+									"provided_address": email_address_value,
+									"error": String(error),
+								},
+							}
+						);
+					}
+				}
+			}
+		}
+		return {
+			"id": invitation_id,
+			"key": invitation_key,
+		};
+	}
+	
+	
+	/**
+	 */
+	export function get_by_id(
+		id : _espe.type.invitation_id
+	) : Promise<_espe.type.invitation_object>
+	{
+		return _espe.repository.invitation.read(id)
+	}
+	
+	
+	/**
+	 */
+	function get_by_key(
+		key : _espe.type.invitation_key
+	) : Promise<_espe.type.invitation_object>
+	{
+		return (
+			_espe.repository.invitation.identify(key)
+			.then(
+				(id) => _espe.repository.invitation.read(id)
+			)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function examine(
+		key : _espe.type.invitation_key
+	) : Promise<_espe.type.invitation_object>
+	{
+		let invitation_object : (null | _espe.type.invitation_object);
+		try {
+			invitation_object = await get_by_key(key);
+		}
+		catch (error) {
+			invitation_object = null;
+		}
+		if (invitation_object === null) {
+			return Promise.reject(new Error("not found"))
+		}
+		else {
+			const now : int = lib_plankton.base.get_current_timestamp(true);
+			if ((invitation_object.expiry !== null) && (invitation_object.expiry < now)) {
+				return Promise.reject(new Error("expired"));
+			}
+			else {
+				return Promise.resolve(invitation_object);
+			}
+		}
+	}
+	
+	
+	/**
+	 */
+	export async function accept(
+		key : _espe.type.invitation_key,
+		data : {
+			name : (null | string);
+			groups : (null | Array<_espe.type.group_id>);
+			email_address : (null | string);
+			password : (null | string);
+		}
+	)
+	: Promise<
+		Array<
+			{
+				incident : string;
+				details : Record<string, any>;
+			}
+		>
+	>
+	{
+		const invitation_id : _espe.type.invitation_id = await _espe.repository.invitation.identify(key);
+		/**
+		 * might throw, but that's fine, since caught and handled in the API action
+		 */
+		const invitation_object : _espe.type.invitation_object = await _espe.repository.invitation.read(invitation_id);
+		const now : int = lib_plankton.base.get_current_timestamp(true);
+		if ((invitation_object.expiry !== null) && (invitation_object.expiry < now))
+		{
+			return Promise.reject(new Error("expired"));
+		}
+		else
+		{
+			const password : string = (
+				(
+					(data.password !== null)
+					&&
+					(data.password !== "")
+				)
+				?
+				data.password
+				:
+				_espe.service.member.generate_password()
+			);
+			const flaws_password : Array<
+				{
+					incident : string;
+					details : Record<string, any>;
+				}
+			> = _espe.service.member.validate_password(password);
+			if (flaws_password.length > 0)
+			{
+				return (
+					flaws_password
+					.map(flaw => ({"incident": ("password_" + flaw.incident), "details": flaw.details}))
+				);
+			}
+			else
+			{
+				if (
+					(invitation_object.name_value === null)
+					&&
+					(data.name === null)
+				)
+				{
+					throw (new Error("no name provided"));
+				}
+				else
+				{
+					const member_id : _espe.type.member_id = await _espe.service.member.add(
+						{
+							"name": (
+								(
+									invitation_object.name_changeable
+									?
+									data.name
+									:
+									invitation_object.name_value
+								) as string
+							),
+							"email_address": (
+								(
+									invitation_object.email_address_changeable
+									&&
+									(data.email_address !== null)
+								)
+								?
+								data.email_address
+								:
+								invitation_object.email_address_value
+							),
+							"groups": (
+								(
+									invitation_object.groups_changeable
+									?
+									data.groups
+									:
+									invitation_object.groups_value
+								)
+								??
+								[]
+							),
+							"password": password,
+						}
+					);
+					
+					await _espe.repository.invitation.delete_(invitation_id);
+					
+					return [];
+				}
+			}
+		}
+	}
+	
+}

source/services/member.ts

@@ -46,7 +46,7 @@ namespace _espe.service.member
 	
 	/**
 	 */
-	function validate_password(
+	export function validate_password(
 		password : string
 	) : Array<{incident : string; details : Record<string, any>}>
 	{
@@ -59,7 +59,7 @@ namespace _espe.service.member
 	
 	/**
 	 */
-	function generate_password(
+	export function generate_password(
 	) : string
 	{
 		return _espe.helper.password.generate(
@@ -79,7 +79,7 @@ namespace _espe.service.member
 			"{{object}}{{extension}}",
 			{
 				"object": lib_plankton.call.convey(
-					object.name_real_value,
+					object.name,
 					[
 						(x : string) => x.toLowerCase(),
 						(x : string) => x.replace(new RegExp(" ", "g"), "."),
@@ -90,11 +90,7 @@ namespace _espe.service.member
 						(x : string) => x.replace(new RegExp("[^0-9a-z-\.]", "g"), "_"),
 					]
 				),
-				"extension": (
-					(object.name_real_index <= 1)
-					? ""
-					: ("." + object.name_real_index.toFixed(0))
-				),
+				"extension": "",
 			}
 		);
 	}
@@ -107,46 +103,7 @@ namespace _espe.service.member
 		object : _espe.type.member_object
 	) : string
 	{
-		return object.name_real_value;
-	}
-	
-	
-	/**
-	 * ermittelt die verschleierte E-Mail-Adresse des Mitglieds
-	 */
-	export function email_address_veiled(
-		object : _espe.type.member_object
-	) : (null | string)
-	{
-		return (
-			(object.membership_number === null)
-			? null
-			: lib_plankton.string.coin(
-				"{{prefix}}{{membership_number}}@{{domain}}",
-				{
-					"prefix": _espe.conf.get().settings.misc.prefix_for_veiled_email_addresses,
-					"membership_number": object.membership_number,
-					"domain": _espe.conf.get().settings.organisation.domain,
-				}
-			)
-		);
-	}
-	
-	
-	/**
-	 * ermittelt die namentliche E-Mail-Adresse des Mitglieds
-	 */
-	export function email_address_nominal(
-		object : _espe.type.member_object
-	) : string
-	{
-		return lib_plankton.string.coin(
-			"{{user}}@{{domain}}",
-			{
-				"user": name_login(object),
-				"domain": _espe.conf.get().settings.organisation.domain,
-			}
-		);
+		return object.name;
 	}
 	
 	
@@ -157,15 +114,7 @@ namespace _espe.service.member
 		object : _espe.type.member_object
 	) : (null | string)
 	{
-		return (
-			object.email_use_nominal_address
-			? email_address_nominal(object)
-			: (
-				object.email_use_veiled_address
-				? email_address_veiled(object)
-				: object.email_address_private
-			)
-		);
+		return object.email_address;
 	}
 	
 	
@@ -207,13 +156,15 @@ namespace _espe.service.member
 			// do nothing
 		}
 		else {
-			if (member_object.email_address_private === null) {
+			if (member_object.email_address === null)
+			{
 				// do nothing
 			}
-			else {
+			else
+			{
 				await _espe.helpers.email_send(
 					[
-						member_object.email_address_private,
+						member_object.email_address,
 					],
 					lib_plankton.string.coin(
 						"{{head}} | {{core}}",
@@ -277,9 +228,7 @@ namespace _espe.service.member
 			{
 				id : _espe.type.member_id;
 				preview : {
-					membership_number : string;
-					name_real_value : string;
-					name_real_index : int;
+					name : string;
 				};
 			}
 		>
@@ -306,32 +255,76 @@ namespace _espe.service.member
 	 */
 	export async function project(
 		data : {
-			membership_number : (null | string);
-			name_real_value : string;
-			email_address_private : (null | string);
-			groups : Array<string>;
+			name : string;
+			email_address : (null | string);
+			groups : Array<_espe.type.group_id>;
+		},
+		{
+			"silent": silent = false,
+		} : {
+			silent ?: boolean;	
+		} = {
 		}
 	) : Promise<_espe.type.member_id>
 	{
-		const name_real_index : int = await _espe.service.name_index.next(data.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,
+			"name": data.name,
+			"email_address": data.email_address,
+			"groups": data.groups,
 			"enabled": true,
-			"email_use_veiled_address": false,
-			"email_use_nominal_address": false,
-			"email_redirect_to_private_address": false,
-			"email_allow_sending": false,
 			"password_image": null,
 			"password_change_last_attempt": null,
 			"password_change_token": null,
-			"groups": data.groups,
 		};
 		const id : _espe.type.member_id = await _espe.repository.member.create(object);
-		signal_change();
+		if (silent)
+		{
+			// do nothing
+		}
+		else
+		{
+			signal_change();
+		}
+		return id;
+	}
+	
+	
+	/**
+	 * legt ein Mitglied an
+	 */
+	export async function add(
+		data : {
+			name : string;
+			email_address : (null | string);
+			groups : Array<_espe.type.group_id>;
+			password : string;
+		},
+		{
+			"silent": silent = false,
+		} : {
+			silent ?: boolean;	
+		} = {
+		}
+	) : Promise<_espe.type.member_id>
+	{
+		const object : _espe.type.member_object = {
+			"name": data.name,
+			"email_address": data.email_address,
+			"groups": data.groups,
+			"enabled": true,
+			"password_image": await password_image(data.password),
+			"password_change_last_attempt": null,
+			"password_change_token": null,
+		};
+		const id : _espe.type.member_id = await _espe.repository.member.create(object);
+		if (silent)
+		{
+			// do nothing
+		}
+		else
+		{
+			signal_change();
+		}
 		return id;
 	}
 	
@@ -346,10 +339,12 @@ namespace _espe.service.member
 	{
 		_espe.helpers.frontend_url_check();
 		const member_object : _espe.type.member_object = await get(member_id);
-		if (member_object.email_address_private === null) {
+		if (member_object.email_address === null)
+		{
 			return null;
 		}
-		else {
+		else
+		{
 			const url : (null | string) = _espe.helpers.frontend_url_get(
 				url_template,
 				{
@@ -362,7 +357,7 @@ namespace _espe.service.member
 			else {
 				await _espe.helpers.email_send(
 					[
-						member_object.email_address_private,
+						member_object.email_address,
 					],
 					lib_plankton.string.coin(
 						"{{head}} | {{core}}",
@@ -390,176 +385,31 @@ namespace _espe.service.member
 	}
 	
 	
-	/**
-	 * gibt Daten über ein Mitglied aus, die relevant für die Registrierung sind
-	 */
-	export async function info(
-		member_id : _espe.type.member_id
-	) : Promise<
-		(
-			null
-			|
-			{
-				name_real_value : string;
-				name_real_index : int;
-				name_login : string;
-				email_address_veiled : (null | string);
-				email_address_nominal : string;
-			}
-		)
-	>
-	{
-		const member_object : _espe.type.member_object = await _espe.repository.member.read(member_id);
-		if (! member_object.registered) {
-			return {
-				"name_real_value": member_object.name_real_value,
-				"name_real_index": member_object.name_real_index,
-				"name_login": name_login(member_object),
-				"email_address_veiled": email_address_veiled(member_object),
-				"email_address_nominal": email_address_nominal(member_object),
-			};
-		}
-		else {
-			return null;
-		}
-	}
-	
-	
-	/**
-	 * führt die Registrierung für ein Mitglied durch
-	 */
-	export async function register(
-		member_id : _espe.type.member_id,
-		data : {
-			email_use_veiled_address : boolean;
-			email_use_nominal_address : boolean;
-			email_redirect_to_private_address : boolean;
-			password : (null | string);
-		},
-		options : {
-			notification_target_url_template ?: (null | string);
-		} = {}
-	) : Promise<Array<{incident : string; details : Record<string, any>;}>>
-	{
-		options = Object.assign(
-			{
-				"notification_target_url_template": null,
-			},
-			options
-		);
-		
-		const member_object : _espe.type.member_object = await get(member_id);
-		
-		let flaws : Array<{incident : string; details : Record<string, any>;}> = [];
-		let password_value : string;
-		let password_generated : boolean;
-		if (member_object.registered) {
-			flaws.push({"incident": "already_registered", "details": {}});
-			password_value = "";
-			password_generated = false;
-		}
-		else {
-			if (
-				(data.password !== null)
-				&&
-				(data.password !== "")
-			) {
-				flaws = flaws.concat(
-					validate_password(data.password)
-					.map(flaw => ({"incident": ("password_" + flaw.incident), "details": flaw.details}))
-				);
-				password_value = data.password;
-				password_generated = false;
-			}
-			else {
-				password_value = generate_password();
-				password_generated = true;
-			}
-		}
-		
-		if (flaws.length > 0) {
-			// do nothing
-		}
-		else {
-			member_object.email_use_veiled_address = data.email_use_veiled_address;
-			member_object.email_use_nominal_address = data.email_use_nominal_address;
-			member_object.email_redirect_to_private_address = data.email_redirect_to_private_address;
-			member_object.password_image = await password_image(password_value);
-			member_object.registered = true;
-			await _espe.repository.member.update(member_id, member_object);
-			signal_change();
-			{
-				const url : (null | string) = (
-					(
-						(options.notification_target_url_template === undefined)
-						||
-						(options.notification_target_url_template === null)
-					)
-					? null
-					: _espe.helpers.frontend_url_get(
-						options.notification_target_url_template,
-						{
-							"id": member_id.toFixed(0),
-						}
-					)
-				);
-				/*await*/ _espe.service.admin.notify_all(
-					lib_plankton.string.coin(
-						"{{head}} | {{core}}",
-						{
-							"head": _espe.conf.get().settings.organisation.name,
-							"core": lib_plankton.translate.get("email.registration.subject"),
-						}
-					),
-					lib_plankton.string.coin(
-						lib_plankton.translate.get("email.registration.body"),
-						{
-							"name_display": name_display(member_object),
-							"url": (url ?? "?"),
-						}
-					)
-				);
-			}
-			/*await*/ send_activation_email(member_object, {"password": password_generated ? password_value : null});
-		}
-		
-		return Promise.resolve(flaws);
-	}
-	
-	
 	/**
 	 * ändert bestimmte Daten des Mitglied
 	 */
 	export async function modify(
 		member_id : _espe.type.member_id,
 		data : {
-			email_address_private : (null | string);
-			registered : boolean;
+			email_address : (null | string);
 			enabled : boolean;
-			groups : lib_plankton.pod.type_pod<Array<string>>;
+			groups : lib_plankton.pod.type_pod<Array<_espe.type.group_id>>;
 		}
 	) : Promise<void>
 	{
 		const member_object_old : _espe.type.member_object = await get(member_id);
 		const member_object_new : _espe.type.member_object = {
-			"membership_number": member_object_old.membership_number,
-			"name_real_value": member_object_old.name_real_value,
-			"name_real_index": member_object_old.name_real_index,
-			"email_address_private": data.email_address_private,
-			"registered": data.registered,
+			"name": member_object_old.name,
+			"email_address": data.email_address,
+			"groups": (
+				lib_plankton.pod.is_filled<Array<_espe.type.group_id>>(data.groups)
+				? lib_plankton.pod.cull<Array<_espe.type.group_id>>(data.groups)
+				: member_object_old.groups
+			),
 			"enabled": data.enabled,
-			"email_use_veiled_address": member_object_old.email_use_veiled_address,
-			"email_use_nominal_address": member_object_old.email_use_nominal_address,
-			"email_redirect_to_private_address": member_object_old.email_redirect_to_private_address,
-			"email_allow_sending": member_object_old.email_allow_sending,
 			"password_image": member_object_old.password_image,
 			"password_change_last_attempt": member_object_old.password_change_last_attempt,
 			"password_change_token": member_object_old.password_change_token,
-			"groups": (
-				lib_plankton.pod.is_filled<Array<string>>(data.groups)
-				? lib_plankton.pod.cull<Array<string>>(data.groups)
-				: member_object_old.groups
-			),
 		};
 		await _espe.repository.member.update(member_id, member_object_new);
 		signal_change();
@@ -595,15 +445,13 @@ namespace _espe.service.member
 			(await _espe.repository.member.dump())
 			.filter(
 				member_entry => (
-					member_entry.object.registered
-					&&
 					member_entry.object.enabled
 					&&
 					(
 						(
-							(! (member_entry.object.email_address_private === null))
+							(! (member_entry.object.email_address === null))
 							&&
-							(member_entry.object.email_address_private === identifier)
+							(member_entry.object.email_address === identifier)
 						)
 						||
 						(name_login(member_entry.object) === identifier)
@@ -632,9 +480,9 @@ namespace _espe.service.member
 				// do nothing
 			}
 			else {
-				if (member_object_old.email_address_private === null) {
+				if (member_object_old.email_address === null) {
 					lib_plankton.log.notice(
-						"member_password_change_impossible_due_to_missing_private_email_address",
+						"member_password_change_impossible_due_to_missing_email_address",
 						{
 							"member_id": member_id,
 						}
@@ -645,20 +493,13 @@ namespace _espe.service.member
 					// keine echte Verifizierung, der Algorithmus ist aber der passende
 					const token : string = await _espe.helpers.verification_get(Math.floor(Math.random() * (1 << 24)));
 					const member_object_new : _espe.type.member_object = {
-						"membership_number": member_object_old.membership_number,
-						"name_real_value": member_object_old.name_real_value,
-						"name_real_index": member_object_old.name_real_index,
-						"email_address_private": member_object_old.email_address_private,
-						"registered": member_object_old.registered,
+						"name": member_object_old.name,
+						"email_address": member_object_old.email_address,
 						"enabled": member_object_old.enabled,
-						"email_use_veiled_address": member_object_old.email_use_veiled_address,
-						"email_use_nominal_address": member_object_old.email_use_nominal_address,
-						"email_redirect_to_private_address": member_object_old.email_redirect_to_private_address,
-						"email_allow_sending": member_object_old.email_allow_sending,
+						"groups": member_object_old.groups,
 						"password_image": member_object_old.password_image,
 						"password_change_last_attempt": now,
 						"password_change_token": token,
-						"groups": member_object_old.groups,
 					};
 					await _espe.repository.member.update(member_id, member_object_new);
 					// signal_change();
@@ -676,7 +517,7 @@ namespace _espe.service.member
 					else {
 						/*await*/ _espe.helpers.email_send(
 							[
-								member_object_old.email_address_private,
+								member_object_old.email_address,
 							],
 							lib_plankton.string.coin(
 								"{{head}} | {{core}}",
@@ -712,10 +553,12 @@ namespace _espe.service.member
 	) : Promise<Array<{incident : string; details : Record<string, any>;}>>
 	{
 		const member_object_old : _espe.type.member_object = await _espe.repository.member.read(member_id);
-		if (member_object_old.email_address_private === null) {
+		if (member_object_old.email_address === null)
+		{
 			return Promise.reject(new Error("private e-mail address missing"));
 		}
-		else {
+		else
+		{
 			let flaws : Array<{incident : string; details : Record<string, any>;}> = [];
 			if (
 				(member_object_old.password_change_token === null)
@@ -741,26 +584,19 @@ namespace _espe.service.member
 				}
 				else {
 					const member_object_new : _espe.type.member_object = {
-						"membership_number": member_object_old.membership_number,
-						"name_real_value": member_object_old.name_real_value,
-						"name_real_index": member_object_old.name_real_index,
-						"email_address_private": member_object_old.email_address_private,
-						"registered": member_object_old.registered,
+						"name": member_object_old.name,
+						"email_address": member_object_old.email_address,
+						"groups": member_object_old.groups,
 						"enabled": member_object_old.enabled,
-						"email_use_veiled_address": member_object_old.email_use_veiled_address,
-						"email_use_nominal_address": member_object_old.email_use_nominal_address,
-						"email_redirect_to_private_address": member_object_old.email_redirect_to_private_address,
-						"email_allow_sending": member_object_old.email_allow_sending,
 						"password_image": await password_image(password_new),
 						"password_change_last_attempt": member_object_old.password_change_last_attempt,
 						"password_change_token": null,
-						"groups": member_object_old.groups,
 					};
 					await _espe.repository.member.update(member_id, member_object_new);
 					signal_change();
 					await _espe.helpers.email_send(
 						[
-							member_object_old.email_address_private,
+							member_object_old.email_address,
 						],
 						lib_plankton.string.coin(
 							"{{head}} | {{core}}",
@@ -843,6 +679,9 @@ namespace _espe.service.member
 							"disabled": (! entry.object.enabled),
 							"displayname": name_display(entry.object),
 							"email": entry.email_address,
+							/**
+							 * @todo covert to string
+							 */
 							"groups": entry.object.groups,
 							"password": entry.object.password_image,
 						}

source/types.ts

@@ -16,6 +16,18 @@ You should have received a copy of the GNU General Public License along with thi
 namespace _espe.type
 {
 	
+	/**
+	 */
+	export type group_id = int;
+	
+	
+	/**
+	 */
+	export type group_object = {
+		name : string;
+	};
+	
+	
 	/**
 	 */
 	export type admin_id = int;
@@ -39,20 +51,38 @@ namespace _espe.type
 	/**
 	 */
 	export type member_object = {
-		membership_number : (null | string);
-		name_real_value : string;
-		name_real_index : int;
-		email_address_private : (null | string);
-		groups : Array<string>;
-		registered : boolean;
+		name : string;
+		email_address : (null | string);
+		groups : Array<group_id>;
 		enabled : boolean;
-		email_use_veiled_address : boolean;
-		email_use_nominal_address : boolean;
-		email_redirect_to_private_address : boolean;
-		email_allow_sending : boolean;
 		password_image : (null | string);
 		password_change_last_attempt : (null | int);
 		password_change_token : (null | string);
 	};
 	
+	
+	/**
+	 */
+	export type invitation_id = int;
+	
+	
+	/**
+	 */
+	export type invitation_key = string;
+	
+	
+	/**
+	 * @todo use "pod" instead of "changable"/"value"
+	 */
+	export type invitation_object = {
+		key : invitation_key;
+		expiry : (null | int);
+		name_changeable : boolean;
+		name_value : (null | string);
+		email_address_changeable : boolean;
+		email_address_value : (null | string);
+		groups_changeable : boolean;
+		groups_value : (null | Array<_espe.type.group_id>);
+	};
+	
 }

todo.md

@@ -0,0 +1,2 @@
+- Niederschreiben (Logging) von geheimen Angaben verhindern
+

tools/build

@@ -15,12 +15,21 @@
 
 import sys as _sys
 import os as _os
+import shutil as _shutil
 import argparse as _argparse
 
 
 def main():
 	## args
 	argument_parser = _argparse.ArgumentParser()
+	argument_parser.add_argument(
+		"-o",
+		"--output-directory",
+		type = str,
+		default = "/tmp/espe",
+		metavar = "<output-directory>",
+		help = "output directory",
+	)
 	argument_parser.add_argument(
 		"-t",
 		"--tests",
@@ -29,12 +38,12 @@ def main():
 		help = "whether to also build the test routines",
 	)
 	argument_parser.add_argument(
-		"-o",
-		"--output-directory",
+		"-c",
+		"--conf-path",
 		type = str,
-		default = "/tmp/espe",
-		metavar = "<output-directory>",
-		help = "output directory",
+		default = "",
+		metavar = "<conf-path>",
+		help = "path to conf file to be put",
 	)
 	args = argument_parser.parse_args()
 	
@@ -50,6 +59,11 @@ def main():
 			" ".join(targets),
 		)
 	)
+	if (args.conf_path != ""):
+		_shutil.copyfile(
+			args.conf_path,
+			_os.path.join(args.output_directory, "conf.json")
+		)
 	_sys.stdout.write("%s\n" % args.output_directory)
 	
 

tools/makefile

@@ -48,27 +48,31 @@ ${dir_temp}/espe-core.js ${dir_temp}/espe-core.d.ts: \
 		${dir_source}/helpers/password.ts \
 		${dir_source}/database.ts \
 		${dir_source}/types.ts \
+		${dir_source}/repositories/group.ts \
 		${dir_source}/repositories/admin.ts \
-		${dir_source}/repositories/name_index.ts \
 		${dir_source}/repositories/member.ts \
-		${dir_source}/services/name_index.ts \
-		${dir_source}/services/member.ts \
+		${dir_source}/repositories/invitation.ts \
+		${dir_source}/services/group.ts \
 		${dir_source}/services/admin.ts \
+		${dir_source}/services/member.ts \
+		${dir_source}/services/invitation.ts \
 		${dir_source}/api/base.ts \
 		${dir_source}/api/actions/meta_ping.ts \
 		${dir_source}/api/actions/meta_spec.ts \
 		${dir_source}/api/actions/session_begin.ts \
 		${dir_source}/api/actions/session_end.ts \
-		${dir_source}/api/actions/member_project.ts \
 		${dir_source}/api/actions/member_summon.ts \
-		${dir_source}/api/actions/member_info.ts \
-		${dir_source}/api/actions/member_register.ts \
 		${dir_source}/api/actions/member_list.ts \
 		${dir_source}/api/actions/member_read.ts \
 		${dir_source}/api/actions/member_modify.ts \
 		${dir_source}/api/actions/member_delete.ts \
 		${dir_source}/api/actions/member_password_change_initialize.ts \
 		${dir_source}/api/actions/member_password_change_execute.ts \
+		${dir_source}/api/actions/invite_list.ts \
+		${dir_source}/api/actions/invite_read.ts \
+		${dir_source}/api/actions/invite_create.ts \
+		${dir_source}/api/actions/invite_examine.ts \
+		${dir_source}/api/actions/invite_accept.ts \
 		${dir_source}/api/functions.ts \
 		${dir_source}/conf.ts
 	@ ${cmd_log} "compile | core …"
@@ -81,6 +85,7 @@ main: core ${dir_build}/espe data
 ${dir_temp}/espe-main-raw.js: \
 		${dir_lib}/plankton/plankton.d.ts \
 		${dir_temp}/espe-core.d.ts \
+		${dir_source}/sample.ts \
 		${dir_source}/main.ts
 	@ ${cmd_log} "compile | main …"
 	@ ${cmd_mkdir} $(dir $@)