backend/source/repositories/resource.ts

namespace _zeitbild.repository.resource
{
	
	/**
	 */
	var _local_resource_core_store : (
		null
		|
		lib_plankton.storage.type_store<
			int,
			Record<string, any>,
			{},
			lib_plankton.storage.type_sql_table_autokey_search_term,
			Record<string, any>
		>
	) = null;
	
	
	/**
	 */
	var _local_resource_event_store : (
		null
		|
		lib_plankton.storage.type_store<
			int,
			Record<string, any>,
			{},
			lib_plankton.storage.type_sql_table_autokey_search_term,
			Record<string, any>
		>
	) = null;
	
	
	/**
	 */
	var _caldav_resource_store : (
		null
		|
		lib_plankton.storage.type_store<
			int,
			Record<string, any>,
			{},
			lib_plankton.storage.type_sql_table_autokey_search_term,
			Record<string, any>
		>
	) = null;
	
	
	/**
	 */
	var _resource_core_store : (
		null
		|
		lib_plankton.storage.type_store<
			_zeitbild.type.resource_id,
			Record<string, any>,
			{},
			lib_plankton.storage.type_sql_table_autokey_search_term,
			Record<string, any>
		>
	) = null;
	
	
	/**
	 */
	function get_local_resource_core_store(
	) : lib_plankton.storage.type_store<
		int,
		Record<string, any>,
		{},
		lib_plankton.storage.type_sql_table_autokey_search_term,
		Record<string, any>
	>
	{
		if (_local_resource_core_store === null) {
			_local_resource_core_store = lib_plankton.storage.sql_table_autokey_store(
				{
					"database_implementation": _zeitbild.database.get_implementation(),
					"table_name": "local_resources",
					"key_name": "id",
				}
			);
		}
		else {
			// do nothing
		}	
		return _local_resource_core_store;
	}
	
	
	/**
	 */
	function get_local_resource_event_store(
	) : lib_plankton.storage.type_store<
		int,
		Record<string, any>,
		{},
		lib_plankton.storage.type_sql_table_autokey_search_term,
		Record<string, any>
	>
	{
		if (_local_resource_event_store === null) {
			_local_resource_event_store = lib_plankton.storage.sql_table_autokey_store(
				{
					"database_implementation": _zeitbild.database.get_implementation(),
					"table_name": "local_resource_events",
					"key_name": "id",
				}
			);
		}
		else {
			// do nothing
		}	
		return _local_resource_event_store;
	}
	
	
	/**
	 */
	function get_caldav_resource_store(
	) : lib_plankton.storage.type_store<
		int,
		Record<string, any>,
		{},
		lib_plankton.storage.type_sql_table_autokey_search_term,
		Record<string, any>
	>
	{
		if (_caldav_resource_store === null) {
			_caldav_resource_store = lib_plankton.storage.sql_table_autokey_store(
				{
					"database_implementation": _zeitbild.database.get_implementation(),
					"table_name": "caldav_resources",
					"key_name": "id",
				}
			);
		}
		else {
			// do nothing
		}	
		return _caldav_resource_store;
	}
	
	
	/**
	 */
	function get_resource_core_store(
	) : lib_plankton.storage.type_store<
		_zeitbild.type.resource_id,
		Record<string, any>,
		{},
		lib_plankton.storage.type_sql_table_autokey_search_term,
		Record<string, any>
	>
	{
		if (_resource_core_store === null) {
			_resource_core_store = lib_plankton.storage.sql_table_autokey_store(
				{
					"database_implementation": _zeitbild.database.get_implementation(),
					"table_name": "resources",
					"key_name": "id",
				}
			);
		}
		else {
			// do nothing
		}	
		return _resource_core_store;
	}
	
	
	/**
	 */
	/*
	function encode_resource_core(
		stuff : {
			object : _zeitbild.type.resource_object;
			sub_id : int;
		}
	) : Record<string, any>
	{
		return {
			"kind": stuff.object.kind,
			"sub_id": stuff.sub_id
		};
	}
	 */
	
	
	/**
	 * @todo data
	 */
	/*
	function decode_resource_core(
		row : Record<string, any>
	) : {
		object : _zeitbild.type.resource_object;
		sub_id : int;
	}
	{
		return {
			"object": {
				"kind": row["kind"],
				"data": null,
			},
			"sub_id": row["sub_id"],
		};
	}
	 */
	
	
	/**
	 */
	function encode_event(
		event : _zeitbild.type.event_object,
		local_resource_id : int
	) : Record<string, any>
	{
		/*
		const decode_datetime : ((datetime_raw : string) => _zeitbild.helpers.type_datetime) = ((datetime_raw) => {
			const parts : Array<string> = datetime_raw.split("|");
			const timezone_shift : int = parseInt(parts[0]);
			if (parts[1].length <= 10) {
				return {
					"timezone_shift": timezone_shift,
					"date": {
						"year": parseInt(parts[1].slice(0, 4)),
						"month": parseInt(parts[1].slice(5, 7)),
						"day": parseInt(parts[1].slice(8, 10)),
					},
					"time": null
				};
			}
			else {
				return {
					"timezone_shift": timezone_shift,
					"date": {
						"year": parseInt(parts[1].slice(0, 4)),
						"month": parseInt(parts[1].slice(5, 7)),
						"day": parseInt(parts[1].slice(8, 10)),
					},
					"time": {
						"hour": parseInt(parts[1].slice(11, 13)),
						"minute": parseInt(parts[1].slice(14, 16)),
						"second": parseInt(parts[1].slice(17, 19)),
					}
				};
			}
		});
		 */
		const encode_datetime : ((datetime : _zeitbild.helpers.type_datetime) => string) = ((datetime) => {
			return lib_plankton.string.coin(
				"{{timezone_shift}}|{{date}}{{macro_time}}",
				{
					"timezone_shift": datetime.timezone_shift.toFixed(0).padStart(2, "0"),
					"date": lib_plankton.string.coin(
						"{{year}}-{{month}}-{{day}}",
						{
							"year": datetime.date.year.toFixed(0).padStart(4, "0"),
							"month": datetime.date.month.toFixed(0).padStart(2, "0"),
							"day": datetime.date.day.toFixed(0).padStart(2, "0"),
						}
					),
					"macro_time": (
						(datetime.time === null)
						?
						""
						:
						lib_plankton.string.coin(
							"T{{hour}}:{{minute}}:{{second}}",
							{
								"hour": datetime.time.hour.toFixed(0).padStart(2, "0"),
								"minute": datetime.time.minute.toFixed(0).padStart(2, "0"),
								"second": datetime.time.second.toFixed(0).padStart(2, "0"),
							}
						)
					),
				}
			);
		});
		return {
			"local_resource_id": local_resource_id,
			"name": event.name,
			"begin": encode_datetime(event.begin),
			"end": (
				(event.end === null)
				?
				null
				:
				encode_datetime(event.end)
			),
			"location": event.location,
			"description": event.description,
		}
	}
	
	
	/**
	 */
	function decode_event(
		row : Record<string, any>
	) : _zeitbild.type.event_object
	{
		const decode_datetime : ((datetime_raw : string) => _zeitbild.helpers.type_datetime) = ((datetime_raw) => {
			const parts : Array<string> = datetime_raw.split("|");
			const timezone_shift : int = parseInt(parts[0]);
			if (parts[1].length <= 10) {
				return {
					"timezone_shift": timezone_shift,
					"date": {
						"year": parseInt(parts[1].slice(0, 4)),
						"month": parseInt(parts[1].slice(5, 7)),
						"day": parseInt(parts[1].slice(8, 10)),
					},
					"time": null
				};
			}
			else {
				return {
					"timezone_shift": timezone_shift,
					"date": {
						"year": parseInt(parts[1].slice(0, 4)),
						"month": parseInt(parts[1].slice(5, 7)),
						"day": parseInt(parts[1].slice(8, 10)),
					},
					"time": {
						"hour": parseInt(parts[1].slice(11, 13)),
						"minute": parseInt(parts[1].slice(14, 16)),
						"second": parseInt(parts[1].slice(17, 19)),
					}
				};
			}
		});
		return {
			"name": row["name"],
			"begin": decode_datetime(row["begin"]),
			"end": (
				(row["end"] === null)
				?
				null
				:
				decode_datetime(row["end"])
			),
			"location": row["location"],
			"description": row["description"],
		};
	}
	
	
	/**
	 */
	export async function read(
		resource_id : _zeitbild.type.resource_id
	) : Promise<_zeitbild.type.resource_object>
	{
		const dataset_core : Record<string, any> = await get_resource_core_store().read(resource_id);
		switch (dataset_core.kind) {
			case "local": {
				const dataset_extra_local_core : Record<string, any> = await get_local_resource_core_store().read(dataset_core.sub_id);
				const datasets_extra_local_events : Array<Record<string, any>> = await get_local_resource_event_store().search(
					{
						"expression": "(local_resource_id = $local_resource_id)",
						"arguments": {
							"local_resource_id": dataset_core.sub_id,
						}
					}
				);
				return Promise.resolve<_zeitbild.type.resource_object>(
					{
						"kind": "local",
						"data": {
							"events": datasets_extra_local_events.map(x => decode_event(x.preview)),
						}
					}
				);
			}
			case "caldav": {
				const dataset_extra_caldav : Record<string, any> = await get_caldav_resource_store().read(dataset_core.sub_id);
				return Promise.resolve<_zeitbild.type.resource_object>(
					{
						"kind": "caldav",
						"data": {
							"url": dataset_extra_caldav["url"],
							"read_only": dataset_extra_caldav["read_only"],
						}
					}
				);
				break;
			}
			default: {
				return Promise.reject<_zeitbild.type.resource_object>(
					new Error("invalid resource kind: " + dataset_core.kind)
				);
				break;
			}
		}
	}
	
	
	/**
	 */
	export async function create(
		resource_object : _zeitbild.type.resource_object
	) : Promise<_zeitbild.type.resource_id>
	{
		switch (resource_object.kind) {
			case "local": {
				const local_resource_id : int = await get_local_resource_core_store().create(
					{
						"_dummy": null,
					}
				);
				for await (const event of resource_object.data.events) {
					get_local_resource_event_store().create(
						encode_event(
							event,
							local_resource_id
						)
					)
				}
				const resource_id : _zeitbild.type.resource_id = await get_resource_core_store().create(
					{
						"kind": "local",
						"sub_id": local_resource_id,
					}
				);
				return Promise.resolve<_zeitbild.type.resource_id>(resource_id);
				break;
			}
			case "caldav": {
				const caldav_resource_id : int = await get_caldav_resource_store().create(
					{
						"url": resource_object.data.url,
						"read_only": resource_object.data.read_only,
					}
				);
				const resource_id : _zeitbild.type.resource_id = await get_resource_core_store().create(
					{
						"kind": "caldav",
						"sub_id": caldav_resource_id,
					}
				);
				return Promise.resolve<_zeitbild.type.resource_id>(resource_id);
				break;
			}
			default: {
				throw (new Error("not implemended"));
				break;
			}
		}
	}
	
}