BlueGit

timfa bluegit

Files

bluegit / internal / server / media.go

media.go

media.go 7.2 KiB Download Raw
1package server
2
3import (
4 "bytes"
5 "context"
6 "encoding/json"
7 "io"
8 "net/http"
9 "os"
10 "path/filepath"
11 "strconv"
12 "strings"
13 "time"
14
15 "gitlab.com/Timfa/bluegit/internal/access"
16 "gitlab.com/Timfa/bluegit/internal/i18n"
17 "gitlab.com/Timfa/bluegit/internal/logo"
18 "gitlab.com/Timfa/bluegit/internal/store"
19)
20
21func wantsModal(r *http.Request) bool {
22 return r.Header.Get("X-BlueGit") == "modal"
23}
24
25func writeModal(w http.ResponseWriter, ok bool, url, problem string, status int) {
26 if status == 0 {
27 status = http.StatusOK
28 }
29 w.Header().Set("Content-Type", "application/json; charset=utf-8")
30 w.WriteHeader(status)
31 _ = json.NewEncoder(w).Encode(map[string]any{"ok": ok, "url": url, "error": problem})
32}
33
34func (s *Server) finishCreate(w http.ResponseWriter, r *http.Request, path, notice string) {
35 if wantsModal(r) {
36 writeModal(w, true, path, "", http.StatusOK)
37 return
38 }
39 s.redirect(w, r, path, notice, "")
40}
41
42func (s *Server) failCreate(w http.ResponseWriter, r *http.Request, problem string) {
43 if wantsModal(r) {
44 writeModal(w, false, "", problem, http.StatusBadRequest)
45 return
46 }
47 s.redirect(w, r, "/new", "", problem)
48}
49
50func (s *Server) csrfValue(w http.ResponseWriter, r *http.Request) bool {
51 p := s.who(r)
52 if !p.OK || r.FormValue("csrf") == "" || r.FormValue("csrf") != p.Session.CSRF {
53 http.Error(w, s.tr(r, "err.badCSRF"), http.StatusBadRequest)
54 return false
55 }
56 return true
57}
58
59func (s *Server) saveProfile(w http.ResponseWriter, r *http.Request) {
60 u, ok := s.loginRequired(w, r)
61 if !ok || !s.csrfOK(w, r) {
62 return
63 }
64 if _, err := s.opSetProfile(r.Context(), u, r.FormValue("name"), r.FormValue("bio")); err != nil {
65 s.redirect(w, r, "/settings", "", s.trErr(r, err))
66 return
67 }
68 s.redirect(w, r, "/settings", s.tr(r, "flash.profile"), "")
69}
70
71func (s *Server) saveLanguage(w http.ResponseWriter, r *http.Request) {
72 u, ok := s.loginRequired(w, r)
73 if !ok || !s.csrfOK(w, r) {
74 return
75 }
76 lang, err := s.opSetLanguage(r.Context(), u, r.FormValue("language"))
77 if err != nil {
78 s.redirect(w, r, "/settings", "", s.trErr(r, err))
79 return
80 }
81 s.redirect(w, r, "/settings", i18n.T(lang, "flash.language"), "")
82}
83
84func (s *Server) saveGroup(w http.ResponseWriter, r *http.Request) {
85 g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
86 if !ok || !s.csrfOK(w, r) {
87 return
88 }
89 if err := s.opUpdateGroup(r.Context(), s.who(r).User, g, r.FormValue("description"), r.FormValue("visibility"), r.FormValue("default_role")); err != nil {
90 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.commitProblem(r, err))
91 return
92 }
93 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "")
94}
95
96func (s *Server) toggleStar(w http.ResponseWriter, r *http.Request) {
97 u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
98 if !ok || !s.csrfOK(w, r) {
99 return
100 }
101 if _, err := s.opToggleStar(r.Context(), u, repo); err != nil {
102 if !s.uiOK(w, r, repoURL(repo), err) {
103 return
104 }
105 }
106 back := r.FormValue("back")
107 if !strings.HasPrefix(back, "/") || strings.HasPrefix(back, "//") || strings.Contains(back, "://") {
108 back = repoURL(repo)
109 }
110 s.redirect(w, r, back, s.tr(r, "flash.star"), "")
111}
112
113func (s *Server) repoLogo(w http.ResponseWriter, r *http.Request) {
114 // Repo-logo volgt de Releases-regel: wie de releases mag zien, ziet ook
115 // het logo (privé repo met publieke releases); verder zoals guard.
116 repo, ok := s.logoRepo(w, r)
117 if !ok {
118 return
119 }
120 s.serveLogo(w, r, "repo", repo.ID, repo.LogoMIME)
121}
122
123func (s *Server) groupLogo(w http.ResponseWriter, r *http.Request) {
124 g, _, ok := s.guardGroup(w, r, access.RoleReadonly)
125 if !ok {
126 return
127 }
128 s.serveLogo(w, r, "group", g.ID, g.LogoMIME)
129}
130
131func (s *Server) uploadRepoLogo(w http.ResponseWriter, r *http.Request) {
132 _, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
133 if !ok || !s.readUpload(w, r) {
134 return
135 }
136 if err := s.storeLogo(r, "repo", repo.ID); err != nil {
137 s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.trErr(r, err))
138 return
139 }
140 s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.logo"), "")
141}
142
143func (s *Server) uploadGroupLogo(w http.ResponseWriter, r *http.Request) {
144 g, _, ok := s.guardGroup(w, r, access.RoleMaintainer)
145 if !ok || !s.readUpload(w, r) {
146 return
147 }
148 if err := s.storeLogo(r, "group", g.ID); err != nil {
149 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))
150 return
151 }
152 s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.logo"), "")
153}
154
155func (s *Server) readUpload(w http.ResponseWriter, r *http.Request) bool {
156 if err := r.ParseMultipartForm(logo.MaxUpload + 4096); err != nil {
157 http.Error(w, s.tr(r, "err.badForm"), http.StatusBadRequest)
158 return false
159 }
160 return s.csrfValue(w, r)
161}
162
163func (s *Server) storeLogo(r *http.Request, kind string, id int64) error {
164 f, hdr, err := r.FormFile("logo")
165 if err != nil {
166 return i18n.E("err.logoRead")
167 }
168 defer f.Close()
169 if hdr.Size > logo.MaxUpload {
170 return i18n.E("err.logoBig")
171 }
172 raw, err := io.ReadAll(io.LimitReader(f, logo.MaxUpload+1))
173 if err != nil {
174 return i18n.E("err.logoRead")
175 }
176 data, mime, err := logo.Normalize(raw)
177 if err != nil {
178 return err
179 }
180 path, err := s.logoPath(kind, id)
181 if err != nil {
182 return err
183 }
184 if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
185 return i18n.E("err.logoStore")
186 }
187 if err := os.WriteFile(path, data, 0o644); err != nil {
188 return i18n.E("err.logoStore")
189 }
190 return s.Store.SetLogoMIME(r.Context(), kind, id, mime)
191}
192
193func (s *Server) serveLogo(w http.ResponseWriter, r *http.Request, kind string, id int64, mime string) {
194 if mime == "" {
195 http.NotFound(w, r)
196 return
197 }
198 path, err := s.logoPath(kind, id)
199 if err != nil {
200 http.NotFound(w, r)
201 return
202 }
203 data, err := os.ReadFile(path)
204 if err != nil {
205 http.NotFound(w, r)
206 return
207 }
208 w.Header().Set("Content-Type", mime)
209 w.Header().Set("Cache-Control", "private, max-age=60")
210 http.ServeContent(w, r, "", time.Time{}, bytes.NewReader(data))
211}
212
213func (s *Server) logoPath(kind string, id int64) (string, error) {
214 if s.StateDir == "" {
215 return "", i18n.E("err.logoStore")
216 }
217 return filepath.Join(s.StateDir, "logos", kind+"-"+strconv.FormatInt(id, 10)), nil
218}
219
220func (s *Server) logoRepo(w http.ResponseWriter, r *http.Request) (store.Repo, bool) {
221 if repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo")); err == nil && repo.Visibility != "public" && !isCrawler(r) {
222 if _, role, err := s.webRole(r, repo); err == nil && releaseOnly(repo, role) {
223 return repo, true
224 }
225 }
226 _, repo, _, ok := s.guard(w, r, access.RoleReadonly)
227 return repo, ok
228}
229
230func (s *Server) repoCards(ctx context.Context, uid int64, repos []store.Repo, lang i18n.Lang) []RepoCard {
231 if len(repos) == 0 {
232 return nil
233 }
234 ids := make([]int64, len(repos))
235 for i, repo := range repos {
236 ids[i] = repo.ID
237 }
238 counts, mine, _ := s.Store.StarInfo(ctx, uid, ids)
239 cards := make([]RepoCard, 0, len(repos))
240 for _, repo := range repos {
241 cards = append(cards, RepoCard{
242 Repo: repo, Stars: counts[repo.ID], Starred: mine[repo.ID],
243 URL: s.absURL("/" + repo.FullPath()),
244 When: i18n.FormatDate(lang, repo.CreatedAt), Pushed: pushedLabel(lang, repo),
245 })
246 }
247 return cards
248}
249
250func (s *Server) starState(ctx context.Context, uid, repoID int64) (int, bool) {
251 counts, mine, err := s.Store.StarInfo(ctx, uid, []int64{repoID})
252 if err != nil {
253 return 0, false
254 }
255 return counts[repoID], mine[repoID]
256}