ident

17.5 KB

1. // lib/notify.hl — NOTIFICATIONS (piece 4 of 6, ticket ident#6; CONCEPT.md "Notifications" and
2. // "Per-app page"). Statics only, the server realm. The routes are lib/api.hl (apiKinds, apiNotify), the pages
3. // components/inbox.hl (/inbox) and components/appsettings.hl (/inbox/<connection id>). Every write to the
4. // kinds, settings and notifications tables is here; the checks, orders and stamps: lib/notify-helpers.hl.
5. // DELIVERY IS NOT HERE (pieces 5/6: the daily mail at 17:00, urgent at once, push): this
6. // file only STORES what delivery needs — per notification the channels and whether each
7. // was delivered — and sends nothing.
8. //
9. // kindsTable pk @id index !pair, @app
10. // A NOTIFICATION KIND of an app, by its name:
11. // { pair = '<app @id>:<name>', app, name, registered (bool), push, email
12. // (the app's PRESET channels, bools), created, updated }
13. // registered = the app registered it (POST /api/kinds). A name the app
14. // sends WITHOUT registering it gets a row with registered = false,
15. // push = false, email = true (CONCEPT: "every notification goes to the
16. // daily mail"; push only after registering the kind).
17. // settingsTable pk @id index !pair, @connection
18. // THE USER'S SWITCHES per connection (= app + identity) and THE
19. // EFFECTIVE SETTINGS:
20. // a kind: { pair = '<connection @id>:<kind name>', connection, account,
21. // kind = name, userPush, userEmail ('' = the app's preset,
22. // 'on', 'off'), push, email (EFFECTIVE, bools), updated }
23. // the override for all (kind = ''):
24. // { pair = '<connection @id>:', connection, account, kind = '',
25. // active (bool), push, email (bools), updated }
26. // notificationsTable pk @id index @account, @connection
27. // { account, identity, app, connection (@ids), name, text, icon, link
28. // ('' = none), urgent, created, read, readAt,
29. // push (bool: to be pushed), mail ('daily' | 'now' | 'none'),
30. // pushSent, mailSent (bools, false until delivery does it) }
31. //
32. // EFFECTIVE (per connection and kind): the app's preset, replaced by the user's switch
33. // where the user set one; the override, when active, replaces both for every kind; and
34. // push is always off for a kind the app has not registered.
35. // THE CHANNELS OF A NOTIFICATION, fixed when it arrives:
36. // normal: push = effective push; mail = 'daily' if effective email, else 'none'
37. // urgent: push if effective push AND the user has a push device (none exist before
38. // piece 6, so never yet), else mail = 'now' — when the user left push or email
39. // on for that kind; with both off: 'none' (the inbox only)
40. // Every notification lands in the inbox, whatever the channels.
41. import { MPackDB } from 'hl:mpackdb'
42. import { now } from 'hl:time'
43. import { dir, countOf, first, merged, isId, isList, isObject, str } from './util.hl'
44. import { bool, onOff, stamp, newestFirst, byName, checkKindName, checkText, checkUrl, switchValue, kindRowOut } from './notify-helpers.hl'
45. import { identityRecords, identityRecord, accountOfIdentity } from './identities.hl'
46. import { labelOf } from './identities-helpers.hl'
47. import { appsTable, connectionsTable, appOfSecret, connectionByAnyId } from './apps.hl'
49. static kindsTable = new MPackDB(file = dir + '/kinds.db', primaryKey = '@id', indexes = ['!pair' '@app'])
50. static settingsTable = new MPackDB(file = dir + '/settings.db', primaryKey = '@id', indexes = ['!pair' '@connection'])
51. static notificationsTable = new MPackDB(file = dir + '/notifications.db', primaryKey = '@id', indexes = ['@account' '@connection'])
53. static maxKindsPerCall = 50
54. static maxKindsPerApp = 200
55. static inboxLimit = 200
57. // ---- THE KINDS (the app, with its key + secret: lib/apps.hl appOfSecret) ---------------
58. static kindOf = (appId, name) => { return first(kindsTable.find('pair', appId + ':' + name)) }
59. static registeredKinds = (appId) => {
60. let out = []
61. for (k of byName(kindsTable.find('app', appId))) { if (bool(k.registered)) { out.push(kindRowOut(k)) } }
62. return out
63. }
65. // THE APP REGISTERS KINDS: `kinds` = [{ name, push, email }] (strict). A name already
66. // there gets the new preset (and counts as registered from now on). Answers
67. // { kinds (every registered one) } or { status, error }.
68. static kindFields = ['name' 'push' 'email']
69. static registerKinds = (appRec, kinds) => {
70. if (!isList(kinds)) { return { status = 400 error = 'field kinds must be a list' } }
71. if (kinds.length > maxKindsPerCall) { return { status = 400 error = 'at most ' + maxKindsPerCall + ' kinds per call' } }
72. // check ALL first: a refused call writes nothing
73. let clean = []
74. let names = []
75. let n = 0
76. for (k of kinds) {
77. let at = 'kinds[' + n + ']'
78. if (!isObject(k)) { return { status = 400 error = at + ' must be an object' } }
79. for (f of k.keys()) {
80. if (!kindFields.includes(f)) { return { status = 400 error = 'unknown field: ' + at + '.' + f } }
81. }
82. for (f of kindFields) {
83. if (k[f] == null) { return { status = 400 error = 'missing field: ' + at + '.' + f } }
84. }
85. let c = checkKindName(k.name, at + '.name')
86. if (c.error != null) { return { status = 400 error = c.error } }
87. if (hlTypeName(k.push) != 'Boolean') { return { status = 400 error = 'field ' + at + '.push must be a boolean' } }
88. if (hlTypeName(k.email) != 'Boolean') { return { status = 400 error = 'field ' + at + '.email must be a boolean' } }
89. if (names.includes(c.name)) { return { status = 400 error = 'the name ' + c.name + ' is in the list twice' } }
90. names.push(c.name)
91. clean.push({ name = c.name push = k.push email = k.email })
92. n = n + 1
93. }
94. let have = countOf(kindsTable.find('app', appRec.id))
95. let fresh = 0
96. for (c of clean) { if (kindOf(appRec.id, c.name) == null) { fresh = fresh + 1 } }
97. if (have + fresh > maxKindsPerApp) { return { status = 400 error = 'an app has at most ' + maxKindsPerApp + ' kinds' } }
98. for (c of clean) {
99. let k = kindOf(appRec.id, c.name)
100. if (k == null) {
101. kindsTable.put({ pair = appRec.id + ':' + c.name app = appRec.id name = c.name registered = true push = c.push email = c.email created = now() updated = now() })
102. } else {
103. kindsTable.update(k.id, merged(k, { registered = true push = c.push email = c.email updated = now() }))
104. }
105. }
106. // the presets changed: every connection's stored effective settings follow
107. let conns = connectionsTable.find('app', appRec.id)
108. if (countOf(conns) > 0) { for (conn of conns) { storeEffective(conn) } }
109. return { kinds = registeredKinds(appRec.id) }
110. }
112. // ---- effective settings ----------------------------------------------------------------
113. static settingOf = (connId, kindName) => { return first(settingsTable.find('pair', connId + ':' + kindName)) }
114. static overrideOf = (connId) => { return settingOf(connId, '') }
115. // the effective { push, email } of one kind for one connection
116. static effectiveOf = (kind, userRow, ovr) => {
117. let registered = bool(kind.registered)
118. let push = switchValue(userRow != null ? userRow.userPush : '', registered && bool(kind.push))
119. let email = switchValue(userRow != null ? userRow.userEmail : '', bool(kind.email))
120. if (ovr != null && bool(ovr.active)) {
121. push = bool(ovr.push)
122. email = bool(ovr.email)
123. }
124. if (!registered) { push = false }
125. return { push = push email = email }
126. }
127. // WRITE THE EFFECTIVE SETTINGS of every kind of the connection's app (a row per kind)
128. static storeEffective = (conn) => {
129. let account = accountOfIdentity(conn.identity)
130. let ovr = overrideOf(conn.id)
131. let kinds = kindsTable.find('app', conn.app)
132. if (countOf(kinds) == 0) { return null }
133. for (k of kinds) {
134. let row = settingOf(conn.id, k.name)
135. let eff = effectiveOf(k, row, ovr)
136. if (row == null) {
137. settingsTable.put({ pair = conn.id + ':' + k.name connection = conn.id account = str(account) kind = k.name userPush = '' userEmail = '' push = eff.push email = eff.email updated = now() })
138. } else if (row.push != eff.push || row.email != eff.email) {
139. settingsTable.update(row.id, merged(row, { push = eff.push email = eff.email updated = now() }))
140. }
141. }
142. return null
143. }
145. // ---- SENDING (the app) -----------------------------------------------------------------
146. // hasPushDevice: no push devices exist before piece 6
147. static hasPushDevice = (accountId) => { return false }
149. // POST /api/notify: `b` = the strict body. Answers { status, error } or { id }.
150. static sendNotification = (b) => {
151. let a = appOfSecret(b.key, b.secret)
152. if (a == null) { return { status = 401 error = 'unknown API key or wrong secret' } }
153. let conn = connectionByAnyId(a.id, b.identity)
154. if (conn == null) { return { status = 404 error = 'unknown identity for this app' } }
155. let ident = identityRecord(conn.identity)
156. if (ident == null) { return { status = 404 error = 'unknown identity for this app' } }
157. let nm = checkKindName(b.name, 'name')
158. if (nm.error != null) { return { status = 400 error = nm.error } }
159. let tx = checkText(b.text)
160. if (tx.error != null) { return { status = 400 error = tx.error } }
161. let icon = ''
162. if (b.icon != null) {
163. let c = checkUrl(b.icon, 'icon')
164. if (c.error != null) { return { status = 400 error = c.error } }
165. icon = c.url
166. }
167. let link = ''
168. if (b.link != null) {
169. let c = checkUrl(b.link, 'link')
170. if (c.error != null) { return { status = 400 error = c.error } }
171. link = c.url
172. }
173. let urgent = bool(b.urgent)
174. // an UNREGISTERED name is allowed: it becomes a kind the app has not registered
175. // (daily mail, no push) — the user sees it on the per-app page and can switch it
176. let kind = kindOf(a.id, nm.name)
177. if (kind == null) {
178. if (countOf(kindsTable.find('app', a.id)) >= maxKindsPerApp) { return { status = 400 error = 'an app has at most ' + maxKindsPerApp + ' kinds' } }
179. let kid = kindsTable.put({ pair = a.id + ':' + nm.name app = a.id name = nm.name registered = false push = false email = true created = now() updated = now() })
180. kind = kindsTable.fetch(kid)
181. storeEffective(conn)
182. }
183. let eff = effectiveOf(kind, settingOf(conn.id, kind.name), overrideOf(conn.id))
184. let push = eff.push
185. let mail = eff.email ? 'daily' : 'none'
186. if (urgent) {
187. if (eff.push && hasPushDevice(ident.account)) {
188. push = true
189. mail = 'none'
190. } else {
191. push = false
192. mail = eff.push || eff.email ? 'now' : 'none'
193. }
194. }
195. let id = notificationsTable.put({ account = ident.account identity = ident.id app = a.id connection = conn.id name = nm.name text = tx.text icon = icon link = link urgent = urgent created = now() read = false readAt = 0 push = push mail = mail pushSent = false mailSent = false })
196. return { id = id }
197. }
199. // ---- THE INBOX (the user) --------------------------------------------------------------
200. // the account's identities: id → label (as in the lists)
201. static identityLabels = (accountId) => {
202. let out = {}
203. let n = 1
204. for (r of identityRecords(accountId)) {
205. out[r.id] = labelOf(r, n)
206. n = n + 1
207. }
208. return out
209. }
210. static appName = (appId) => {
211. let a = isId(appId) ? appsTable.fetch(appId) : null
212. return a != null ? a.name : 'a deleted app'
213. }
215. static inboxRowOf = (r, labels) => {
216. let label = labels[r.identity]
217. let read = bool(r.read)
218. return {
219. id = r.id
220. identity = label != null ? label : 'a deleted identity'
221. app = appName(r.app)
222. connection = r.connection
223. name = r.name
224. text = r.text
225. icon = str(r.icon)
226. hasIcon = str(r.icon) != ''
227. link = str(r.link)
228. hasLink = str(r.link) != ''
229. urgent = bool(r.urgent)
230. time = stamp(r.created)
231. read = read
232. unread = !read
233. state = read ? 'read' : 'unread'
234. toggleText = read ? 'Mark unread' : 'Mark read'
235. }
236. }
238. // the account's notifications (all identities), newest first, at most inboxLimit
239. static inboxRows = (accountId) => {
240. let out = []
241. if (!isId(accountId)) { return out }
242. let labels = identityLabels(accountId)
243. let n = 0
244. for (r of newestFirst(notificationsTable.find('account', accountId))) {
245. if (n >= inboxLimit) { return out }
246. out.push(inboxRowOf(r, labels))
247. n = n + 1
248. }
249. return out
250. }
252. // read / unread: only the account's own. Answers { error } or { ok }.
253. static markRead = (accountId, id, read) => {
254. if (!isId(id)) { return { error = 'no such notification' } }
255. if (hlTypeName(read) != 'Boolean') { return { error = 'field read must be a boolean' } }
256. let r = notificationsTable.fetch(id)
257. if (r == null || r.account != accountId) { return { error = 'no such notification' } }
258. notificationsTable.update(r.id, merged(r, { read = read readAt = read ? now() : 0 }))
259. return { ok = true }
260. }
262. // ---- THE PER-APP PAGE (the user) -------------------------------------------------------
263. // the connection `id` if its identity belongs to the account, else null
264. static ownConnection = (accountId, id) => {
265. if (!isId(id)) { return null }
266. let c = connectionsTable.fetch(id)
267. if (c == null) { return null }
268. let ident = identityRecord(c.identity)
269. if (ident == null || ident.account != accountId) { return null }
270. if (!isId(c.app) || appsTable.fetch(c.app) == null) { return null }
271. return c
272. }
274. // the account's connections (every app each identity registered in), oldest first
275. static connectionRows = (accountId) => {
276. let out = []
277. if (!isId(accountId)) { return out }
278. let labels = identityLabels(accountId)
279. let all = connectionsTable.find(null, null)
280. if (countOf(all) == 0) { return out }
281. let mine = []
282. for (c of all) {
283. if (labels[c.identity] != null && isId(c.app) && appsTable.fetch(c.app) != null) { mine.push(c) }
284. }
285. // oldest first by created (reverse of newestFirst)
286. let sorted = newestFirst(mine)
287. let i = sorted.length - 1
288. while (i >= 0) {
289. let c = sorted[i]
290. out.push({ id = c.id href = '/inbox/' + c.id app = appName(c.app) identity = labels[c.identity] since = stamp(c.created) })
291. i = i - 1
292. }
293. return out
294. }
296. // everything the per-app page shows. Answers null for a connection that is not the account's.
297. static settingsPage = (accountId, connId) => {
298. let c = ownConnection(accountId, connId)
299. if (c == null) { return null }
300. let labels = identityLabels(accountId)
301. let ovr = overrideOf(c.id)
302. let active = ovr != null && bool(ovr.active)
303. let oPush = ovr != null && bool(ovr.push)
304. // no override row yet: its switches show what it would start with (the concept's
305. // default: the daily mail, no push)
306. let oEmail = ovr == null ? true : bool(ovr.email)
307. let kinds = []
308. for (k of byName(kindsTable.find('app', c.app))) {
309. let row = settingOf(c.id, k.name)
310. let eff = effectiveOf(k, row, ovr)
311. let registered = bool(k.registered)
312. kinds.push({
313. name = k.name
314. registered = registered
315. canPush = registered && !active
316. noPush = !registered
317. lockedPush = registered && active
318. canEmail = !active
319. lockedEmail = active
320. push = onOff(eff.push)
321. email = onOff(eff.email)
322. pushChecked = '' + eff.push
323. emailChecked = '' + eff.email
324. preset = 'app default: push ' + onOff(registered && bool(k.push)) + ', email ' + onOff(bool(k.email)) + (registered ? '' : ' (not registered by the app: no push)')
325. })
326. }
327. return {
328. id = c.id
329. app = appName(c.app)
330. identity = labels[c.identity]
331. since = stamp(c.created)
332. overrideActive = onOff(active)
333. overridePush = onOff(oPush)
334. overrideEmail = onOff(oEmail)
335. overrideActiveChecked = '' + active
336. overridePushChecked = '' + oPush
337. overrideEmailChecked = '' + oEmail
338. kinds = kinds
339. hasKinds = kinds.length > 0
340. noKinds = kinds.length == 0
341. }
342. }
344. // THE USER FLIPS A KIND'S SWITCH: channel 'push' | 'email', value bool. Answers { error } or { page }.
345. static setSwitch = (accountId, connId, kindName, channel, value) => {
346. let c = ownConnection(accountId, connId)
347. if (c == null) { return { error = 'no such app connection' } }
348. if (kindName == null || hlTypeName(kindName) != 'String') { return { error = 'field kind must be a string' } }
349. if (channel != 'push' && channel != 'email') { return { error = 'field channel must be push or email' } }
350. if (hlTypeName(value) != 'Boolean') { return { error = 'field value must be a boolean' } }
351. let k = kindOf(c.app, kindName)
352. if (k == null) { return { error = 'no such notification kind' } }
353. if (channel == 'push' && !bool(k.registered)) { return { error = 'the app has not registered this notification — it cannot be pushed' } }
354. let account = accountId
355. let row = settingOf(c.id, k.name)
356. let change = channel == 'push' ? { userPush = onOff(value) updated = now() } : { userEmail = onOff(value) updated = now() }
357. if (row == null) {
358. let rec = { pair = c.id + ':' + k.name connection = c.id account = account kind = k.name userPush = '' userEmail = '' push = false email = false updated = now() }
359. settingsTable.put(merged(rec, change))
360. } else {
361. settingsTable.update(row.id, merged(row, change))
362. }
363. storeEffective(c)
364. return { page = settingsPage(accountId, c.id) }
365. }
367. // THE OVERRIDE FOR ALL: field 'active' | 'push' | 'email', value bool. Answers { error } or { page }.
368. static setOverride = (accountId, connId, field, value) => {
369. let c = ownConnection(accountId, connId)
370. if (c == null) { return { error = 'no such app connection' } }
371. if (field != 'active' && field != 'push' && field != 'email') { return { error = 'field field must be active, push or email' } }
372. if (hlTypeName(value) != 'Boolean') { return { error = 'field value must be a boolean' } }
373. let row = overrideOf(c.id)
374. let change = { updated = now() }
375. change[field] = value
376. if (row == null) {
377. let rec = { pair = c.id + ':' connection = c.id account = accountId kind = '' active = false push = false email = true updated = now() }
378. settingsTable.put(merged(rec, change))
379. } else {
380. settingsTable.update(row.id, merged(row, change))
381. }
382. storeEffective(c)
383. return { page = settingsPage(accountId, c.id) }
384. }