calendar

5.0 KB

1. // lib/events.hl — THE EVENTS (ticket calendar#2). One hl:mpackdb table, storage/mpackdb/events.db, pk @id, index owner.
2. // A record IS a WorldAPI Event (https://worldapi.org/standards/event): the `$`-keys `$type $version $kind $title
3. // $description $start $end $timezone $location $status $visibility $created $updated`, plus `owner` (the users @id)
4. // and the @id. Appointment: `$start`/`$end` local wall-clock `YYYY-MM-DDTHH:MM:SS` in `$timezone`. All-day:
5. // `$kind = 'allday'`, `$start` a date, `$end` the EXCLUSIVE end date (left out for one day). Every event is
6. // `$visibility = 'private'`: every function takes the owner's user id and reaches only that user's events.
7. // Every write to the table is here. Looked up in lib/events-helpers.hl: build (page fields → record), viewOf (record →
8. // what the page shows), isLocalId, byStart. The default reminders are lib/settings.hl.
9. import { MPackDB } from 'hl:mpackdb'
10. import { timestamp } from 'hl:time'
11. import { storageDir, countOfList } from './util.hl'
12. import { build, viewOf, isLocalId, byStart } from './events-helpers.hl'
13. import { defaultsOf } from './settings.hl'
14. import { before } from '../components/month-view/dates.hl'
15. import { describe, shift } from '../components/month-view/reminders.hl'
16. import { serverToday } from '../components/month-view/clock.hl'
18. static eventsTable = new MPackDB(file = storageDir + '/events.db', primaryKey = '@id', indexes = ['owner'])
20. static ownEvent = (userId, id) => {
21. if (id == null || hlTypeName(id) != 'String' || id == '') { return null }
22. e = eventsTable.fetch(id)
23. if (e == null || e.owner != userId) { return null }
24. return e
25. }
27. // the owner's events that touch first..last (dates), by start
28. static eventsBetween = (userId, first, last) => {
29. found = eventsTable.find('owner', userId)
30. n = countOfList(found)
31. views = []
32. let i = 0
33. while (i < n) {
34. let v = viewOf(found[i])
35. if (!before(v.last, first) && !before(last, v.first)) { views.push(v) }
36. i = i + 1
37. }
38. return byStart(views)
39. }
41. static realId = (userId, id) => {
42. if (!isLocalId(id)) { return id }
43. found = eventsTable.find('owner', userId)
44. n = countOfList(found)
45. let i = 0
46. while (i < n) {
47. if (found[i].ref == id) { return found[i].id }
48. i = i + 1
49. }
50. return null
51. }
53. // create, or change when the fields name an event (real or temporary id)
54. static saveEvent = (userId, b) => {
55. if (b != null && hlTypeName(b) == 'Hybrid' && b.id != null && b.id != '') {
56. id = realId(userId, b.id)
57. if (id != null) { return changeEvent(userId, id, b) }
58. if (!isLocalId(b.id)) { return changeEvent(userId, b.id, b) }
59. }
60. return createEvent(userId, b)
61. }
63. static createEvent = (userId, b) => {
64. x = build(b)
65. if (x.error != null) { return x }
66. r = x.record
67. t = timestamp()
68. r['$created'] = t
69. r['$updated'] = t
70. r.owner = userId
71. if (isLocalId(b.id)) { r.ref = b.id }
72. let id = eventsTable.put(r)
73. if (id == null) { return { error = 'could not store the event: ' + eventsTable.lastError() } }
74. return { id = id }
75. }
77. static changeEvent = (userId, id, b) => {
78. old = ownEvent(userId, id)
79. if (old == null) { return { error = 'no such event' } }
80. x = build(b)
81. if (x.error != null) { return x }
82. r = x.record
83. r['$created'] = old['$created']
84. r['$updated'] = timestamp()
85. r.owner = userId
86. if (old.ref != null) { r.ref = old.ref }
87. r.id = id
88. eventsTable.update(id, r)
89. return { id = id }
90. }
92. static deleteEvent = (userId, given) => {
93. id = realId(userId, given)
94. old = ownEvent(userId, id)
95. if (old == null) { return { error = 'no such event' } }
96. eventsTable.delete(id)
97. return { ok = true }
98. }
100. // ---- the reminders still to come ------------------------------------------------------------------------
102. // the owner's events starting first..last with the reminders that apply (own, else the defaults); timed and all-day
103. static upcoming = (userId, first, last) => {
104. defaults = defaultsOf(userId)
105. found = eventsTable.find('owner', userId)
106. n = countOfList(found)
107. out = []
108. let i = 0
109. while (i < n) {
110. let v = viewOf(found[i])
111. if (!before(v.first, first) && !before(last, v.first)) {
112. let list = { id = v.id title = v.title allDay = v.allDay startDate = v.startDate startTime = v.startTime place = v.place zone = v.zone rows = v.custom ? v.rows : defaults }
113. out.push(list)
114. }
115. i = i + 1
116. }
117. return out
118. }
120. // the events with the reminders that apply, from two days back to nine days ahead (what the browser plans its notifications from)
121. static soonOf = (userId) => {
122. t = serverToday()
123. return upcoming(userId, shift(t, -2), shift(t, 9))
124. }
126. // ---- what the faces answer (components/calendar.hl) -----------------------------------------------------
128. // the events of the six weeks on screen, the defaults (text and rows) and the reminders still to come
129. static calendarView = (userId, first, last) => {
130. return { events = eventsBetween(userId, first, last) defaults = describe(defaultsOf(userId)) soon = soonOf(userId) defaultRows = defaultsOf(userId) }
131. }
133. // the settings editor: the default reminders as rows, their text and the reminders still to come
134. static settingsView = (userId) => {
135. return { rows = defaultsOf(userId) defaults = describe(defaultsOf(userId)) soon = soonOf(userId) defaultRows = defaultsOf(userId) }
136. }