frontend-dali/source/pages/overview/logic.ts

/*
This file is part of »dali«.

Copyright 2025 'kcf' <fenris@folksprak.org>

»dali« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

»dali« 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with »dali«. If not, see <http://www.gnu.org/licenses/>.
 */


namespace _dali.pages.overview
{
	
	/**
	 */
	lib_plankton.zoo_page.register(
		"overview",
		async (parameters, target_element) => {
			// params
			const view_mode : _dali.enum_view_mode = _dali.helpers.view_mode_determine(parameters["mode"] ?? "auto");
			const view_kind : _dali.enum_view_kind = _dali.helpers.view_kind_determine(parameters["kind"] ?? "auto");
			
			// exec
			/**
			 */
			async function get_available_calendars(
			)
			: Promise<
				Array<
					_dali.type_calendar_object_reduced_with_id
				>
			>
			{
				return (
					(await _dali.model.calendar_list())
					/*
					.filter(
						(entry) => (
							(entry.access_level === _dali.enum_access_level.edit)
							||
							(entry.access_level === _dali.enum_access_level.admin)
						)
					)
					 */
				);
			}
			
			/**
			 * @todo add return type
			 */
			async function get_entries(
				from_pit : lib_plankton.pit.type_pit,
				to_pit : lib_plankton.pit.type_pit,
				calendar_ids : Array<_dali.type_calendar_id>
			)
			: Promise<Array<_dali.type_event_object_extended>>
			{
				/**
				 * @todo do NOT wait?
				 */
				await _dali.model.sync_events(
					{
						"from": from_pit,
						"to": to_pit,
					},
					{
						"calendar_ids": calendar_ids,
					}
				);
				/**
				 * @todo filter
				 */
				return _dali.model.event_list();
			}
			
			/**
			 * @todo update listview
			 */
			async function update_sources_and_entries(
				{
					"priviliged": priviliged = null,
				}
				:
				{
					priviliged ?: (null | boolean);
				}
				=
				{
				}
			)
			: Promise<void>
			{
				await widget_sources.update({"priviliged": priviliged});
				await widget_multiview.update_entries();
			}
			
			/**
			 * @todo use priviliged?
			 * @todo update listview
			 */
			async function update_entries(
				{
					"priviliged": priviliged = null,
				}
				:
				{
					priviliged ?: (null | boolean);
				}
				=
				{
				}
			)
			: Promise<void>
			{
				await widget_multiview.update_entries();
			}
			
			/**
			 */
			async function action_create_calendar(
			)
			: Promise<void>
			{
				const widget = new _dali.widgets.calendar_edit.class_widget_calendar_edit(
					await _dali.model.group_list(),
					await _dali.model.user_list(),
					{
						"name": "",
						"hue": lib_plankton.random.generate_unit(),
						"access": {
							"public": false,
							"default_level": _dali.enum_access_level.view,
							"attributed_group": lib_plankton.map.hashmap.implementation_map<
								_dali.type_group_id,
								_dali.enum_access_level
							>(
								lib_plankton.map.hashmap.make<
									_dali.type_group_id,
									_dali.enum_access_level
								>(
									group_id => group_id.toFixed(0),
								)
							),
							"attributed_user": lib_plankton.map.hashmap.implementation_map<
								_dali.type_user_id,
								_dali.enum_access_level
							>(
								lib_plankton.map.hashmap.make<
									_dali.type_user_id,
									_dali.enum_access_level
								>(
									user_id => user_id.toFixed(0),
								)
							),
						},
						/**
						 * @todo
						 */
						"resource_id": 0,
					},
					{
						"read_only": false,
						"action_cancel": () => {
							_dali.overlay.toggle({"mode": false});
						},
						"action_add": (calendar_object) => {
							_dali.model.calendar_add(
								calendar_object
							)
							.then(
								() => {
									update_sources_and_entries();
									_dali.overlay.toggle({"mode": false});
								}
							)
							.catch(
								(reason) => {
									lib_plankton.log.warning(
										"dali.overview.calendar_add_error",
										{"reason": String(reason)}
									);
								}
							);
						},
					}
				);
				_dali.overlay.clear();
				_dali.overlay.toggle({"mode": true});
				await widget.load(_dali.overlay.get_content_element());
			}
			
			/**
			 */
			async function action_edit_calendar(
				calendar_object_reduced_with_id : type_calendar_object_reduced_with_id
			)
			: Promise<void>
			{
				const read_only : boolean = (() => {
					switch (calendar_object_reduced_with_id.access_level)
					{
						case _dali.enum_access_level.none:
						{
							throw (new Error("this event should not be visible"));
							break;
						}
						case _dali.enum_access_level.edit:
						case _dali.enum_access_level.view:
						{
							return true;
							break;
						}
						case _dali.enum_access_level.admin:
						{
							return false;
							break;
						}
					}
				}) ();
				if (read_only)
				{
					lib_plankton.log.notice(
						"dali.overview.may_not_edit_calendar",
						{
							"calendar_id": calendar_object_reduced_with_id.id,
						}
					);
				}
				else
				{
					const calendar_id : _dali.type_calendar_id = calendar_object_reduced_with_id.id;
					const calendar_object : _dali.type_calendar_object = await _dali.model.calendar_get(
						calendar_id
					);
					const widget = new _dali.widgets.calendar_edit.class_widget_calendar_edit(
						await _dali.model.group_list(),
						await _dali.model.user_list(),
						calendar_object,
						{
							"read_only": read_only,
							"action_cancel": () => {
								_dali.overlay.toggle({"mode": false});
							},
							"action_change": (data) => {
								_dali.model.calendar_change(
									calendar_id,
									data
								)
								.then(
									() => {
										update_sources_and_entries();
										_dali.overlay.toggle({"mode": false});
									}
								);
							},
							"action_remove": (data) => {
								_dali.model.calendar_remove(
									calendar_id
								)
								.then(
									() => {
										update_sources_and_entries();
										_dali.overlay.toggle({"mode": false});
									}
								);
							},
						}
					);
					_dali.overlay.clear();
					_dali.overlay.toggle({"mode": true});
					await widget.load(_dali.overlay.get_content_element());
				}
			}
			
			/**
			 * @todo unterschiedliches Verhalten bei Anmeldung?
			 */
			async function action_create_event(
				{
					"date": date = lib_plankton.pit.to_datetime(lib_plankton.pit.now()).date,
				}
				:
				{
					date ?: lib_plankton.pit.type_date;
				}
				=
				{
				}
			)
			: Promise<void>
			{
				if (! _dali.is_logged_in())
				{
					// do nothing
				}
				else
				{
					const widget = new _dali.widgets.event_edit.class_widget_event_edit(
						(await get_available_calendars()),
						{
							"calendar_id": null,
							"event_name": "",
							"event_begin": lib_plankton.call.convey(
								date,
								[
									x => ({
										"timezone_shift": 0,
										"date": date,
										"time": {"hour": 12, "minute": 0, "second": 0}
									}),
									lib_plankton.pit.from_datetime,
									x => lib_plankton.pit.shift_hour(x, 0),
									lib_plankton.pit.to_datetime,
								]
							),
							"event_end": lib_plankton.call.convey(
								date,
								[
									x => ({
										"timezone_shift": 0,
										"date": date,
										"time": {"hour": 12, "minute": 0, "second": 0}
									}),
									lib_plankton.pit.from_datetime,
									x => lib_plankton.pit.shift_hour(x, +1),
									lib_plankton.pit.to_datetime,
								]
							),
							"event_location": null,
							"event_link": null,
							"event_description": null,
						},
						{
							"read_only": false,
							"action_cancel": () => {
								_dali.overlay.toggle({"mode": false});
							},
							"action_add": (data) => {
								_dali.model.event_add(
									data.calendar_id,
									{
										"name": data.event_name,
										"begin": data.event_begin,
										"end": data.event_end,
										"location": data.event_location,
										"link": data.event_link,
										"description": data.event_description,
									}
								)
								.then(
									() => {
										update_entries();
										_dali.overlay.toggle({"mode": false});
									}
								)
								.catch(
									(reason) => {
										// todo
									}
								);
							},
						}
					);
					_dali.overlay.clear();
					_dali.overlay.toggle({"mode": true});
					await widget.load(_dali.overlay.get_content_element());
				}
			}
			
			/**
			 */
			async function action_edit_event
			(
				event_key : _dali.type_event_key
			)
			: Promise<void>
			{
				const event_object_extended : _dali.type_event_object_extended = await _dali.model.event_get(event_key);
				const read_only : boolean = (() => {
					switch (event_object_extended.access_level)
					{
						case _dali.enum_access_level.none:
						{
							throw (new Error("this event should not be visible"));
							break;
						}
						case _dali.enum_access_level.view:
						{
							return true;
							break;
						}
						case _dali.enum_access_level.edit:
						case _dali.enum_access_level.admin:
						{
							return false;
							break;
						}
					}
				}) ();
				const widget = new _dali.widgets.event_edit.class_widget_event_edit(
					(await get_available_calendars()),
					{
						"calendar_id": event_object_extended.calendar_id,
						"event_name": event_object_extended.event_object.name,
						"event_begin": event_object_extended.event_object.begin,
						"event_end": event_object_extended.event_object.end,
						"event_location": event_object_extended.event_object.location,
						"event_link": event_object_extended.event_object.link,
						"event_description": event_object_extended.event_object.description,
					},
					{
						"read_only": read_only,
						"action_cancel": () => {
							_dali.overlay.toggle({"mode": false});
						},
						"action_change": (data) => {
							_dali.model.event_change(
								event_key,
								{
									"name": data.event_name,
									"begin": data.event_begin,
									"end": data.event_end,
									"location": data.event_location,
									"link": data.event_link,
									"description": data.event_description,
								}
							)
							.then(
								() => {
									update_entries();
									_dali.overlay.toggle({"mode": false});
								}
							)
							.catch(
								(reason) => {
									lib_plankton.log.warning(
										"dali.overview.event_change.error",
										{"reason": String(reason)}
									);
								}
							);
						},
						"action_remove": () => {
							_dali.model.event_remove(
								event_key
							)
							.then(
								() => {
									update_entries();
									_dali.overlay.toggle({"mode": false});
								}
							)
							.catch(
								(reason) => {
									lib_plankton.log.warning(
										"dali.overview.event_remove_error",
										{"reason": String(reason)}
									);
								}
							);
						},
					}
				);
				
				_dali.overlay.clear();
				_dali.overlay.toggle({"mode": true});
				await widget.load(_dali.overlay.get_content_element());
			}
			
			const widget_sources : _dali.widgets.sources.class_widget_sources = (
				new _dali.widgets.sources.class_widget_sources(
					_dali.model.calendar_list,
					{
						"initial_priviliged": _dali.is_logged_in(),
						"action_add": action_create_calendar,
						"action_select": (entry) => action_edit_calendar(entry),
						"action_toggle": (entry, mode) => {
							widget_multiview.toggle_calendar_visibilty(entry.id, {"mode": mode});
						},
					}
				)
			);
			const widget_multiview : _dali.widgets.multiview.class_widget_multiview = (
				new _dali.widgets.multiview.class_widget_multiview(
					get_entries,
					{
						"initial_view_mode": view_mode,
						"weekview_initial_vertical": (view_kind === _dali.enum_view_kind.touch),
						"action_create_event": action_create_event,
						"action_edit_event": action_edit_event,
					}
				)
			);
			
			target_element.innerHTML = await _dali.helpers.template_coin(
				"overview",
				"main",
				{
				}
			);
			
			switch (view_kind)
			{
				case _dali.enum_view_kind.regular:
				{
					const widget_slider = new lib_plankton.zoo_widget.class_slider(
						[
							new lib_plankton.zoo_widget.class_bunch(
								[
									widget_sources,
									widget_multiview,
								]
							),
						],
						{
							"threshold": 100,
							"initial_index": 1,
						}						
					);
					await widget_slider.load(target_element.querySelector("#overview-body"));
					break;
				}
				case _dali.enum_view_kind.touch:
				{
					const widget_slider = new lib_plankton.zoo_widget.class_slider(
						[
							widget_sources,
							widget_multiview,
						],
						{
							"threshold": 100,
							"initial_index": 2,
						}						
					);
					await widget_slider.load(target_element.querySelector("#overview-body"));
					break;
				}
			}
						
			// hint
			{
				const dom_hint = target_element.querySelector("#overview-hint");
				dom_hint.textContent = lib_plankton.translate.get("page.overview.login_hint");
				dom_hint.classList.toggle("overview-hint-hidden", _dali.is_logged_in());
			}
			
			_dali.model.listen_reset(
				async (priviliged) => {
					update_sources_and_entries({"priviliged": priviliged});
					target_element.querySelector("#overview-hint").classList.toggle("overview-hint-hidden", priviliged);
				}
			);
			
			return Promise.resolve<void>(undefined);
		},
	);

}