BlueGit

timfa bluegit

Files

bluegit / internal / server / release_access.go

release_access.go

release_access.go 4.3 KiB Download Raw
1package server
2
3import (
4 "net/http"
5 "strings"
6 "unicode/utf8"
7
8 "gitlab.com/Timfa/bluegit/internal/access"
9 "gitlab.com/Timfa/bluegit/internal/i18n"
10 "gitlab.com/Timfa/bluegit/internal/store"
11)
12
13// Zichtbaarheid van releases staat los van die van de code:
14//
15// - inherit: releases volgen de repo.
16// - private: releases alleen voor leden, ook als de code publiek is.
17// - public: releases (pagina, notities, assets) voor iedereen, ook als
18// de code privé is. Niet-leden zien dan alleen naam, korte
19// beschrijving en de Releases-pagina. Code, archieven, clone, raw,
20// commits, issues, MR's, pipelines, logs en artefacten blijven privé:
21// die routes gebruiken guard/apiRepo, die alleen op repo.Visibility
22// en lidmaatschap letten.
23
24// canSeeReleases: lid, of releases publiek.
25func canSeeReleases(repo store.Repo, role access.Role) bool {
26 return role.CanRead() || repo.ReleasesPublic()
27}
28
29// releaseOnly: de kijker ziet van deze repo alleen de releases.
30func releaseOnly(repo store.Repo, role access.Role) bool {
31 return !role.CanRead() && repo.Visibility != "public" && repo.ReleasesPublic()
32}
33
34// shortDesc kort de beschrijving in voor overzichten van release-only repo's.
35func shortDesc(s string) string {
36 s = strings.TrimSpace(strings.SplitN(s, "\n", 2)[0])
37 if utf8.RuneCountInString(s) > 140 {
38 s = string([]rune(s)[:139]) + "…"
39 }
40 return s
41}
42
43// releaseOnlyCard is wat een niet-lid van een privé repo met publieke
44// releases in overzichten ziet: naam, korte beschrijving, verder niets.
45func releaseOnlyCard(r store.Repo) store.Repo {
46 return store.Repo{ID: r.ID, OwnerKind: r.OwnerKind, OwnerPath: r.OwnerPath, Name: r.Name,
47 Description: shortDesc(r.Description), Visibility: r.Visibility, ReleaseVisibility: r.ReleaseVisibility}
48}
49
50func (s *Server) releaseOnlyRepos(r *http.Request, viewer int64) []store.Repo {
51 ids, err := s.Store.ListReleaseOnlyRepoIDs(r.Context(), viewer)
52 if err != nil {
53 return nil
54 }
55 repos, err := s.Store.ReposByIDs(r.Context(), ids)
56 if err != nil {
57 return nil
58 }
59 out := make([]store.Repo, 0, len(repos))
60 for _, repo := range repos {
61 out = append(out, releaseOnlyCard(repo))
62 }
63 return out
64}
65
66// repoRoleOf geeft de rol van de kijker (web), met crawlers als anoniem.
67func (s *Server) webRole(r *http.Request, repo store.Repo) (principal, access.Role, error) {
68 p := s.who(r)
69 var role access.Role
70 if p.OK {
71 var err error
72 role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID)
73 if err != nil {
74 return p, role, err
75 }
76 }
77 if isCrawler(r) {
78 return principal{}, access.RoleNone, nil
79 }
80 return p, role, nil
81}
82
83// guardReleases is guard voor de Releases-pagina en assets.
84func (s *Server) guardReleases(w http.ResponseWriter, r *http.Request) (store.User, store.Repo, access.Role, bool) {
85 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
86 if err != nil {
87 http.NotFound(w, r)
88 return store.User{}, store.Repo{}, "", false
89 }
90 p, role, err := s.webRole(r, repo)
91 if err != nil {
92 http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError)
93 return store.User{}, store.Repo{}, "", false
94 }
95 if !canSeeReleases(repo, role) {
96 if isCrawler(r) {
97 s.writeLockedCard(w, r)
98 } else if p.OK {
99 http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
100 } else {
101 http.NotFound(w, r)
102 }
103 return store.User{}, store.Repo{}, "", false
104 }
105 return p.User, repo, role, true
106}
107
108// apiRepoReleases is apiRepo voor de release-API (lijst en assets).
109func (s *Server) apiRepoReleases(w http.ResponseWriter, r *http.Request) (store.Repo, access.Role, bool) {
110 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
111 if err != nil {
112 s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
113 return store.Repo{}, "", false
114 }
115 role, err := s.Store.EffectiveRole(r.Context(), apiUser(r).ID, repo.ID)
116 if err != nil {
117 s.writeAPIErr(w, r, fail(500, err))
118 return store.Repo{}, "", false
119 }
120 if !canSeeReleases(repo, role) {
121 s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
122 return store.Repo{}, "", false
123 }
124 return repo, role, true
125}
126
127// releasesSlash: /-/releases/ gaat naar /-/releases, met dezelfde toegang (anders 404).
128func (s *Server) releasesSlash(w http.ResponseWriter, r *http.Request) {
129 _, repo, _, ok := s.guardReleases(w, r)
130 if !ok {
131 return
132 }
133 http.Redirect(w, r, "/"+repo.FullPath()+"/-/releases", http.StatusSeeOther)
134}