580 lines
14 KiB
TypeScript
580 lines
14 KiB
TypeScript
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");
|
|
|
|
// exec
|
|
target_element.innerHTML = await _dali.helpers.template_coin(
|
|
"overview",
|
|
"default",
|
|
{
|
|
}
|
|
);
|
|
|
|
let widget_mode_switcher : lib_plankton.zoo_widget.interface_widget;
|
|
let widget_sources : _dali.widgets.sources.class_widget_sources;
|
|
let widget_weekview : _dali.widgets.weekview.class_widget_weekview;
|
|
let widget_listview : _dali.widgets.listview.class_widget_listview;
|
|
|
|
/**
|
|
* @todo ordentlich machen (nicht nur week und list)
|
|
*/
|
|
function set_view_mode
|
|
(
|
|
view_mode : _dali.enum_view_mode
|
|
)
|
|
: void
|
|
{
|
|
const compact : boolean = (view_mode !== _dali.enum_view_mode.week);
|
|
target_element.querySelector("#overview").classList.toggle("overview-compact", compact);
|
|
}
|
|
|
|
/**
|
|
*/
|
|
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_weekview.update_entries();
|
|
}
|
|
|
|
/**
|
|
* @todo use priviliged?
|
|
* @todo update listview
|
|
*/
|
|
async function update_entries(
|
|
{
|
|
"priviliged": priviliged = null,
|
|
}
|
|
:
|
|
{
|
|
priviliged ?: (null | boolean);
|
|
}
|
|
=
|
|
{
|
|
}
|
|
)
|
|
: Promise<void>
|
|
{
|
|
await widget_weekview.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());
|
|
}
|
|
|
|
// 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());
|
|
}
|
|
|
|
// mode switcher
|
|
{
|
|
widget_mode_switcher = new _dali.widgets.mode_switcher.class_widget_mode_switcher(
|
|
[
|
|
{
|
|
"mode": _dali.enum_view_mode.week,
|
|
"label": lib_plankton.translate.get("page.overview.mode.week"),
|
|
},
|
|
{
|
|
"mode": _dali.enum_view_mode.list,
|
|
"label": lib_plankton.translate.get("page.overview.mode.list"),
|
|
},
|
|
],
|
|
{
|
|
"initial_selection": view_mode,
|
|
"action_change": (view_mode) => {
|
|
lib_plankton.zoo_page.set(
|
|
{
|
|
"name": "overview",
|
|
"parameters": {
|
|
"mode": _dali.view_mode_encode(view_mode),
|
|
}
|
|
}
|
|
);
|
|
set_view_mode(view_mode);
|
|
}
|
|
}
|
|
);
|
|
set_view_mode(view_mode);
|
|
await widget_mode_switcher.load(target_element.querySelector("#overview-mode"));
|
|
}
|
|
|
|
// sources
|
|
{
|
|
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_weekview.toggle_visibility(entry.id, {"mode": mode});
|
|
widget_listview.toggle_visibility(entry.id, {"mode": mode});
|
|
},
|
|
}
|
|
);
|
|
await widget_sources.load(target_element.querySelector("#overview-pane-left"));
|
|
}
|
|
|
|
// weekview
|
|
{
|
|
widget_weekview = (
|
|
new _dali.widgets.weekview.class_widget_weekview(
|
|
get_entries,
|
|
{
|
|
"action_select_event": (event_key) => action_edit_event(event_key),
|
|
"action_select_day": (date) => action_create_event({"date": date}),
|
|
}
|
|
)
|
|
);
|
|
await widget_weekview.load(target_element.querySelector("#overview-pane-right-weekview"));
|
|
}
|
|
|
|
// listview
|
|
{
|
|
widget_listview = (
|
|
new _dali.widgets.listview.class_widget_listview(
|
|
get_entries,
|
|
{
|
|
"action_select": (event_key) => action_edit_event(event_key),
|
|
"action_add": () => action_create_event(),
|
|
}
|
|
)
|
|
);
|
|
await widget_listview.load(target_element.querySelector("#overview-pane-right-listview"));
|
|
}
|
|
|
|
_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);
|
|
},
|
|
);
|
|
|
|
}
|