BlueGit

timfa bluegit

Files

bluegit / internal / server / people.go

people.go

people.go 6.4 KiB Download Raw
1package server
2
3import (
4 "context"
5 "net/http"
6 "strings"
7 "unicode/utf8"
8
9 "gitlab.com/Timfa/bluegit/internal/gitrepo"
10 "gitlab.com/Timfa/bluegit/internal/i18n"
11 "gitlab.com/Timfa/bluegit/internal/names"
12 "gitlab.com/Timfa/bluegit/internal/store"
13)
14
15// userShort stuurt /<username> door naar /users/<username>.
16// Het eerste paddeel is de gedeelde namespace van gebruikers en groepen
17// (repositories staan op /<owner>/<repo>, groepen op /groups/<pad>).
18// Vaste routes zoals /login blijven specifieker. Alleen een bestaande
19// gebruiker krijgt een redirect; een groepsnaam of onbekende naam niet.
20func (s *Server) userShort(w http.ResponseWriter, r *http.Request) {
21 name := strings.ToLower(strings.TrimSpace(r.PathValue("name")))
22 if names.ValidUsername(name) != nil {
23 http.NotFound(w, r)
24 return
25 }
26 if _, err := s.Store.UserByUsername(r.Context(), name); err != nil {
27 http.NotFound(w, r)
28 return
29 }
30 http.Redirect(w, r, "/users/"+name, http.StatusFound)
31}
32
33func (s *Server) profile(w http.ResponseWriter, r *http.Request) {
34 name := strings.ToLower(strings.TrimSpace(r.PathValue("username")))
35 u, err := s.Store.UserByUsername(r.Context(), name)
36 if err != nil {
37 http.NotFound(w, r)
38 return
39 }
40 v := s.view(w, r, u.Username)
41 v.Profile = &u
42 viewer := int64(0)
43 if v.User != nil {
44 viewer = v.User.ID
45 }
46 ids, err := s.Store.ListRepoIDs(r.Context(), viewer)
47 if err != nil {
48 ids = nil
49 }
50 v.Heat = s.heatmap(r.Context(), u.ID, ids, s.langOf(r))
51 total := 0
52 if v.Heat != nil {
53 total = v.Heat.Total
54 }
55 card, repos, groups := s.profileCard(r, u, viewer, total)
56 card.Heading = "h1"
57 v.Card = &card
58 v.Repos = repos
59 v.Cards = s.repoCards(r.Context(), viewer, repos, s.langOf(r))
60 v.Groups = groups
61 s.render(w, "profile", v)
62}
63
64// profileCard bouwt het blok en de lijsten van iemands eigen repositories
65// en groepen, beperkt tot wat de kijker mag zien.
66func (s *Server) profileCard(r *http.Request, person store.User, viewer int64, contrib int) (ProfileCard, []store.Repo, []store.Group) {
67 repos := s.ownedReposVisible(r.Context(), person.ID, viewer)
68 groups := s.groupsVisible(r.Context(), person.ID, viewer)
69 name := strings.TrimSpace(person.DisplayName)
70 if name == "" {
71 name = person.Username
72 }
73 card := ProfileCard{
74 User: person, Name: name, Since: i18n.FormatDate(s.langOf(r), person.CreatedAt),
75 Bio: strings.TrimSpace(person.Bio), URL: s.absURL("/users/" + person.Username),
76 Repos: len(repos), Groups: len(groups), Contrib: contrib,
77 Own: viewer != 0 && viewer == person.ID,
78 }
79 return card, repos, groups
80}
81
82func (s *Server) ownedReposVisible(ctx context.Context, owner, viewer int64) []store.Repo {
83 all, err := s.Store.ReposByOwner(ctx, owner)
84 if err != nil {
85 return nil
86 }
87 allowed, err := s.Store.ListRepoIDs(ctx, viewer)
88 if err != nil {
89 return nil
90 }
91 set := map[int64]bool{}
92 for _, id := range allowed {
93 set[id] = true
94 }
95 var out []store.Repo
96 for _, repo := range all {
97 if set[repo.ID] {
98 out = append(out, repo)
99 }
100 }
101 return out
102}
103
104func (s *Server) groupsVisible(ctx context.Context, member, viewer int64) []store.Group {
105 all, err := s.Store.ListGroups(ctx, member)
106 if err != nil {
107 return nil
108 }
109 var out []store.Group
110 for _, g := range all {
111 if g.Visibility == "public" {
112 out = append(out, g)
113 continue
114 }
115 if viewer == 0 {
116 continue
117 }
118 role, err := s.Store.GroupRole(ctx, g.ID, viewer)
119 if err == nil && role.CanRead() {
120 out = append(out, g)
121 }
122 }
123 return out
124}
125
126func (s *Server) presentCommits(ctx context.Context, repoID int64, in []gitrepo.Commit, lang i18n.Lang) []CommitRow {
127 shas := make([]string, 0, len(in))
128 for _, c := range in {
129 if c.SHA != "" {
130 shas = append(shas, c.SHA)
131 }
132 }
133 pushers := map[string]store.Pusher{}
134 if s.Store != nil && repoID != 0 && len(shas) > 0 {
135 if got, err := s.Store.PushersBySHA(ctx, repoID, shas); err == nil {
136 pushers = got
137 }
138 }
139 cache := map[string]store.User{}
140 miss := map[string]bool{}
141 var rows []CommitRow
142 for _, c := range in {
143 rows = append(rows, s.oneCommit(ctx, c, pushers[c.SHA], lang, cache, miss))
144 }
145 return rows
146}
147
148func (s *Server) oneCommit(ctx context.Context, c gitrepo.Commit, pusher store.Pusher, lang i18n.Lang, cache map[string]store.User, miss map[string]bool) CommitRow {
149 row := CommitRow{
150 SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date,
151 Subject: c.Subject, Body: c.Body, When: i18n.Ago(lang, c.Unix),
152 Initial: initialOf(c.Author),
153 }
154 if u, ok := s.userForEmail(ctx, c.Email, cache, miss); ok {
155 row.Author = u.Username
156 row.Who = strings.TrimSpace(u.DisplayName)
157 if row.Who == "" {
158 row.Who = u.Username
159 }
160 row.WhoURL = "/users/" + u.Username
161 row.UserURL = row.WhoURL
162 row.Avatar = u.AvatarURL
163 row.Initial = initialOf(u.Username)
164 return finishCommit(row, c.Email, c.Author)
165 }
166 if pusher.UserID != 0 && pusher.Username != "" {
167 row.Author = pusher.Username
168 row.UserURL = "/users/" + pusher.Username
169 row.Avatar = pusher.AvatarURL
170 row.Initial = initialOf(pusher.Username)
171 raw := strings.TrimSpace(c.Author)
172 if raw != "" && !strings.EqualFold(raw, pusher.Username) {
173 row.RawName = raw
174 row.PushedBy = pusher.Username
175 }
176 }
177 return finishCommit(row, c.Email, c.Author)
178}
179
180func (s *Server) userForEmail(ctx context.Context, email string, cache map[string]store.User, miss map[string]bool) (store.User, bool) {
181 if s.Store == nil {
182 return store.User{}, false
183 }
184 key := strings.ToLower(strings.TrimSpace(email))
185 if u, ok := cache[key]; ok {
186 return u, true
187 }
188 if miss[key] {
189 return store.User{}, false
190 }
191 u, ok := s.Store.UserByGitEmail(ctx, email)
192 if !ok {
193 miss[key] = true
194 return store.User{}, false
195 }
196 cache[key] = u
197 return u, true
198}
199
200// tileHue kiest een vaste kleurklasse bij een naam, zodat dezelfde
201// repo of groep steeds hetzelfde vierkantje krijgt.
202func tileHue(name string) string {
203 n := 0
204 for _, r := range strings.ToLower(strings.TrimSpace(name)) {
205 n = n*33 + int(r)
206 }
207 if n < 0 {
208 n = -n
209 }
210 return "hue" + string(rune('0'+(n%8)))
211}
212
213func initialOf(s string) string {
214 s = strings.TrimSpace(s)
215 if s == "" {
216 return "?"
217 }
218 r, _ := utf8.DecodeRuneInString(s)
219 return strings.ToUpper(string(r))
220}
221
222// trimSlash stuurt een pagina-URL met afsluitende slash permanent door naar
223// dezelfde URL zonder slash (querystring blijft behouden).
224func (s *Server) trimSlash(w http.ResponseWriter, r *http.Request) {
225 target := strings.TrimRight(r.URL.Path, "/")
226 if target == "" {
227 target = "/"
228 }
229 if r.URL.RawQuery != "" {
230 target += "?" + r.URL.RawQuery
231 }
232 http.Redirect(w, r, target, http.StatusMovedPermanently)
233}