package server import ( "context" "encoding/json" "errors" "net/http" "sort" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/webhook" ) func (s *Server) settings(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } v := s.repoView(w, r, repo, role, "title.settings") v.Page = "settings" v.Wide = true v.Tab = settingsTab(r.URL.Query().Get("tab")) if role.CanManageSettings() { v.Members, _ = s.Store.ListMembers(r.Context(), "repo", repo.ID) if repo.OwnerKind == "user" { owner, err := s.Store.UserByID(r.Context(), repo.OwnerID) if err == nil { v.Members = append([]store.Member{{UserID: owner.ID, Username: owner.Username, Role: access.RoleMaintainer}}, v.Members...) } } v.Secrets, _ = s.Store.ListSecrets(r.Context(), "repo", repo.ID) v.HookSecrets = s.repoSecretChoices(r, repo) v.Patterns, _ = s.Store.ProtectedPatterns(r.Context(), repo.ID) v.TagPatterns, _ = s.Store.ProtectedTagPatterns(r.Context(), repo.ID) v.Hooks = s.hookViews(r, "repo", repo.ID) s.fillHookEdit(r, &v, "repo", repo.ID) s.fillApproval(r, &v, repo) } s.render(w, "settings", v) } func (s *Server) hookViews(r *http.Request, kind string, id int64) []HookView { hooks, err := s.Store.ListWebhooks(r.Context(), kind, id) if err != nil { return nil } lang := s.langOf(r) var out []HookView for _, h := range hooks { d, _ := s.Store.RecentDeliveries(r.Context(), h.ID) out = append(out, HookView{ ID: h.ID, Name: h.Name, Preset: h.Preset, URL: h.URLTemplate, Method: h.Method, Filter: h.BranchFilter, Events: strings.Join(h.Events, ", "), Badges: eventBadges(lang, h.Events), Deliveries: d, }) } return out } func eventBadges(lang i18n.Lang, events []string) []string { var out []string for _, e := range events { key := "" switch e { case webhook.EventPush: key = "set.ev.push" case webhook.EventMergeRequest: key = "set.ev.mr" case webhook.EventPipelineSuccess: key = "set.ev.ok" case webhook.EventPipelineFailure: key = "set.ev.fail" case webhook.EventRelease: key = "set.ev.release" } if key == "" { out = append(out, e) continue } out = append(out, i18n.T(lang, key)) } return out } func (s *Server) fillHookEdit(r *http.Request, v *View, kind string, id int64) { if kind == "repo" && v.Tab != "webhooks" { return } if kind == "group" && v.Tab != "settings" { return } raw := strings.TrimSpace(r.URL.Query().Get("hook")) if raw == "" { return } hid, err := strconv.ParseInt(raw, 10, 64) if err != nil || hid <= 0 { return } h, err := s.Store.Webhook(r.Context(), kind, id, hid) if err != nil { return } v.HookEdit = draftFrom(h) if v.HookEdit.Token != "" { v.HookSecrets = keepToken(v.HookSecrets, v.HookEdit.Token) } } func keepToken(in []SecretChoice, name string) []SecretChoice { for _, c := range in { if c.Name == name { return in } } return append(in, SecretChoice{Name: name, Label: name}) } func draftFrom(h store.Webhook) HookDraft { d := HookDraft{ ID: h.ID, Name: h.Name, Preset: h.Preset, Filter: h.BranchFilter, Method: h.Method, } var in webhook.Input if h.Fields != "" && json.Unmarshal([]byte(h.Fields), &in) == nil { d.URL, d.Username, d.Avatar, d.Icon, d.Alias = in.URL, in.Username, in.Avatar, in.Icon, in.Alias d.Token, d.Chat, d.Server, d.Topic = in.Token, in.Chat, in.Server, in.Topic d.Home, d.Room, d.CType, d.Headers, d.Body = in.Homeserver, in.Room, in.ContentType, in.Headers, in.Body if in.Method != "" { d.Method = in.Method } } else { d.URL = h.URLTemplate d.Body = h.BodyTemplate d.Headers = headerLines(h.Headers) d.CType = h.Headers["Content-Type"] } for _, e := range h.Events { switch e { case webhook.EventPush: d.OnPush = true case webhook.EventMergeRequest: d.OnMR = true case webhook.EventPipelineSuccess: d.OnOK = true case webhook.EventPipelineFailure: d.OnFail = true case webhook.EventRelease: d.OnRel = true case webhook.EventIssue: d.OnIssue = true } } if d.Preset == "" { d.Preset = webhook.PresetCustom } if d.Method == "" { d.Method = "POST" } return d } func headerLines(h map[string]string) string { if len(h) == 0 { return "" } keys := make([]string, 0, len(h)) for k := range h { keys = append(keys, k) } sort.Strings(keys) var b strings.Builder for i, k := range keys { if i > 0 { b.WriteByte('\n') } b.WriteString(k) b.WriteString(": ") b.WriteString(h[k]) } return b.String() } func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleMaintainer) if !ok || !s.csrfOK(w, r) { return } if err := s.opUpdateRepo(r.Context(), s.who(r).User, repo, r.FormValue("description"), r.FormValue("visibility")); err != nil { s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err)) return } s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "") } func (s *Server) repoMember(w http.ResponseWriter, r *http.Request) { s.memberPost(w, r, "repo") } func (s *Server) repoMemberRemove(w http.ResponseWriter, r *http.Request) { s.memberRemove(w, r, "repo") } func (s *Server) groupMember(w http.ResponseWriter, r *http.Request) { s.memberPost(w, r, "group") } func (s *Server) groupMemberRemove(w http.ResponseWriter, r *http.Request) { s.memberRemove(w, r, "group") } func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string) { scopeID, back, ok := s.adminScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } if err := s.opSetMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username"), r.FormValue("role")); err != nil { s.redirect(w, r, back, "", s.commitProblem(r, err)) return } s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "") } func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind string) { scopeID, back, ok := s.adminScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } if err := s.opRemoveMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username")); err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.redirect(w, r, back, s.tr(r, "flash.memberRemoved"), "") } func (s *Server) adminScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) { if kind == "group" { g, role, ok := s.guardGroup(w, r, access.RoleMaintainer) if !ok { return 0, "", false } _ = role return g.ID, "/groups/" + g.Path + "?tab=members", true } _, repo, _, ok := s.guard(w, r, access.RoleMaintainer) if !ok { return 0, "", false } return repo.ID, repoURL(repo) + "/-/settings?tab=members", true } func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleMaintainer) if !ok || !s.csrfOK(w, r) { return } if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false); err != nil { s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err)) return } s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.branchOn"), "") } func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleMaintainer) if !ok || !s.csrfOK(w, r) { return } _ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false) s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "") } func (s *Server) repoSecret(w http.ResponseWriter, r *http.Request) { s.secretPost(w, r, "repo") } func (s *Server) repoSecretDelete(w http.ResponseWriter, r *http.Request) { s.secretDelete(w, r, "repo") } func (s *Server) groupSecret(w http.ResponseWriter, r *http.Request) { s.secretPost(w, r, "group") } func (s *Server) groupSecretDelete(w http.ResponseWriter, r *http.Request) { s.secretDelete(w, r, "group") } // secretScope laat alleen een maintainer secrets bekijken of bewerken, ook protected. func (s *Server) secretScope(w http.ResponseWriter, r *http.Request, kind string) (int64, string, bool) { if kind == "group" { g, role, ok := s.guardGroup(w, r, access.RoleReadonly) if !ok { return 0, "", false } if !role.CanManageSecrets() { http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden) return 0, "", false } return g.ID, "/groups/" + g.Path + "?tab=settings#secrets", true } _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return 0, "", false } if !role.CanManageSecrets() { http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden) return 0, "", false } return repo.ID, repoURL(repo) + "/-/settings?tab=secrets", true } func (s *Server) secretPost(w http.ResponseWriter, r *http.Request, kind string) { scopeID, back, ok := s.secretScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } name := strings.TrimSpace(r.FormValue("name")) value := r.FormValue("value") protected := r.FormValue("protected") == "1" flash := "flash.secretSaved" var err error switch r.FormValue("mode") { case "update": err = s.Store.UpdateSecret(r.Context(), kind, scopeID, name, value, protected) case "replace": err = s.Store.ReplaceSecret(r.Context(), kind, scopeID, name, value, protected) flash = "flash.secretReplaced" default: err = s.Store.CreateSecret(r.Context(), kind, scopeID, name, value, protected, r.FormValue("invisible") == "1") } if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.redirect(w, r, back, s.tr(r, flash), "") } func (s *Server) repoSecretReveal(w http.ResponseWriter, r *http.Request) { s.secretReveal(w, r, "repo") } func (s *Server) groupSecretReveal(w http.ResponseWriter, r *http.Request) { s.secretReveal(w, r, "group") } func (s *Server) secretReveal(w http.ResponseWriter, r *http.Request, kind string) { scopeID, _, ok := s.secretScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } value, err := s.Store.RevealSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.FormValue("name"))) w.Header().Set("Content-Type", "application/json") if err != nil { s.writeSecretJSONErr(w, r, err) return } _ = json.NewEncoder(w).Encode(map[string]string{"value": value}) } func (s *Server) writeSecretJSONErr(w http.ResponseWriter, r *http.Request, err error) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(secretStatus(err)) _ = json.NewEncoder(w).Encode(map[string]string{"error": s.trErr(r, err)}) } func secretStatus(err error) int { if store.Missing(err) { return http.StatusNotFound } var ie i18n.Error if errors.As(err, &ie) { switch ie.Key { case "err.secretHidden": return http.StatusForbidden case "err.secretExists", "err.secretVisible": return http.StatusConflict } } return http.StatusBadRequest } func (s *Server) secretDelete(w http.ResponseWriter, r *http.Request, kind string) { scopeID, back, ok := s.secretScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } _ = s.Store.DeleteSecret(r.Context(), kind, scopeID, r.FormValue("name")) s.redirect(w, r, back, s.tr(r, "flash.secretRemoved"), "") } func (s *Server) repoWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "repo") } func (s *Server) repoWebhookDelete(w http.ResponseWriter, r *http.Request) { s.webhookDelete(w, r, "repo") } func (s *Server) groupWebhook(w http.ResponseWriter, r *http.Request) { s.webhookPost(w, r, "group") } func (s *Server) groupWebhookDelete(w http.ResponseWriter, r *http.Request) { s.webhookDelete(w, r, "group") } func (s *Server) webhookPost(w http.ResponseWriter, r *http.Request, kind string) { scopeID, back, ok := s.adminScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks") if kind == "group" { back += "#webhooks" } var events []string for _, e := range webhook.AllEvents() { if r.FormValue("event_"+e) == "1" { events = append(events, e) } } id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64) _, err := s.saveWebhookRecord(r.Context(), kind, scopeID, id, strings.TrimSpace(r.FormValue("name")), r.FormValue("preset"), r.FormValue("branch_filter"), events, webhook.Input{ URL: r.FormValue("url"), Username: r.FormValue("username"), Avatar: r.FormValue("avatar"), Icon: r.FormValue("icon"), Alias: r.FormValue("alias"), Token: r.FormValue("token"), Chat: r.FormValue("chat"), Server: r.FormValue("server"), Topic: r.FormValue("topic"), Homeserver: r.FormValue("homeserver"), Room: r.FormValue("room"), Method: r.FormValue("method"), ContentType: r.FormValue("content_type"), Headers: r.FormValue("headers"), Body: r.FormValue("body"), }) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } s.redirect(w, r, back, s.tr(r, "flash.webhookSaved"), "") } func (s *Server) createWebhookRecord(ctx context.Context, kind string, scopeID int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) { return s.saveWebhookRecord(ctx, kind, scopeID, 0, name, preset, filter, events, in) } func (s *Server) saveWebhookRecord(ctx context.Context, kind string, scopeID, id int64, name, preset, filter string, events []string, in webhook.Input) (int64, error) { if !webhook.KnownPreset(preset) { return 0, i18n.E("err.preset") } filter = strings.TrimSpace(filter) if _, err := webhook.MatchBranch(filter, "main"); err != nil { return 0, err } if len(events) == 0 { return 0, i18n.E("err.pickEvent") } spec, err := webhook.Prepare(preset, in) if err != nil { return 0, err } raw, err := json.Marshal(in) if err != nil { return 0, err } rec := store.Webhook{ ID: id, ScopeKind: kind, ScopeID: scopeID, Name: name, Preset: preset, URLTemplate: spec.URL, Headers: spec.Headers, BodyTemplate: spec.Body, Events: events, BranchFilter: filter, Method: spec.Method, Fields: string(raw), } if id > 0 { if err := s.Store.UpdateWebhook(ctx, rec); err != nil { return 0, err } return id, nil } return s.Store.CreateWebhook(ctx, rec) } func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind string) { scopeID, back, ok := s.adminScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks") id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64) _ = s.opDeleteWebhook(r.Context(), s.who(r).User, kind, scopeID, id) s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "") } func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleMaintainer) if !ok || !s.csrfOK(w, r) { return } u := s.who(r).User if err := s.opDeleteRepo(r.Context(), u, repo, r.FormValue("confirm")); err != nil { s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err)) return } s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "") } func (s *Server) guardGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, access.Role, bool) { g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path")) if err != nil { http.NotFound(w, r) return store.Group{}, "", false } p := s.who(r) var role access.Role if p.OK { role, err = s.Store.GroupRole(r.Context(), g.ID, p.User.ID) if err != nil { http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError) return store.Group{}, "", false } } if isCrawler(r) { p = principal{} role = access.RoleNone } if min == access.RoleReadonly { if role.CanRead() || g.Visibility == "public" { return g, role, true } if isCrawler(r) { s.writeLockedCard(w, r) } else if p.OK { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) } else { http.NotFound(w, r) } return store.Group{}, "", false } if !p.OK { http.Redirect(w, r, "/login", http.StatusFound) return store.Group{}, "", false } if !role.AtLeast(min) { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return store.Group{}, "", false } return g, role, true } func (s *Server) groupPage(w http.ResponseWriter, r *http.Request) { g, role, ok := s.guardGroup(w, r, access.RoleReadonly) if !ok { return } v := s.view(w, r, g.Name) v.Wide = true v.Group = &g v.Role = role v.CanAdmin = role.CanManageSettings() tab := r.URL.Query().Get("tab") switch tab { case "members": if !role.CanRead() { tab = "" } case "settings": if !role.CanManageSettings() { tab = "" } default: tab = "" } v.Tab = tab all, _ := s.Store.ReposByGroup(r.Context(), g.ID) uid := int64(0) if v.User != nil { uid = v.User.ID } var repos []store.Repo for _, repo := range all { if repo.Visibility == "public" { repos = append(repos, repo) continue } if uid == 0 { continue } er, err := s.Store.EffectiveRole(r.Context(), uid, repo.ID) if err == nil && er.CanRead() { repos = append(repos, repo) } } q := strings.TrimSpace(r.URL.Query().Get("q")) dir := r.URL.Query().Get("dir") if dir != "desc" { dir = "asc" } v.Query, v.SortDir = q, dir if dir == "desc" { v.FlipDir = "asc" } else { v.FlipDir = "desc" } if lq := strings.ToLower(q); lq != "" { var filtered []store.Repo for _, repo := range repos { if strings.Contains(strings.ToLower(repo.Name), lq) { filtered = append(filtered, repo) } } repos = filtered } sort.Slice(repos, func(i, j int) bool { a, b := strings.ToLower(repos[i].Name), strings.ToLower(repos[j].Name) if dir == "desc" { return a > b } return a < b }) ids := make([]int64, len(repos)) for i, repo := range repos { ids[i] = repo.ID } counts, mine, _ := s.Store.StarInfo(r.Context(), uid, ids) lang := s.langOf(r) for _, repo := range repos { v.Cards = append(v.Cards, RepoCard{ Repo: repo, Stars: counts[repo.ID], Starred: mine[repo.ID], When: i18n.FormatDate(lang, repo.CreatedAt), }) } v.Repos = repos v.Heat = s.heatmap(r.Context(), 0, s.visibleIDs(r.Context(), uid, repos), lang) if tab == "members" && role.CanRead() { v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID) } if tab == "settings" && role.CanManageSettings() { v.Members, _ = s.Store.ListMembers(r.Context(), "group", g.ID) v.Secrets, _ = s.Store.ListSecrets(r.Context(), "group", g.ID) v.HookSecrets = s.groupSecretChoices(r, g) v.Hooks = s.hookViews(r, "group", g.ID) s.fillHookEdit(r, &v, "group", g.ID) s.fillGroupApproval(r, &v, g) if v.User != nil && v.User.ID == g.OwnerID { v.IsOwner = true v.Candidates = groupCandidates(v.Members, g.OwnerID) } } s.render(w, "group", v) } func settingsTab(tab string) string { switch tab { case "leden", "members": return "members" case "geheimen", "secrets": return "secrets" case "branches": return "branches" case "tags": return "tags" case "webhooks": return "webhooks" case "approvals": return "approvals" default: return "general" } } func scopeTab(kind, repoTab string) string { if kind == "group" { if repoTab == "members" { return "?tab=members" } return "?tab=settings" } return "?tab=" + repoTab }