kot.pink
1package state
2
3import (
4 "crypto/hmac"
5 "crypto/sha256"
6 "encoding/hex"
7 "fmt"
8 "log"
9 "net/http"
10 "slices"
11 "strings"
12 "time"
13
14 comatproto "github.com/bluesky-social/indigo/api/atproto"
15 "github.com/bluesky-social/indigo/atproto/identity"
16 "github.com/bluesky-social/indigo/atproto/syntax"
17 lexutil "github.com/bluesky-social/indigo/lex/util"
18 "github.com/go-chi/chi/v5"
19 "tangled.sh/tangled.sh/core/api/tangled"
20 "tangled.sh/tangled.sh/core/appview/db"
21 "tangled.sh/tangled.sh/core/appview/pages"
22)
23
24func (s *State) Profile(w http.ResponseWriter, r *http.Request) {
25 tabVal := r.URL.Query().Get("tab")
26 switch tabVal {
27 case "":
28 s.profilePage(w, r)
29 case "repos":
30 s.reposPage(w, r)
31 }
32}
33
34func (s *State) profilePage(w http.ResponseWriter, r *http.Request) {
35 didOrHandle := chi.URLParam(r, "user")
36 if didOrHandle == "" {
37 http.Error(w, "Bad request", http.StatusBadRequest)
38 return
39 }
40
41 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
42 if !ok {
43 s.pages.Error404(w)
44 return
45 }
46
47 profile, err := db.GetProfile(s.db, ident.DID.String())
48 if err != nil {
49 log.Printf("getting profile data for %s: %s", ident.DID.String(), err)
50 }
51
52 repos, err := db.GetRepos(
53 s.db,
54 0,
55 db.FilterEq("did", ident.DID.String()),
56 )
57 if err != nil {
58 log.Printf("getting repos for %s: %s", ident.DID.String(), err)
59 }
60
61 // filter out ones that are pinned
62 pinnedRepos := []db.Repo{}
63 for i, r := range repos {
64 // if this is a pinned repo, add it
65 if slices.Contains(profile.PinnedRepos[:], r.RepoAt()) {
66 pinnedRepos = append(pinnedRepos, r)
67 }
68
69 // if there are no saved pins, add the first 4 repos
70 if profile.IsPinnedReposEmpty() && i < 4 {
71 pinnedRepos = append(pinnedRepos, r)
72 }
73 }
74
75 collaboratingRepos, err := db.CollaboratingIn(s.db, ident.DID.String())
76 if err != nil {
77 log.Printf("getting collaborating repos for %s: %s", ident.DID.String(), err)
78 }
79
80 pinnedCollaboratingRepos := []db.Repo{}
81 for _, r := range collaboratingRepos {
82 // if this is a pinned repo, add it
83 if slices.Contains(profile.PinnedRepos[:], r.RepoAt()) {
84 pinnedCollaboratingRepos = append(pinnedCollaboratingRepos, r)
85 }
86 }
87
88 timeline, err := db.MakeProfileTimeline(s.db, ident.DID.String())
89 if err != nil {
90 log.Printf("failed to create profile timeline for %s: %s", ident.DID.String(), err)
91 }
92
93 var didsToResolve []string
94 for _, r := range collaboratingRepos {
95 didsToResolve = append(didsToResolve, r.Did)
96 }
97 for _, byMonth := range timeline.ByMonth {
98 for _, pe := range byMonth.PullEvents.Items {
99 didsToResolve = append(didsToResolve, pe.Repo.Did)
100 }
101 for _, ie := range byMonth.IssueEvents.Items {
102 didsToResolve = append(didsToResolve, ie.Metadata.Repo.Did)
103 }
104 for _, re := range byMonth.RepoEvents {
105 didsToResolve = append(didsToResolve, re.Repo.Did)
106 if re.Source != nil {
107 didsToResolve = append(didsToResolve, re.Source.Did)
108 }
109 }
110 }
111
112 resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
113 didHandleMap := make(map[string]string)
114 for _, identity := range resolvedIds {
115 if !identity.Handle.IsInvalidHandle() {
116 didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())
117 } else {
118 didHandleMap[identity.DID.String()] = identity.DID.String()
119 }
120 }
121
122 followers, following, err := db.GetFollowerFollowing(s.db, ident.DID.String())
123 if err != nil {
124 log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
125 }
126
127 loggedInUser := s.oauth.GetUser(r)
128 followStatus := db.IsNotFollowing
129 if loggedInUser != nil {
130 followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
131 }
132
133 now := time.Now()
134 startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
135 punchcard, err := db.MakePunchcard(
136 s.db,
137 db.FilterEq("did", ident.DID.String()),
138 db.FilterGte("date", startOfYear.Format(time.DateOnly)),
139 db.FilterLte("date", now.Format(time.DateOnly)),
140 )
141 if err != nil {
142 log.Println("failed to get punchcard for did", "did", ident.DID.String(), "err", err)
143 }
144
145 profileAvatarUri := s.GetAvatarUri(ident.Handle.String())
146 s.pages.ProfilePage(w, pages.ProfilePageParams{
147 LoggedInUser: loggedInUser,
148 Repos: pinnedRepos,
149 CollaboratingRepos: pinnedCollaboratingRepos,
150 DidHandleMap: didHandleMap,
151 Card: pages.ProfileCard{
152 UserDid: ident.DID.String(),
153 UserHandle: ident.Handle.String(),
154 AvatarUri: profileAvatarUri,
155 Profile: profile,
156 FollowStatus: followStatus,
157 Followers: followers,
158 Following: following,
159 },
160 Punchcard: punchcard,
161 ProfileTimeline: timeline,
162 })
163}
164
165func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
166 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
167 if !ok {
168 s.pages.Error404(w)
169 return
170 }
171
172 profile, err := db.GetProfile(s.db, ident.DID.String())
173 if err != nil {
174 log.Printf("getting profile data for %s: %s", ident.DID.String(), err)
175 }
176
177 repos, err := db.GetRepos(
178 s.db,
179 0,
180 db.FilterEq("did", ident.DID.String()),
181 )
182 if err != nil {
183 log.Printf("getting repos for %s: %s", ident.DID.String(), err)
184 }
185
186 loggedInUser := s.oauth.GetUser(r)
187 followStatus := db.IsNotFollowing
188 if loggedInUser != nil {
189 followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
190 }
191
192 followers, following, err := db.GetFollowerFollowing(s.db, ident.DID.String())
193 if err != nil {
194 log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
195 }
196
197 profileAvatarUri := s.GetAvatarUri(ident.Handle.String())
198
199 s.pages.ReposPage(w, pages.ReposPageParams{
200 LoggedInUser: loggedInUser,
201 Repos: repos,
202 DidHandleMap: map[string]string{ident.DID.String(): ident.Handle.String()},
203 Card: pages.ProfileCard{
204 UserDid: ident.DID.String(),
205 UserHandle: ident.Handle.String(),
206 AvatarUri: profileAvatarUri,
207 Profile: profile,
208 FollowStatus: followStatus,
209 Followers: followers,
210 Following: following,
211 },
212 })
213}
214
215func (s *State) GetAvatarUri(handle string) string {
216 secret := s.config.Avatar.SharedSecret
217 h := hmac.New(sha256.New, []byte(secret))
218 h.Write([]byte(handle))
219 signature := hex.EncodeToString(h.Sum(nil))
220 return fmt.Sprintf("%s/%s/%s", s.config.Avatar.Host, signature, handle)
221}
222
223func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {
224 user := s.oauth.GetUser(r)
225
226 err := r.ParseForm()
227 if err != nil {
228 log.Println("invalid profile update form", err)
229 s.pages.Notice(w, "update-profile", "Invalid form.")
230 return
231 }
232
233 profile, err := db.GetProfile(s.db, user.Did)
234 if err != nil {
235 log.Printf("getting profile data for %s: %s", user.Did, err)
236 }
237
238 profile.Description = r.FormValue("description")
239 profile.IncludeBluesky = r.FormValue("includeBluesky") == "on"
240 profile.Location = r.FormValue("location")
241
242 var links [5]string
243 for i := range 5 {
244 iLink := r.FormValue(fmt.Sprintf("link%d", i))
245 links[i] = iLink
246 }
247 profile.Links = links
248
249 // Parse stats (exactly 2)
250 stat0 := r.FormValue("stat0")
251 stat1 := r.FormValue("stat1")
252
253 if stat0 != "" {
254 profile.Stats[0].Kind = db.VanityStatKind(stat0)
255 }
256
257 if stat1 != "" {
258 profile.Stats[1].Kind = db.VanityStatKind(stat1)
259 }
260
261 if err := db.ValidateProfile(s.db, profile); err != nil {
262 log.Println("invalid profile", err)
263 s.pages.Notice(w, "update-profile", err.Error())
264 return
265 }
266
267 s.updateProfile(profile, w, r)
268}
269
270func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) {
271 user := s.oauth.GetUser(r)
272
273 err := r.ParseForm()
274 if err != nil {
275 log.Println("invalid profile update form", err)
276 s.pages.Notice(w, "update-profile", "Invalid form.")
277 return
278 }
279
280 profile, err := db.GetProfile(s.db, user.Did)
281 if err != nil {
282 log.Printf("getting profile data for %s: %s", user.Did, err)
283 }
284
285 i := 0
286 var pinnedRepos [6]syntax.ATURI
287 for key, values := range r.Form {
288 if i >= 6 {
289 log.Println("invalid pin update form", err)
290 s.pages.Notice(w, "update-profile", "Only 6 repositories can be pinned at a time.")
291 return
292 }
293 if strings.HasPrefix(key, "pinnedRepo") && len(values) > 0 && values[0] != "" && i < 6 {
294 aturi, err := syntax.ParseATURI(values[0])
295 if err != nil {
296 log.Println("invalid profile update form", err)
297 s.pages.Notice(w, "update-profile", "Invalid form.")
298 return
299 }
300 pinnedRepos[i] = aturi
301 i++
302 }
303 }
304 profile.PinnedRepos = pinnedRepos
305
306 s.updateProfile(profile, w, r)
307}
308
309func (s *State) updateProfile(profile *db.Profile, w http.ResponseWriter, r *http.Request) {
310 user := s.oauth.GetUser(r)
311 tx, err := s.db.BeginTx(r.Context(), nil)
312 if err != nil {
313 log.Println("failed to start transaction", err)
314 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
315 return
316 }
317
318 client, err := s.oauth.AuthorizedClient(r)
319 if err != nil {
320 log.Println("failed to get authorized client", err)
321 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
322 return
323 }
324
325 // yeah... lexgen dose not support syntax.ATURI in the record for some reason,
326 // nor does it support exact size arrays
327 var pinnedRepoStrings []string
328 for _, r := range profile.PinnedRepos {
329 pinnedRepoStrings = append(pinnedRepoStrings, r.String())
330 }
331
332 var vanityStats []string
333 for _, v := range profile.Stats {
334 vanityStats = append(vanityStats, string(v.Kind))
335 }
336
337 ex, _ := client.RepoGetRecord(r.Context(), "", tangled.ActorProfileNSID, user.Did, "self")
338 var cid *string
339 if ex != nil {
340 cid = ex.Cid
341 }
342
343 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
344 Collection: tangled.ActorProfileNSID,
345 Repo: user.Did,
346 Rkey: "self",
347 Record: &lexutil.LexiconTypeDecoder{
348 Val: &tangled.ActorProfile{
349 Bluesky: profile.IncludeBluesky,
350 Description: &profile.Description,
351 Links: profile.Links[:],
352 Location: &profile.Location,
353 PinnedRepositories: pinnedRepoStrings,
354 Stats: vanityStats[:],
355 }},
356 SwapRecord: cid,
357 })
358 if err != nil {
359 log.Println("failed to update profile", err)
360 s.pages.Notice(w, "update-profile", "Failed to update PDS, try again later.")
361 return
362 }
363
364 err = db.UpsertProfile(tx, profile)
365 if err != nil {
366 log.Println("failed to update profile", err)
367 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
368 return
369 }
370
371 s.notifier.UpdateProfile(r.Context(), profile)
372
373 s.pages.HxRedirect(w, "/"+user.Did)
374}
375
376func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
377 user := s.oauth.GetUser(r)
378
379 profile, err := db.GetProfile(s.db, user.Did)
380 if err != nil {
381 log.Printf("getting profile data for %s: %s", user.Did, err)
382 }
383
384 s.pages.EditBioFragment(w, pages.EditBioParams{
385 LoggedInUser: user,
386 Profile: profile,
387 })
388}
389
390func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
391 user := s.oauth.GetUser(r)
392
393 profile, err := db.GetProfile(s.db, user.Did)
394 if err != nil {
395 log.Printf("getting profile data for %s: %s", user.Did, err)
396 }
397
398 repos, err := db.GetAllReposByDid(s.db, user.Did)
399 if err != nil {
400 log.Printf("getting repos for %s: %s", user.Did, err)
401 }
402
403 collaboratingRepos, err := db.CollaboratingIn(s.db, user.Did)
404 if err != nil {
405 log.Printf("getting collaborating repos for %s: %s", user.Did, err)
406 }
407
408 allRepos := []pages.PinnedRepo{}
409
410 for _, r := range repos {
411 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
412 allRepos = append(allRepos, pages.PinnedRepo{
413 IsPinned: isPinned,
414 Repo: r,
415 })
416 }
417 for _, r := range collaboratingRepos {
418 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
419 allRepos = append(allRepos, pages.PinnedRepo{
420 IsPinned: isPinned,
421 Repo: r,
422 })
423 }
424
425 var didsToResolve []string
426 for _, r := range allRepos {
427 didsToResolve = append(didsToResolve, r.Did)
428 }
429 resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
430 didHandleMap := make(map[string]string)
431 for _, identity := range resolvedIds {
432 if !identity.Handle.IsInvalidHandle() {
433 didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())
434 } else {
435 didHandleMap[identity.DID.String()] = identity.DID.String()
436 }
437 }
438
439 s.pages.EditPinsFragment(w, pages.EditPinsParams{
440 LoggedInUser: user,
441 Profile: profile,
442 AllRepos: allRepos,
443 DidHandleMap: didHandleMap,
444 })
445}