BlueGit

timfa bluegit

Files

bluegit / internal / webhook / presets.go

presets.go

feat: toon webhooks in een tabel en maak secrets bewerkbaar
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
89b83b18 History
presets.go 8.8 KiB Download Raw
1package webhook
2
3import (
4 "encoding/json"
5 "net/url"
6 "strings"
7
8 "gitlab.com/Timfa/bluegit/internal/access"
9 "gitlab.com/Timfa/bluegit/internal/i18n"
10)
11
12// Extra presets. generic, discord en grok bestonden al.
13const (
14 PresetCustom = "custom"
15 PresetSlack = "slack"
16 PresetTeams = "teams"
17 PresetMattermost = "mattermost"
18 PresetRocketChat = "rocketchat"
19 PresetTelegram = "telegram"
20 PresetMatrix = "matrix"
21 PresetGoogleChat = "googlechat"
22 PresetNtfy = "ntfy"
23 PresetGotify = "gotify"
24)
25
26// PresetIDs is de volgorde in het formulier.
27func PresetIDs() []string {
28 return []string{
29 PresetCustom, PresetGeneric, PresetDiscord, PresetSlack, PresetTeams,
30 PresetMattermost, PresetRocketChat, PresetTelegram, PresetMatrix,
31 PresetGoogleChat, PresetNtfy, PresetGotify, PresetGrok,
32 }
33}
34
35// KnownPreset meldt of id een ondersteunde preset is.
36func KnownPreset(id string) bool {
37 for _, p := range PresetIDs() {
38 if p == id {
39 return true
40 }
41 }
42 return false
43}
44
45// Input zijn de velden van het formulier. Prepare leest alleen wat bij de preset hoort.
46type Input struct {
47 URL string `json:"url"`
48 Username string `json:"username"`
49 Avatar string `json:"avatar"`
50 Icon string `json:"icon"`
51 Alias string `json:"alias"`
52 Token string `json:"token"`
53 Chat string `json:"chat"`
54 Server string `json:"server"`
55 Topic string `json:"topic"`
56 Homeserver string `json:"homeserver"`
57 Room string `json:"room"`
58 Method string `json:"method"`
59 ContentType string `json:"content_type"`
60 Headers string `json:"headers"`
61 Body string `json:"body"`
62}
63
64// Spec is wat er opgeslagen wordt. De body is een sjabloon; JSON-presets
65// gebruiken {{event.summary_json}} zodat aanhalingstekens heel blijven.
66type Spec struct {
67 Method string
68 URL string
69 Headers map[string]string
70 Body string
71}
72
73// Prepare bouwt URL, methode, headers en body voor een preset.
74func Prepare(preset string, in Input) (Spec, error) {
75 if !KnownPreset(preset) {
76 return Spec{}, i18n.E("err.preset")
77 }
78 switch preset {
79 case PresetCustom:
80 return prepareCustom(in)
81 case PresetGeneric:
82 return prepareJSONURL(in.URL)
83 case PresetDiscord:
84 return prepareMessage(in.URL, discordBody(in.Username, in.Avatar))
85 case PresetSlack, PresetGoogleChat:
86 return prepareMessage(in.URL, `{"text":{{event.summary_json}}}`)
87 case PresetTeams:
88 return prepareMessage(in.URL, `{"@type":"MessageCard","@context":"https://schema.org/extensions","summary":{{event.summary_json}},"text":{{event.summary_json}}}`)
89 case PresetMattermost:
90 return prepareMessage(in.URL, mattermostBody(in.Username, in.Icon))
91 case PresetRocketChat:
92 return prepareMessage(in.URL, rocketBody(in.Alias))
93 case PresetTelegram:
94 return prepareTelegram(in)
95 case PresetMatrix:
96 return prepareMatrix(in)
97 case PresetNtfy:
98 return prepareNtfy(in)
99 case PresetGotify:
100 return prepareGotify(in)
101 case PresetGrok:
102 return prepareGrok(in)
103 default:
104 return Spec{}, i18n.E("err.preset")
105 }
106}
107
108func prepareJSONURL(raw string) (Spec, error) {
109 u, err := plainURL(raw)
110 if err != nil {
111 return Spec{}, err
112 }
113 return Spec{
114 Method: "POST",
115 URL: u,
116 Headers: map[string]string{"Content-Type": "application/json"},
117 }, nil
118}
119
120func prepareMessage(raw, body string) (Spec, error) {
121 spec, err := prepareJSONURL(raw)
122 if err != nil {
123 return Spec{}, err
124 }
125 spec.Body = body
126 return spec, nil
127}
128
129func discordBody(username, avatar string) string {
130 b := strings.Builder{}
131 b.WriteString(`{"content":{{event.summary_json}}`)
132 if username != "" {
133 b.WriteString(`,"username":`)
134 b.Write(mustJSON(username))
135 }
136 if avatar != "" {
137 b.WriteString(`,"avatar_url":`)
138 b.Write(mustJSON(avatar))
139 }
140 b.WriteByte('}')
141 return b.String()
142}
143
144func mattermostBody(username, icon string) string {
145 b := strings.Builder{}
146 b.WriteString(`{"text":{{event.summary_json}}`)
147 if username != "" {
148 b.WriteString(`,"username":`)
149 b.Write(mustJSON(username))
150 }
151 if icon != "" {
152 b.WriteString(`,"icon_url":`)
153 b.Write(mustJSON(icon))
154 }
155 b.WriteByte('}')
156 return b.String()
157}
158
159func rocketBody(alias string) string {
160 if alias == "" {
161 return `{"text":{{event.summary_json}}}`
162 }
163 return `{"text":{{event.summary_json}},"alias":` + string(mustJSON(alias)) + `}`
164}
165
166func prepareTelegram(in Input) (Spec, error) {
167 ref, err := secretRef(in.Token)
168 if err != nil {
169 return Spec{}, err
170 }
171 chat := strings.TrimSpace(in.Chat)
172 if chat == "" || strings.ContainsAny(chat, "\r\n") {
173 return Spec{}, i18n.E("err.whChat")
174 }
175 return Spec{
176 Method: "POST",
177 URL: "https://api.telegram.org/bot" + ref + "/sendMessage",
178 Headers: map[string]string{"Content-Type": "application/json"},
179 Body: `{"chat_id":` + string(mustJSON(chat)) + `,"text":{{event.summary_json}}}`,
180 }, nil
181}
182
183func prepareMatrix(in Input) (Spec, error) {
184 home, err := plainURL(in.Homeserver)
185 if err != nil {
186 return Spec{}, err
187 }
188 room := strings.TrimSpace(in.Room)
189 if room == "" || strings.ContainsAny(room, " \r\n") {
190 return Spec{}, i18n.E("err.whRoom")
191 }
192 ref, err := secretRef(in.Token)
193 if err != nil {
194 return Spec{}, err
195 }
196 home = strings.TrimRight(home, "/")
197 txn := "bluegit-{{event.type}}-{{event.commit}}-{{event.pipeline_id}}-{{event.release_tag}}"
198 return Spec{
199 Method: "PUT",
200 URL: home + "/_matrix/client/v3/rooms/" + url.QueryEscape(room) + "/send/m.room.message/" + txn,
201 Headers: map[string]string{
202 "Content-Type": "application/json",
203 "Authorization": "Bearer " + ref,
204 },
205 Body: `{"msgtype":"m.text","body":{{event.summary_json}}}`,
206 }, nil
207}
208
209func prepareNtfy(in Input) (Spec, error) {
210 server := strings.TrimSpace(in.Server)
211 if server == "" {
212 server = "https://ntfy.sh"
213 }
214 server, err := plainURL(server)
215 if err != nil {
216 return Spec{}, err
217 }
218 topic := strings.Trim(strings.TrimSpace(in.Topic), "/")
219 if topic == "" || strings.ContainsAny(topic, " \r\n?#") {
220 return Spec{}, i18n.E("err.whTopic")
221 }
222 headers := map[string]string{"Content-Type": "text/plain"}
223 if strings.TrimSpace(in.Token) != "" {
224 ref, err := secretRef(in.Token)
225 if err != nil {
226 return Spec{}, err
227 }
228 headers["Authorization"] = "Bearer " + ref
229 }
230 return Spec{
231 Method: "POST",
232 URL: strings.TrimRight(server, "/") + "/" + topic,
233 Headers: headers,
234 Body: "{{event.summary}}",
235 }, nil
236}
237
238func prepareGotify(in Input) (Spec, error) {
239 if strings.TrimSpace(in.Server) == "" {
240 return Spec{}, i18n.E("err.whServer")
241 }
242 server, err := plainURL(in.Server)
243 if err != nil {
244 return Spec{}, err
245 }
246 ref, err := secretRef(in.Token)
247 if err != nil {
248 return Spec{}, err
249 }
250 return Spec{
251 Method: "POST",
252 URL: strings.TrimRight(server, "/") + "/message",
253 Headers: map[string]string{
254 "Content-Type": "application/json",
255 "X-Gotify-Key": ref,
256 },
257 Body: `{"title":{{event.project_json}},"message":{{event.summary_json}}}`,
258 }, nil
259}
260
261func prepareGrok(in Input) (Spec, error) {
262 spec, err := prepareJSONURL(in.URL)
263 if err != nil {
264 return Spec{}, err
265 }
266 ref, err := secretRef(in.Token)
267 if err != nil {
268 return Spec{}, err
269 }
270 spec.Headers["Authorization"] = "Bearer " + ref
271 return spec, nil
272}
273
274func prepareCustom(in Input) (Spec, error) {
275 method := strings.ToUpper(strings.TrimSpace(in.Method))
276 if method == "" {
277 method = "POST"
278 }
279 switch method {
280 case "GET", "POST", "PUT", "PATCH":
281 default:
282 return Spec{}, i18n.E("err.whMethod")
283 }
284 u, err := plainURL(in.URL)
285 if err != nil {
286 return Spec{}, err
287 }
288 ctype := strings.TrimSpace(in.ContentType)
289 if ctype == "" {
290 ctype = "application/json"
291 }
292 if strings.ContainsAny(ctype, "\r\n") {
293 return Spec{}, i18n.E("err.header")
294 }
295 headers := map[string]string{"Content-Type": ctype}
296 extra, err := parseHeaderLines(in.Headers)
297 if err != nil {
298 return Spec{}, err
299 }
300 for k, v := range extra {
301 headers[k] = v
302 }
303 return Spec{Method: method, URL: u, Headers: headers, Body: in.Body}, nil
304}
305
306func parseHeaderLines(raw string) (map[string]string, error) {
307 out := map[string]string{}
308 for _, line := range strings.Split(raw, "\n") {
309 line = strings.TrimSpace(line)
310 if line == "" {
311 continue
312 }
313 if strings.ContainsAny(line, "\r") {
314 return nil, i18n.E("err.header")
315 }
316 k, v, ok := strings.Cut(line, ":")
317 k, v = strings.TrimSpace(k), strings.TrimSpace(v)
318 if !ok || k == "" || strings.ContainsAny(k, " \r\n") || strings.ContainsAny(v, "\r\n") {
319 return nil, i18n.E("err.header")
320 }
321 out[k] = v
322 }
323 return out, nil
324}
325
326func plainURL(raw string) (string, error) {
327 raw = strings.TrimSpace(raw)
328 if raw == "" {
329 return "", i18n.E("err.whURL")
330 }
331 u, err := url.Parse(raw)
332 if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") || u.User != nil {
333 return "", i18n.E("err.whURL")
334 }
335 return raw, nil
336}
337
338func secretRef(name string) (string, error) {
339 name = strings.TrimSpace(name)
340 if err := access.ValidSecretName(name); err != nil {
341 return "", err
342 }
343 return "{{secret." + name + "}}", nil
344}
345
346func mustJSON(s string) []byte {
347 b, err := json.Marshal(s)
348 if err != nil {
349 return []byte(`""`)
350 }
351 return b
352}