gitoria

9.8 KB

1. // lib/tickets.hl — THE TICKETS OF A REPO (gitoria#10, gitoria#18; CONCEPT "/tickets"). The tickets are NOT stored in
2. // gitoria: they live in a tickets.worldapi.org project the repo's OWNER connected in the repo's settings
3. // (docs: antcolony-docs/docs/tickets-connect-apps.md). The connect flow:
4. // 1. /settings/connect (lib/api.hl connectStart) sends the owner's browser to <tickets>/connect?app=gitoria&label=<slug>&return=…&state=…
5. // 2. tickets brings them back to /settings/connected?code=…&state=… (the state is the nonce of step 1, kept in the session)
6. // 3. exchangeConnect(code): POST <tickets>/api/connect/exchange { code } → { key, project, title, api }, from THIS server.
7. // The key is stored per repo (repos.hl, mpackdb) and never sent to a page.
8. // Every write then carries `Authorization: Bearer <key>` and `X-Tickets-Identity: <ident id of the person>`: the person
9. // (not gitoria) is the author, under the project's roles. Reads need no key.
10. // Links both ways: "#12" in a commit subject or a pull request title links ticket 12 (refParts); a push posts
11. // "mentioned in commit …" on that ticket, and a merged `|||PR` whose title says "fixes #12" sets ticket 12 to review (notifyPush).
12. // Config: GITORIA_TICKETS_URL (tickets-helpers.hl). The shapes, the `#12` references: tickets-helpers.hl.
13. import { fetch } from 'hl:fetch'
14. import { MPackDB } from 'hl:mpackdb'
15. import { now } from 'hl:time'
16. import { NL, storageDir, countOfList, plainError, repoOrigin } from './util.hl'
17. import { userRecord } from './users.hl'
18. import { repoBySlug, setTicketsConnection } from './repos.hl'
19. import { gitRaw } from './git.hl'
20. import { tabs, isHexId } from './git-helpers.hl'
21. import { pullsNow } from './pulls.hl'
22. import { ticketsUrl, maxRows, agent, isCode, viewOf, writeHeaders, whyOf, refsOf, fixedBy } from './tickets-helpers.hl'
24. // what was already told to tickets (a push arrives again with the same commits): one row per `<slug> <what> <sha> <n>`
25. static seenTable = new MPackDB(file = storageDir + '/ticketlinks.db', primaryKey = '@id', indexes = ['!key'])
27. // ---- the connect flow ------------------------------------------------------------------------------
28. static connectHref = (slug, state) => {
29. let back = repoOrigin(slug) + '/settings/connected'
30. return ticketsUrl + '/connect?app=gitoria&label=' + encodeURIComponent(slug) + '&return=' + encodeURIComponent(back) + '&state=' + encodeURIComponent(state)
31. }
33. // the code tickets sent back → { key, project, title, api } | { error }
34. static exchangeConnect = (code) => {
35. if (!isCode(code)) { return { error = 'that is not a code from tickets' } }
36. let r = fetch(ticketsUrl + '/api/connect/exchange', { method = 'POST' json = { code = code } headers = { 'user-agent' = agent } timeoutMs = 10000 })
37. if (r == null || r.status == null || r.status == 0) { return { error = 'tickets.worldapi.org did not answer' } }
38. let j = r.json()
39. if (r.status != 200 || j == null || j.key == null || j.project == null || j.api == null) {
40. return { error = 'tickets.worldapi.org refused the connection (' + r.status + (j != null && j.error != null ? ': ' + j.error : '') + ')' }
41. }
42. if (hlTypeName(j.key) != 'String' || !j.key.startsWith('tktc_') || hlTypeName(j.api) != 'String' || !j.api.startsWith(ticketsUrl + '/api/projects/')) { return { error = 'tickets.worldapi.org sent an answer gitoria does not understand' } }
43. return { key = j.key project = '' + j.project title = j.title != null ? '' + j.title : '' + j.project api = j.api }
44. }
46. // THE END OF THE CONNECT FLOW (/settings/connected, lib/api.hl connectBack): tickets' answer `q` (?code&state, or ?error),
47. // `want` = the nonce parked in the session at the start → '' (connected: the key is stored per repo, the history so far
48. // is marked as told) or the note for the settings page. The caller checked that the person owns the repo.
49. static finishConnect = (slug, want, q) => {
50. if (q.error != null && q.code == null) { return 'Tickets did not connect: ' + ('' + q.error).slice(0, 100) }
51. if (want == null || want != slug + '.' + q.state) { return 'That connection was not started here (or was used already) — click "Tickets: connect" again.' }
52. let x = exchangeConnect(q.code)
53. if (x.error != null) { return x.error }
54. let r = setTicketsConnection(slug, x.key, x.project, x.title, x.api)
55. if (r.error != null) { return r.error }
56. notifyPush(slug, true)
57. return ''
58. }
60. // ---- reading ---------------------------------------------------------------------------------------
61. // the project of a connected repo (the server-side record has the key): { key, api, project } or null
62. static connectionOf = (slug) => {
63. let r = repoBySlug(slug)
64. if (r == null || r.tktKey == null || r.tktKey == '' || r.tktApi == null || r.tktApi == '') { return null }
65. return { key = r.tktKey api = r.tktApi project = r.tktProject title = r.tktTitle }
66. }
68. // the repo's tickets, newest update first (tickets' order): { tickets, count, truncated, project, url } or { error }
69. static loadTickets = (slug) => {
70. let c = connectionOf(slug)
71. if (c == null) { return { error = 'not connected' } }
72. let r = fetch(c.api + '/tickets', { method = 'GET' headers = { 'user-agent' = agent } timeoutMs = 10000 })
73. if (r == null || r.status == null || r.status == 0) { return { error = 'tickets.worldapi.org did not answer' } }
74. let base = { project = c.project url = ticketsUrl + '/projects/' + c.project }
75. let j = r.status == 200 ? r.json() : null
76. if (j == null || j.tickets == null) { return { error = 'tickets.worldapi.org answered ' + r.status } }
77. let out = []
78. for (t of j.tickets) { if (out.length < maxRows) { out.push(viewOf(t)) } }
79. base.tickets = out
80. base.count = j.tickets.length
81. base.truncated = j.tickets.length > out.length
82. return base
83. }
85. // ---- writing (as a person) ---------------------------------------------------------------------------
86. // open a ticket for a repo as the person with this ident id: { ticket } or { error, field }
87. static openTicket = (slug, identity, subject, summary) => {
88. let s = subject == null ? '' : ('' + subject).trim()
89. if (s == '') { return { error = 'the ticket needs a subject' field = 'subject' } }
90. let bad = plainError(s, 200, 'the subject')
91. if (bad != null) { return { error = bad field = 'subject' } }
92. let body = summary == null ? '' : ('' + summary).trim()
93. if (body.length > 20000) { return { error = 'the text is too long (at most 20000 characters)' field = 'summary' } }
94. let c = connectionOf(slug)
95. if (c == null) { return { error = 'this repository is not connected to a tickets project (see Settings)' field = '' } }
96. let r = fetch(c.api + '/tickets', { method = 'POST' json = { subject = s summary = body } headers = writeHeaders(c, identity) timeoutMs = 10000 })
97. if (r == null || r.status == null || r.status == 0) { return { error = 'tickets.worldapi.org did not answer' field = '' } }
98. let j = r.json()
99. if ((r.status != 201 && r.status != 200) || j == null || j.ticket == null) {
100. if (r.status == 403) { return { error = 'tickets refused: log in to tickets.worldapi.org once, choose a display name there, and check you may edit this project' + whyOf(r) field = '' } }
101. return { error = 'tickets.worldapi.org refused the ticket (' + r.status + whyOf(r).slice(0, 200) + ')' field = '' }
102. }
103. return { ticket = viewOf(j.ticket) }
104. }
106. // a comment on ticket n as a person → true when tickets took it, or answered it with a refusal (no retry then)
107. static commentTicket = (c, identity, n, text) => {
108. let r = fetch(c.api + '/tickets/' + n + '/comments', { method = 'POST' json = { text = text } headers = writeHeaders(c, identity) timeoutMs = 10000 })
109. return r != null && r.status != null && r.status > 0 && r.status < 500
110. }
112. static stateTicket = (c, identity, n, state, text) => {
113. let r = fetch(c.api + '/tickets/' + n + '/state', { method = 'POST' json = { state = state text = text } headers = writeHeaders(c, identity) timeoutMs = 10000 })
114. return r != null && r.status != null && r.status > 0 && r.status < 500
115. }
117. // ---- after a push or a merge: tell tickets ---------------------------------------------------------------
118. static seen = (key) => { return countOfList(seenTable.find('key', key)) > 0 }
119. static markSeen = (key) => { seenTable.put({ key = key created = now() }) }
121. // The recent commits of every branch that name a ticket: "mentioned in commit …" as a comment on it, once per
122. // commit and ticket. `quiet` only marks them (the moment of connecting: old history is not announced).
123. // Then every MERGED pull request whose title says "fixes #N" sets ticket N to review, once. The person is the repo's
124. // owner (pushes and merges are the owner's). Failures are silent (the push has succeeded); a refusal by tickets is not retried.
125. static notifyPush = (slug, quiet) => {
126. let c = connectionOf(slug)
127. let repo = repoBySlug(slug)
128. if (c == null || repo == null) { return null }
129. let owner = userRecord(repo.owner)
130. if (owner == null || owner.identity == null) { return null }
131. let lg = gitRaw(slug, ['log', '-100', '--branches', '--format=%H%x09%s'])
132. if (lg != null && lg.exit == 0) {
133. for (l of lg.lines) {
134. let f = tabs(l)
135. if (f.length >= 2 && isHexId(f[0])) {
136. let sub = f.slice(1).join(' ')
137. for (x of refsOf(sub)) {
138. let key = slug + ' commit ' + f[0] + ' ' + x.n
139. if (!seen(key)) {
140. if (quiet || commentTicket(c, owner.identity, x.n, 'Mentioned in commit [' + f[0].slice(0, 8) + '](' + repoOrigin(slug) + '/commit/' + f[0] + ') of ' + slug + ':' + NL + NL + '> ' + sub)) { markSeen(key) }
141. }
142. }
143. }
144. }
145. }
146. let got = pullsNow(slug, repo.branch != null ? repo.branch : '')
147. if (got != null && !got.isMessage) {
148. for (p of got.pulls) {
149. if (p.isMerged) {
150. for (n of fixedBy(p.title)) {
151. let key = slug + ' pr ' + p.sha + ' ' + n
152. if (!seen(key)) {
153. if (quiet || stateTicket(c, owner.identity, n, 'review', 'Fixed by the merged pull request [' + p.title + '](' + repoOrigin(slug) + '/commit/' + p.sha + ') of ' + slug + '.')) { markSeen(key) }
154. }
155. }
156. }
157. }
158. }
159. return null
160. }