BlueGit

timfa bluegit

Files

bluegit / internal / server / secret_api.go

secret_api.go

feat: toon webhooks in een tabel en maak secrets bewerkbaar
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
89b83b18 History
secret_api.go 5.5 KiB Download Raw
1package server
2
3import (
4 "encoding/json"
5 "io"
6 "net/http"
7 "strings"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/store"
11)
12
13type secretBody struct {
14 Name string `json:"name"`
15 Value string `json:"value"`
16 Protected bool `json:"protected"`
17 Invisible bool `json:"invisible"`
18}
19
20func (s *Server) repoSecretsAPI(w http.ResponseWriter, r *http.Request) {
21 repo, _, ok := s.webhookAPIRepo(w, r)
22 if !ok {
23 return
24 }
25 s.secretListAPI(w, r, "repo", repo.ID)
26}
27
28func (s *Server) groupSecretsAPI(w http.ResponseWriter, r *http.Request) {
29 g, _, ok := s.webhookAPIGroup(w, r)
30 if !ok {
31 return
32 }
33 s.secretListAPI(w, r, "group", g.ID)
34}
35
36func (s *Server) repoSecretCreateAPI(w http.ResponseWriter, r *http.Request) {
37 repo, _, ok := s.webhookAPIRepo(w, r)
38 if !ok {
39 return
40 }
41 s.secretWriteAPI(w, r, "repo", repo.ID, "create")
42}
43
44func (s *Server) groupSecretCreateAPI(w http.ResponseWriter, r *http.Request) {
45 g, _, ok := s.webhookAPIGroup(w, r)
46 if !ok {
47 return
48 }
49 s.secretWriteAPI(w, r, "group", g.ID, "create")
50}
51
52func (s *Server) repoSecretRevealAPI(w http.ResponseWriter, r *http.Request) {
53 repo, _, ok := s.webhookAPIRepo(w, r)
54 if !ok {
55 return
56 }
57 s.secretRevealAPI(w, r, "repo", repo.ID)
58}
59
60func (s *Server) groupSecretRevealAPI(w http.ResponseWriter, r *http.Request) {
61 g, _, ok := s.webhookAPIGroup(w, r)
62 if !ok {
63 return
64 }
65 s.secretRevealAPI(w, r, "group", g.ID)
66}
67
68func (s *Server) repoSecretUpdateAPI(w http.ResponseWriter, r *http.Request) {
69 repo, _, ok := s.webhookAPIRepo(w, r)
70 if !ok {
71 return
72 }
73 s.secretWriteAPI(w, r, "repo", repo.ID, "update")
74}
75
76func (s *Server) groupSecretUpdateAPI(w http.ResponseWriter, r *http.Request) {
77 g, _, ok := s.webhookAPIGroup(w, r)
78 if !ok {
79 return
80 }
81 s.secretWriteAPI(w, r, "group", g.ID, "update")
82}
83
84func (s *Server) repoSecretReplaceAPI(w http.ResponseWriter, r *http.Request) {
85 repo, _, ok := s.webhookAPIRepo(w, r)
86 if !ok {
87 return
88 }
89 s.secretWriteAPI(w, r, "repo", repo.ID, "replace")
90}
91
92func (s *Server) groupSecretReplaceAPI(w http.ResponseWriter, r *http.Request) {
93 g, _, ok := s.webhookAPIGroup(w, r)
94 if !ok {
95 return
96 }
97 s.secretWriteAPI(w, r, "group", g.ID, "replace")
98}
99
100func (s *Server) repoSecretDeleteAPI(w http.ResponseWriter, r *http.Request) {
101 repo, _, ok := s.webhookAPIRepo(w, r)
102 if !ok {
103 return
104 }
105 s.secretDeleteAPI(w, r, "repo", repo.ID)
106}
107
108func (s *Server) groupSecretDeleteAPI(w http.ResponseWriter, r *http.Request) {
109 g, _, ok := s.webhookAPIGroup(w, r)
110 if !ok {
111 return
112 }
113 s.secretDeleteAPI(w, r, "group", g.ID)
114}
115
116func (s *Server) secretListAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
117 list, err := s.Store.ListSecrets(r.Context(), kind, scopeID)
118 if err != nil {
119 http.Error(w, s.trErr(r, err), http.StatusInternalServerError)
120 return
121 }
122 out := make([]map[string]any, 0, len(list))
123 for _, m := range list {
124 out = append(out, secretMetaJSON(m))
125 }
126 w.Header().Set("Content-Type", "application/json")
127 _ = json.NewEncoder(w).Encode(map[string]any{"secrets": out})
128}
129
130func (s *Server) secretWriteAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64, mode string) {
131 var body secretBody
132 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
133 http.Error(w, s.tr(r, "err.json"), http.StatusBadRequest)
134 return
135 }
136 name := strings.TrimSpace(body.Name)
137 if mode != "create" {
138 name = strings.TrimSpace(r.PathValue("name"))
139 }
140 var err error
141 switch mode {
142 case "update":
143 err = s.Store.UpdateSecret(r.Context(), kind, scopeID, name, body.Value, body.Protected)
144 case "replace":
145 err = s.Store.ReplaceSecret(r.Context(), kind, scopeID, name, body.Value, body.Protected)
146 default:
147 err = s.Store.CreateSecret(r.Context(), kind, scopeID, name, body.Value, body.Protected, body.Invisible)
148 }
149 if err != nil {
150 s.writeSecretErr(w, r, err)
151 return
152 }
153 meta, err := s.secretMeta(r, kind, scopeID, name)
154 if err != nil {
155 s.writeSecretErr(w, r, err)
156 return
157 }
158 w.Header().Set("Content-Type", "application/json")
159 if mode == "create" {
160 w.WriteHeader(http.StatusCreated)
161 }
162 _ = json.NewEncoder(w).Encode(secretMetaJSON(meta))
163}
164
165func (s *Server) secretRevealAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
166 name := strings.TrimSpace(r.PathValue("name"))
167 value, err := s.Store.RevealSecret(r.Context(), kind, scopeID, name)
168 if err != nil {
169 s.writeSecretErr(w, r, err)
170 return
171 }
172 w.Header().Set("Content-Type", "application/json")
173 _ = json.NewEncoder(w).Encode(map[string]string{"name": name, "value": value})
174}
175
176func (s *Server) secretDeleteAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
177 if err := s.Store.DeleteSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.PathValue("name"))); err != nil {
178 s.writeSecretErr(w, r, err)
179 return
180 }
181 w.WriteHeader(http.StatusNoContent)
182}
183
184func (s *Server) secretMeta(r *http.Request, kind string, scopeID int64, name string) (store.SecretMeta, error) {
185 list, err := s.Store.ListSecrets(r.Context(), kind, scopeID)
186 if err != nil {
187 return store.SecretMeta{}, err
188 }
189 for _, m := range list {
190 if m.Name == name {
191 return m, nil
192 }
193 }
194 return store.SecretMeta{}, store.NotFound()
195}
196
197func secretMetaJSON(m store.SecretMeta) map[string]any {
198 created := ""
199 if !m.CreatedAt.IsZero() {
200 created = m.CreatedAt.UTC().Format(time.RFC3339)
201 }
202 return map[string]any{
203 "name": m.Name,
204 "protected": m.Protected,
205 "invisible": m.Invisible,
206 "created_at": created,
207 }
208}
209
210func (s *Server) writeSecretErr(w http.ResponseWriter, r *http.Request, err error) {
211 http.Error(w, s.trErr(r, err), secretStatus(err))
212}