// Package webhook filtert gebeurtenissen en vult URL, headers en body. package webhook import ( "encoding/json" "regexp" "strings" "gitlab.com/Timfa/bluegit/internal/i18n" ) // Soorten gebeurtenissen. const ( EventPush = "push" EventMergeRequest = "merge_request" EventPipelineSuccess = "pipeline_success" EventPipelineFailure = "pipeline_failure" EventRelease = "release_published" EventIssue = "issue" // Fijnere events. Een hook met "issue" of "merge_request" krijgt ze ook. EventIssueOpened = "issue_opened" EventIssueClosed = "issue_closed" EventIssueReopened = "issue_reopened" EventIssueUpdated = "issue_updated" EventIssueComment = "issue_comment" EventMRComment = "merge_request_comment" ) // AllEvents is de vaste lijst die een webhook mag aanvinken. func AllEvents() []string { return []string{EventPush, EventMergeRequest, EventPipelineSuccess, EventPipelineFailure, EventRelease, EventIssue, EventIssueOpened, EventIssueClosed, EventIssueReopened, EventIssueUpdated, EventIssueComment, EventMRComment} } // SpecificEvents zijn de fijnere events die bij issue en merge_request horen. func SpecificEvents() []string { return []string{EventIssueOpened, EventIssueClosed, EventIssueReopened, EventIssueUpdated, EventIssueComment, EventMRComment} } // Specific geeft de fijnere eventnaam van ev, of "" als die er niet is. func Specific(ev Event) string { switch ev.Type { case EventIssue: if ev.Issue == nil { return "" } switch ev.Issue.Action { case "opened": return EventIssueOpened case "closed": return EventIssueClosed case "reopened": return EventIssueReopened case "updated": return EventIssueUpdated case "commented": return EventIssueComment } case EventMergeRequest: if ev.MergeRequest != nil && ev.MergeRequest.Action == "commented" { return EventMRComment } } return "" } // KnownEvent meldt of name een ondersteunde gebeurtenis is. func KnownEvent(name string) bool { for _, e := range AllEvents() { if e == name { return true } } return false } // Presets. const ( PresetDiscord = "discord" PresetGrok = "grok" PresetGeneric = "generic" ) // Event is de gegevensset die een webhook te zien krijgt. // De platte velden blijven beschikbaar als {{event.veld}}. // Pipeline, Jobs, Ref/Before/After/Commits, MergeRequest en Release // vullen de JSON-body als het sjabloon leeg is. type Event struct { Type string Project string Group string Branch string Commit string Summary string URL string PipelineID string ReleaseTag string Actor string Pipeline *PipelineInfo Jobs []JobInfo Ref string Before string After string Commits []CommitInfo MergeRequest *MRInfo Comment string Release *ReleaseInfo Issue *IssueInfo } // Hook is de opgeslagen configuratie, zonder geheimen al ingevuld. type Hook struct { Preset string Events []string BranchFilter string } // Allows meldt of deze hook de gebeurtenis wil ontvangen. // Het branchfilter geldt alleen voor push. Leeg betekent alle branches. // "re:" gevolgd door een reguliere expressie, anders een exacte branchnaam. func Allows(h Hook, ev Event) (bool, error) { if !KnownEvent(ev.Type) { return false, i18n.E("err.whEvent", ev.Type) } found := false specific := Specific(ev) for _, e := range h.Events { if e == ev.Type || (specific != "" && e == specific) { found = true break } } if !found { return false, nil } if ev.Type != EventPush { return true, nil } return MatchBranch(h.BranchFilter, ev.Branch) } // MatchBranch past een push-filter toe. func MatchBranch(filter, branch string) (bool, error) { filter = strings.TrimSpace(filter) if filter == "" { return true, nil } if strings.HasPrefix(filter, "re:") { re, err := regexp.Compile(strings.TrimPrefix(filter, "re:")) if err != nil { return false, i18n.E("err.whFilter", err.Error()) } return re.MatchString(branch), nil } return filter == branch, nil } // Expand vult {{event.veld}} en {{secret.NAAM}}. // Een onbekend geheim of veld is een fout, zodat een webhook niet // per ongeluk met een leeg token vertrekt. func Expand(s string, ev Event, secrets map[string]string) (string, error) { var b strings.Builder for { start := strings.Index(s, "{{") if start < 0 { b.WriteString(s) break } b.WriteString(s[:start]) rest := s[start+2:] end := strings.Index(rest, "}}") if end < 0 { return "", i18n.E("err.whTemplate") } key := strings.TrimSpace(rest[:end]) val, err := lookup(key, ev, secrets) if err != nil { return "", err } b.WriteString(val) s = rest[end+2:] } return b.String(), nil } func lookup(key string, ev Event, secrets map[string]string) (string, error) { switch { case strings.HasPrefix(key, "secret."): name := strings.TrimPrefix(key, "secret.") v, ok := secrets[name] if !ok { return "", i18n.E("err.whSecret", name) } return v, nil case strings.HasPrefix(key, "event."): field := strings.TrimPrefix(key, "event.") v, ok := eventField(ev, field) if !ok { return "", i18n.E("err.whField", field) } return v, nil default: return "", i18n.E("err.whPlaceholder", key) } } func eventField(ev Event, field string) (string, bool) { if base, ok := strings.CutSuffix(field, "_json"); ok && base != "" { v, ok := eventField(ev, base) if !ok { return "", false } b, err := json.Marshal(v) if err != nil { return "", false } return string(b), true } switch field { case "type": return ev.Type, true case "event_name": if n := Specific(ev); n != "" { return n, true } return ev.Type, true case "project": return ev.Project, true case "group": return ev.Group, true case "branch": return ev.Branch, true case "commit": return ev.Commit, true case "summary": return ev.Summary, true case "url": return ev.URL, true case "pipeline_id": return ev.PipelineID, true case "release_tag": return ev.ReleaseTag, true case "actor": return ev.Actor, true case "payload": b, err := json.Marshal(ev.Document()) if err != nil { return "", false } return string(b), true default: return "", false } } // PresetDefaults vult URL-headers en body als de gebruiker een preset kiest // en een veld leeg laat. func PresetDefaults(preset string) (headers map[string]string, body string) { switch preset { case PresetDiscord: return map[string]string{"Content-Type": "application/json"}, `{"content":"{{event.summary}}"}` case PresetGrok: return map[string]string{ "Content-Type": "application/json", "Authorization": "Bearer {{secret.GROK_TOKEN}}", }, "" default: return map[string]string{"Content-Type": "application/json"}, "" } } // RenderBody maakt de HTTP-body. Een lege sjabloon wordt de gebeurtenis als JSON. func RenderBody(bodyTemplate string, ev Event, secrets map[string]string) ([]byte, error) { if strings.TrimSpace(bodyTemplate) == "" { return json.Marshal(ev.Document()) } s, err := Expand(bodyTemplate, ev, secrets) if err != nil { return nil, err } return []byte(s), nil } // RenderHeaders vult geheimen in headers. Preset-headers vullen alleen // ontbrekende sleutels aan. func RenderHeaders(preset string, configured map[string]string, ev Event, secrets map[string]string) (map[string]string, error) { base, _ := PresetDefaults(preset) if base == nil { base = map[string]string{} } for k, v := range configured { base[k] = v } out := map[string]string{} for k, v := range base { ek, err := Expand(k, ev, secrets) if err != nil { return nil, err } evv, err := Expand(v, ev, secrets) if err != nil { return nil, err } out[ek] = evv } return out, nil }