BlueGit

timfa bluegit

Files

bluegit / internal / server / repo_handlers.go

repo_handlers.go

feat: toon een commit zoals GitLab
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
dc9d9b26 History
repo_handlers.go 18.1 KiB Download Raw
1package server
2
3import (
4 "net/http"
5 "os"
6 "strconv"
7 "strings"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
10 "gitlab.com/Timfa/bluegit/internal/gitrepo"
11 "gitlab.com/Timfa/bluegit/internal/i18n"
12 "gitlab.com/Timfa/bluegit/internal/names"
13 "gitlab.com/Timfa/bluegit/internal/store"
14)
15
16func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) {
17 owner := r.PathValue("owner")
18 name := strings.TrimSuffix(r.PathValue("repo"), ".git")
19 repo, err := s.Store.RepoByPath(r.Context(), owner, name)
20 if err != nil {
21 http.NotFound(w, r)
22 return store.User{}, store.Repo{}, "", false
23 }
24 p := s.who(r)
25 var role access.Role
26 if p.OK {
27 role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
28 if err != nil {
29 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
30 return store.User{}, store.Repo{}, "", false
31 }
32 }
33 readable := role.CanRead() || repo.Visibility == "public"
34 if !readable {
35 if p.OK {
36 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
37 } else {
38 http.NotFound(w, r)
39 }
40 return store.User{}, store.Repo{}, "", false
41 }
42 if min != access.RoleReadonly && !role.AtLeast(min) {
43 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
44 return store.User{}, store.Repo{}, "", false
45 }
46 return p.User, repo, role, true
47}
48
49func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View {
50 v := s.view(w, r, title)
51 v.Repo = &repo
52 v.Role = role
53 v.CanWrite = role.CanWriteCode()
54 v.CanAdmin = role.CanManageSettings()
55 v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch)
56 v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git"
57 v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath())
58 return v
59}
60
61func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) {
62 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
63 if !ok {
64 return
65 }
66 v := s.repoView(w, r, repo, role, repo.Name)
67 v.Wide = true
68 s.fillOverview(r, &v, repo)
69 v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}, s.langOf(r))
70 s.render(w, "repo", v)
71}
72
73func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) {
74 r.SetPathValue("path", "")
75 s.tree(w, r)
76}
77
78func (s *Server) tree(w http.ResponseWriter, r *http.Request) {
79 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
80 if !ok {
81 return
82 }
83 rel, err := cleanRel(r.PathValue("path"))
84 if err != nil {
85 http.NotFound(w, r)
86 return
87 }
88 v := s.repoView(w, r, repo, role, rel)
89 v.Wide = true
90 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
91 if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" {
92 http.NotFound(w, r)
93 return
94 }
95 s.fillFiles(r, &v, repo, rel, false)
96 s.render(w, "files", v)
97}
98
99func (s *Server) blob(w http.ResponseWriter, r *http.Request) {
100 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
101 if !ok {
102 return
103 }
104 rel, err := cleanRel(r.PathValue("path"))
105 if err != nil || rel == "" {
106 http.NotFound(w, r)
107 return
108 }
109 v := s.repoView(w, r, repo, role, rel)
110 v.Wide = true
111 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
112 if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil {
113 http.NotFound(w, r)
114 return
115 }
116 s.fillFiles(r, &v, repo, rel, true)
117 s.render(w, "files", v)
118}
119
120func (s *Server) commits(w http.ResponseWriter, r *http.Request) {
121 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
122 if !ok {
123 return
124 }
125 v := s.repoView(w, r, repo, role, "title.commits")
126 v.Page = "commits"
127 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
128 list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50)
129 v.Commits = s.presentCommits(r.Context(), repo.ID, list, i18n.Parse(v.Lang))
130 s.render(w, "commits", v)
131}
132
133func (s *Server) commit(w http.ResponseWriter, r *http.Request) {
134 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
135 if !ok {
136 return
137 }
138 sha := r.PathValue("sha")
139 if !safeSHA(sha) {
140 http.NotFound(w, r)
141 return
142 }
143 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
144 c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
145 if err != nil {
146 http.NotFound(w, r)
147 return
148 }
149 v := s.repoView(w, r, repo, role, c.Subject)
150 v.Page = "commit"
151 v.Wide = true
152 lang := i18n.Parse(v.Lang)
153 rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, lang)
154 s.attachHeadPipeline(r.Context(), repo, &rows[0], lang)
155 v.Commit = &rows[0]
156 parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, c.SHA)
157 if err != nil && s.Log != nil {
158 s.Log.Warn("commitdiff", "sha", c.SHA, "err", err)
159 }
160 v.CommitDiff = presentCommitDiff(repo.FullPath(), c.SHA, parents, files)
161 s.render(w, "commit", v)
162}
163
164func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
165 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
166 if !ok {
167 return
168 }
169 v := s.repoView(w, r, repo, role, "title.branches")
170 v.Page = "branches"
171 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
172 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
173 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
174 for _, name := range names {
175 v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)})
176 }
177 s.render(w, "branches", v)
178}
179
180func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
181 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
182 if !ok {
183 return
184 }
185 v := s.repoView(w, r, repo, role, "title.mrs")
186 v.Page = "mrs"
187 v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID)
188 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
189 names, _ := gitrepo.Branches(r.Context(), s.Git, dir)
190 for _, name := range names {
191 v.Branches = append(v.Branches, BranchRow{Name: name})
192 }
193 s.render(w, "mrs", v)
194}
195
196func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
197 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
198 if !ok || !s.csrfOK(w, r) {
199 return
200 }
201 if !role.CanWriteCode() {
202 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
203 return
204 }
205 source := safeRev(r.FormValue("source"), "")
206 target := safeRev(r.FormValue("target"), repo.DefaultBranch)
207 if source == "" || source == target {
208 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.tr(r, "err.branches"))
209 return
210 }
211 mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target)
212 if err != nil {
213 s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.trErr(r, err))
214 return
215 }
216 num := strconv.FormatInt(mr.Number, 10)
217 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
218 if sha := gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
219 s.startOneMergePipeline(r.Context(), repo, sha, u.Username, "", mr)
220 }
221 s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, s.tr(r, "hook.mr", num, mr.Title), repoURL(repo)+"/-/merge-requests/"+num))
222 s.recordContribution(u.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
223 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
224}
225
226func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
227 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
228 if !ok {
229 return
230 }
231 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
232 if err != nil {
233 http.NotFound(w, r)
234 return
235 }
236 mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
237 if err != nil {
238 http.NotFound(w, r)
239 return
240 }
241 v := s.repoView(w, r, repo, role, mr.Title)
242 v.Page = "mr"
243 v.MR = &mr
244 v.Wide = true
245 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
246 v.CanComment = role.AtLeast(access.RoleReadonly)
247 v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch))
248 v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch))
249 v.MergeBlocks = s.mergeBlocks(r, repo, mr)
250 s.fillMRPipeline(r, &v, repo, mr)
251 s.fillReviews(r, &v, repo, mr, role)
252 if u.ID != 0 {
253 mine := u.ID == mr.AuthorID || role.CanManageSettings()
254 v.CanClose = mr.Status == "open" && mine
255 v.CanReopen = mr.Status == "closed" && mine
256 }
257 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
258 diff, err := gitrepo.DiffStat(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
259 if err == nil {
260 v.Diff = diff
261 }
262 files, _ := gitrepo.DiffFiles(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch)
263 notes, _ := s.Store.ListNotes(r.Context(), mr.ID)
264 v.Notes, v.DiffFiles = arrangeNotes(notes, files, s.langOf(r))
265 s.render(w, "mr", v)
266}
267
268func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
269 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
270 if !ok || !s.csrfOK(w, r) {
271 return
272 }
273 if u.ID == 0 || !role.AtLeast(access.RoleReadonly) {
274 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
275 return
276 }
277 mr, err := s.mrFromRequest(r, repo.ID)
278 if err != nil {
279 http.NotFound(w, r)
280 return
281 }
282 back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
283 path, pathOK := repoPath(r.FormValue("path"))
284 if !pathOK {
285 s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))
286 return
287 }
288 if path == "" {
289 if _, err := s.Store.AddNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body")); err != nil {
290 s.redirect(w, r, back, "", s.trErr(r, err))
291 return
292 }
293 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
294 return
295 }
296 start, _ := strconv.Atoi(r.FormValue("line_start"))
297 end, _ := strconv.Atoi(r.FormValue("line_end"))
298 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
299 blob, err := gitrepo.BlobText(r.Context(), s.Git, dir, mr.SourceBranch, path)
300 if err != nil {
301 s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))
302 return
303 }
304 lines := gitrepo.SplitLines(blob)
305 if start < 1 || end < start || end > len(lines) {
306 s.redirect(w, r, back, "", s.tr(r, "err.sugLines"))
307 return
308 }
309 base := strings.Join(lines[start-1:end], "\n")
310 suggestion, _ := gitrepo.ParseSuggestion(r.FormValue("body"))
311 if _, err := s.Store.AddLineNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body"), path, start, end, suggestion, base); err != nil {
312 s.redirect(w, r, back, "", s.trErr(r, err))
313 return
314 }
315 s.noteRequestsChanges(r, repo, mr, u.ID, suggestion)
316 s.redirect(w, r, back, s.tr(r, "flash.note"), "")
317}
318
319func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
320 u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
321 if !ok || !s.csrfOK(w, r) {
322 return
323 }
324 mr, err := s.mrFromRequest(r, repo.ID)
325 if err != nil || mr.Status != "open" {
326 http.NotFound(w, r)
327 return
328 }
329 patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
330 if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
331 http.Error(w, s.tr(r, "err.targetAccess"), http.StatusForbidden)
332 return
333 }
334 if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {
335 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", blocks[0])
336 return
337 }
338 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
339 work, err := s.scratchDir("merge")
340 if err != nil {
341 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", s.commitProblem(r, err))
342 return
343 }
344 defer os.RemoveAll(work)
345 email := u.Username + "@users.git.timfalken.com"
346 msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
347 if err := s.postReceive(r.Context(), repo, u, dir, func() error {
348 return gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns)
349 }); err != nil {
350 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", s.commitProblem(r, err))
351 return
352 }
353 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged")
354 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.merged"), "")
355}
356
357func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
358 u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
359 if !ok || !s.csrfOK(w, r) {
360 return
361 }
362 mr, err := s.mrFromRequest(r, repo.ID)
363 if err != nil {
364 http.NotFound(w, r)
365 return
366 }
367 if mr.AuthorID != u.ID && !role.CanManageSettings() {
368 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
369 return
370 }
371 _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed")
372 s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.closed"), "")
373}
374
375func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
376 n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
377 if err != nil {
378 return store.MergeRequest{}, err
379 }
380 return s.Store.MergeRequestByNumber(r.Context(), repoID, n)
381}
382
383func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) {
384 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
385 if !ok {
386 return
387 }
388 if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" {
389 if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 {
390 http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther)
391 return
392 }
393 }
394 v := s.repoView(w, r, repo, role, "title.pipelines")
395 v.Wide = true
396 v.Page = "pipelines"
397 s.fillPipelines(r, &v, repo)
398 if wantsJSON(r) {
399 s.writePipeList(w, v)
400 return
401 }
402 s.render(w, "pipelines", v)
403}
404
405func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) {
406 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
407 if !ok {
408 return
409 }
410 id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
411 if err != nil {
412 http.NotFound(w, r)
413 return
414 }
415 p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
416 if err != nil {
417 http.NotFound(w, r)
418 return
419 }
420 v := s.repoView(w, r, repo, role, "title.pipeline")
421 v.Wide = true
422 v.Page = "pipelines"
423 v.Pipe = &p
424 jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
425 v.Jobs = jobs
426 ranks := s.queueRanks(r.Context())
427 tr := func(key string, args ...any) string { return s.tr(r, key, args...) }
428 v.PipeStatus = displayStatus(p.Status, jobs)
429 v.PipeLabel = tr("pipe." + v.PipeStatus)
430 v.PipeJobs = linksFor(jobs, ranks, tr)
431 v.Live = jobsLive(p.Status, jobs)
432 v.LiveURL = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10)
433 if wantsJSON(r) {
434 s.writePipeDetail(w, v)
435 return
436 }
437 s.render(w, "pipeline", v)
438}
439
440func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
441 u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
442 if !ok || !s.csrfOK(w, r) {
443 return
444 }
445 ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
446 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
447 shaOut, err := gitSHA(r, s.Git, dir, ref)
448 if err != nil {
449 s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", s.tr(r, "err.branchMissing"))
450 return
451 }
452 s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username, "web", "", nil)
453 s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
454}
455
456func (s *Server) releases(w http.ResponseWriter, r *http.Request) {
457 _, repo, role, ok := s.guard(w, r, access.RoleReadonly)
458 if !ok {
459 return
460 }
461 v := s.repoView(w, r, repo, role, "title.releases")
462 v.Page = "releases"
463 v.Wide = true
464 v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID)
465 s.render(w, "releases", v)
466}
467
468func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
469 u, ok := s.loginRequired(w, r)
470 if !ok || !s.csrfOK(w, r) {
471 return
472 }
473 if s.StoragePath() == "" {
474 msg := s.tr(r, "err.noStorage")
475 if wantsModal(r) {
476 writeModal(w, false, "", msg, http.StatusBadRequest)
477 return
478 }
479 s.redirect(w, r, "/", "", msg)
480 return
481 }
482 name, err := names.Slug("repo", r.FormValue("name"))
483 if err != nil {
484 s.failCreate(w, r, s.tr(r, "slug.bad"))
485 return
486 }
487 ownerKind := "user"
488 ownerID := u.ID
489 if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {
490 g, err := s.Store.GroupByPath(r.Context(), gpath)
491 if err != nil {
492 s.failCreate(w, r, s.tr(r, "err.groupMissing"))
493 return
494 }
495 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
496 if err != nil || !role.CanManageSettings() {
497 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
498 return
499 }
500 ownerKind, ownerID = "group", g.ID
501 }
502 vis := r.FormValue("visibility")
503 if vis != "public" {
504 vis = "private"
505 }
506 repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)
507 if err != nil {
508 s.failCreate(w, r, s.trErr(r, err))
509 return
510 }
511 dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
512 if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
513 _ = s.Store.DeleteRepo(r.Context(), repo.ID)
514 s.failCreate(w, r, s.tr(r, "err.gitInit", err.Error()))
515 return
516 }
517 s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
518}
519
520func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
521 u, ok := s.loginRequired(w, r)
522 if !ok || !s.csrfOK(w, r) {
523 return
524 }
525 display := strings.TrimSpace(r.FormValue("name"))
526 path, err := names.Slug("group", display)
527 if err != nil {
528 s.failCreate(w, r, s.tr(r, "slug.bad"))
529 return
530 }
531 role := access.Role("")
532 if raw := strings.TrimSpace(r.FormValue("default_role")); raw != "" {
533 role, err = access.ParseRole(raw)
534 if err != nil {
535 s.failCreate(w, r, s.trErr(r, err))
536 return
537 }
538 }
539 g, err := s.Store.CreateGroup(r.Context(), u.ID, display, path, r.FormValue("description"), role)
540 if err != nil {
541 s.failCreate(w, r, s.trErr(r, err))
542 return
543 }
544 s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated"))
545}
546
547func toEntries(base string, in []gitrepo.Entry) []EntryRow {
548 var out []EntryRow
549 for _, e := range in {
550 p := e.Name
551 if base != "" {
552 p = base + "/" + e.Name
553 }
554 out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p})
555 }
556 return out
557}
558
559func cleanRel(p string) (string, error) {
560 p = strings.TrimPrefix(p, "/")
561 if p == "" || p == "." {
562 return "", nil
563 }
564 if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") {
565 return "", errBadID
566 }
567 return p, nil
568}
569
570func safeRev(s, fallback string) string {
571 if s == "" {
572 return fallback
573 }
574 if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") {
575 return fallback
576 }
577 return s
578}
579
580func safeSHA(s string) bool {
581 if len(s) < 7 || len(s) > 64 {
582 return false
583 }
584 for _, c := range s {
585 if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
586 return false
587 }
588 }
589 return true
590}