BlueGit

timfa bluegit

Files

bluegit / internal / webhook / presets.go

presets.go

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