lewis.moe
Monorepo for Tangled
1package state
2
3import (
4 "context"
5 "fmt"
6 "log"
7 "net/http"
8 "slices"
9 "strings"
10 "time"
11
12 comatproto "github.com/bluesky-social/indigo/api/atproto"
13 "github.com/bluesky-social/indigo/atproto/identity"
14 "github.com/bluesky-social/indigo/atproto/syntax"
15 lexutil "github.com/bluesky-social/indigo/lex/util"
16 "github.com/go-chi/chi/v5"
17 "github.com/gorilla/feeds"
18 "tangled.org/core/api/tangled"
19 "tangled.org/core/appview/db"
20 "tangled.org/core/appview/models"
21 "tangled.org/core/appview/pages"
22 "tangled.org/core/orm"
23 "tangled.org/core/xrpc"
24)
25
26func (s *State) Profile(w http.ResponseWriter, r *http.Request) {
27 tabVal := r.URL.Query().Get("tab")
28 switch tabVal {
29 case "repos":
30 s.reposPage(w, r)
31 case "followers":
32 s.followersPage(w, r)
33 case "following":
34 s.followingPage(w, r)
35 case "starred":
36 s.starredPage(w, r)
37 case "strings":
38 s.stringsPage(w, r)
39 default:
40 s.profileOverview(w, r)
41 }
42}
43
44func (s *State) profile(r *http.Request) (*pages.ProfileCard, error) {
45 didOrHandle := chi.URLParam(r, "user")
46 if didOrHandle == "" {
47 return nil, fmt.Errorf("empty DID or handle")
48 }
49
50 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
51 if !ok {
52 return nil, fmt.Errorf("failed to resolve ID")
53 }
54 did := ident.DID.String()
55
56 profile, err := db.GetProfile(s.db, did)
57 if err != nil {
58 return nil, fmt.Errorf("failed to get profile: %w", err)
59 }
60
61 hasProfile := profile != nil
62 if !hasProfile {
63 profile = &models.Profile{Did: did}
64 }
65
66 repoCount, err := db.CountRepos(s.db, orm.FilterEq("did", did))
67 if err != nil {
68 return nil, fmt.Errorf("failed to get repo count: %w", err)
69 }
70
71 stringCount, err := db.CountStrings(s.db, orm.FilterEq("did", did))
72 if err != nil {
73 return nil, fmt.Errorf("failed to get string count: %w", err)
74 }
75
76 starredCount, err := db.CountStars(s.db, orm.FilterEq("did", did))
77 if err != nil {
78 return nil, fmt.Errorf("failed to get starred repo count: %w", err)
79 }
80
81 followStats, err := db.GetFollowerFollowingCount(s.db, did)
82 if err != nil {
83 return nil, fmt.Errorf("failed to get follower stats: %w", err)
84 }
85
86 loggedInUser := s.oauth.GetMultiAccountUser(r)
87 followStatus := models.IsNotFollowing
88 if loggedInUser != nil {
89 followStatus = db.GetFollowStatus(s.db, loggedInUser.Active.Did, did)
90 }
91
92 now := time.Now()
93 startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
94 punchcard, err := db.MakePunchcard(
95 s.db,
96 orm.FilterEq("did", did),
97 orm.FilterGte("date", startOfYear.Format(time.DateOnly)),
98 orm.FilterLte("date", now.Format(time.DateOnly)),
99 )
100 if err != nil {
101 return nil, fmt.Errorf("failed to get punchcard for %s: %w", did, err)
102 }
103
104 return &pages.ProfileCard{
105 UserDid: did,
106 HasProfile: hasProfile,
107 Profile: profile,
108 FollowStatus: followStatus,
109 Stats: pages.ProfileStats{
110 RepoCount: repoCount,
111 StringCount: stringCount,
112 StarredCount: starredCount,
113 FollowersCount: followStats.Followers,
114 FollowingCount: followStats.Following,
115 },
116 Punchcard: punchcard,
117 }, nil
118}
119
120func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {
121 l := s.logger.With("handler", "profileHomePage")
122
123 profile, err := s.profile(r)
124 if err != nil {
125 l.Error("failed to build profile card", "err", err)
126 s.pages.Error500(w)
127 return
128 }
129 l = l.With("profileDid", profile.UserDid)
130
131 repos, err := db.GetRepos(
132 s.db,
133 0,
134 orm.FilterEq("did", profile.UserDid),
135 )
136 if err != nil {
137 l.Error("failed to fetch repos", "err", err)
138 }
139
140 // filter out ones that are pinned
141 pinnedRepos := []models.Repo{}
142 for i, r := range repos {
143 // if this is a pinned repo, add it
144 if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
145 pinnedRepos = append(pinnedRepos, r)
146 }
147
148 // if there are no saved pins, add the first 4 repos
149 if profile.Profile.IsPinnedReposEmpty() && i < 4 {
150 pinnedRepos = append(pinnedRepos, r)
151 }
152 }
153
154 collaboratingRepos, err := db.CollaboratingIn(s.db, profile.UserDid)
155 if err != nil {
156 l.Error("failed to fetch collaborating repos", "err", err)
157 }
158
159 pinnedCollaboratingRepos := []models.Repo{}
160 for _, r := range collaboratingRepos {
161 // if this is a pinned repo, add it
162 if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
163 pinnedCollaboratingRepos = append(pinnedCollaboratingRepos, r)
164 }
165 }
166
167 timeline, err := db.MakeProfileTimeline(s.db, profile.UserDid)
168 if err != nil {
169 l.Error("failed to create timeline", "err", err)
170 }
171
172 s.pages.ProfileOverview(w, pages.ProfileOverviewParams{
173 LoggedInUser: s.oauth.GetMultiAccountUser(r),
174 Card: profile,
175 Repos: pinnedRepos,
176 CollaboratingRepos: pinnedCollaboratingRepos,
177 ProfileTimeline: timeline,
178 })
179}
180
181func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
182 l := s.logger.With("handler", "reposPage")
183
184 profile, err := s.profile(r)
185 if err != nil {
186 l.Error("failed to build profile card", "err", err)
187 s.pages.Error500(w)
188 return
189 }
190 l = l.With("profileDid", profile.UserDid)
191
192 repos, err := db.GetRepos(
193 s.db,
194 0,
195 orm.FilterEq("did", profile.UserDid),
196 )
197 if err != nil {
198 l.Error("failed to get repos", "err", err)
199 s.pages.Error500(w)
200 return
201 }
202
203 err = s.pages.ProfileRepos(w, pages.ProfileReposParams{
204 LoggedInUser: s.oauth.GetMultiAccountUser(r),
205 Repos: repos,
206 Card: profile,
207 })
208}
209
210func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {
211 l := s.logger.With("handler", "starredPage")
212
213 profile, err := s.profile(r)
214 if err != nil {
215 l.Error("failed to build profile card", "err", err)
216 s.pages.Error500(w)
217 return
218 }
219 l = l.With("profileDid", profile.UserDid)
220
221 stars, err := db.GetRepoStars(s.db, 0, orm.FilterEq("did", profile.UserDid))
222 if err != nil {
223 l.Error("failed to get stars", "err", err)
224 s.pages.Error500(w)
225 return
226 }
227 var repos []models.Repo
228 for _, s := range stars {
229 repos = append(repos, *s.Repo)
230 }
231
232 err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{
233 LoggedInUser: s.oauth.GetMultiAccountUser(r),
234 Repos: repos,
235 Card: profile,
236 })
237}
238
239func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {
240 l := s.logger.With("handler", "stringsPage")
241
242 profile, err := s.profile(r)
243 if err != nil {
244 l.Error("failed to build profile card", "err", err)
245 s.pages.Error500(w)
246 return
247 }
248 l = l.With("profileDid", profile.UserDid)
249
250 strings, err := db.GetStrings(s.db, 0, orm.FilterEq("did", profile.UserDid))
251 if err != nil {
252 l.Error("failed to get strings", "err", err)
253 s.pages.Error500(w)
254 return
255 }
256
257 err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{
258 LoggedInUser: s.oauth.GetMultiAccountUser(r),
259 Strings: strings,
260 Card: profile,
261 })
262}
263
264type FollowsPageParams struct {
265 Follows []pages.FollowCard
266 Card *pages.ProfileCard
267}
268
269func (s *State) followPage(
270 r *http.Request,
271 fetchFollows func(db.Execer, string) ([]models.Follow, error),
272 extractDid func(models.Follow) string,
273) (*FollowsPageParams, error) {
274 l := s.logger.With("handler", "reposPage")
275
276 profile, err := s.profile(r)
277 if err != nil {
278 return nil, err
279 }
280 l = l.With("profileDid", profile.UserDid)
281
282 loggedInUser := s.oauth.GetMultiAccountUser(r)
283 params := FollowsPageParams{
284 Card: profile,
285 }
286
287 follows, err := fetchFollows(s.db, profile.UserDid)
288 if err != nil {
289 l.Error("failed to fetch follows", "err", err)
290 return ¶ms, err
291 }
292
293 if len(follows) == 0 {
294 return ¶ms, nil
295 }
296
297 followDids := make([]string, 0, len(follows))
298 for _, follow := range follows {
299 followDids = append(followDids, extractDid(follow))
300 }
301
302 profiles, err := db.GetProfiles(s.db, orm.FilterIn("did", followDids))
303 if err != nil {
304 l.Error("failed to get profiles", "followDids", followDids, "err", err)
305 return ¶ms, err
306 }
307
308 followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)
309 if err != nil {
310 log.Printf("getting follow counts for %s: %s", followDids, err)
311 }
312
313 loggedInUserFollowing := make(map[string]struct{})
314 if loggedInUser != nil {
315 following, err := db.GetFollowing(s.db, loggedInUser.Active.Did)
316 if err != nil {
317 l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Active.Did)
318 return ¶ms, err
319 }
320 loggedInUserFollowing = make(map[string]struct{}, len(following))
321 for _, follow := range following {
322 loggedInUserFollowing[follow.SubjectDid] = struct{}{}
323 }
324 }
325
326 followCards := make([]pages.FollowCard, len(follows))
327 for i, did := range followDids {
328 followStats := followStatsMap[did]
329 followStatus := models.IsNotFollowing
330 if _, exists := loggedInUserFollowing[did]; exists {
331 followStatus = models.IsFollowing
332 } else if loggedInUser != nil && loggedInUser.Active.Did == did {
333 followStatus = models.IsSelf
334 }
335
336 var profile *models.Profile
337 if p, exists := profiles[did]; exists {
338 profile = p
339 } else {
340 profile = &models.Profile{}
341 profile.Did = did
342 }
343 followCards[i] = pages.FollowCard{
344 LoggedInUser: loggedInUser,
345 UserDid: did,
346 FollowStatus: followStatus,
347 FollowersCount: followStats.Followers,
348 FollowingCount: followStats.Following,
349 Profile: profile,
350 }
351 }
352
353 params.Follows = followCards
354
355 return ¶ms, nil
356}
357
358func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {
359 followPage, err := s.followPage(r, db.GetFollowers, func(f models.Follow) string { return f.UserDid })
360 if err != nil {
361 s.pages.Notice(w, "all-followers", "Failed to load followers")
362 return
363 }
364
365 s.pages.ProfileFollowers(w, pages.ProfileFollowersParams{
366 LoggedInUser: s.oauth.GetMultiAccountUser(r),
367 Followers: followPage.Follows,
368 Card: followPage.Card,
369 })
370}
371
372func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {
373 followPage, err := s.followPage(r, db.GetFollowing, func(f models.Follow) string { return f.SubjectDid })
374 if err != nil {
375 s.pages.Notice(w, "all-following", "Failed to load following")
376 return
377 }
378
379 s.pages.ProfileFollowing(w, pages.ProfileFollowingParams{
380 LoggedInUser: s.oauth.GetMultiAccountUser(r),
381 Following: followPage.Follows,
382 Card: followPage.Card,
383 })
384}
385
386func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) {
387 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
388 if !ok {
389 s.pages.Error404(w)
390 return
391 }
392
393 feed, err := s.getProfileFeed(r.Context(), &ident)
394 if err != nil {
395 s.pages.Error500(w)
396 return
397 }
398
399 if feed == nil {
400 return
401 }
402
403 atom, err := feed.ToAtom()
404 if err != nil {
405 s.pages.Error500(w)
406 return
407 }
408
409 w.Header().Set("content-type", "application/atom+xml")
410 w.Write([]byte(atom))
411}
412
413func (s *State) getProfileFeed(ctx context.Context, id *identity.Identity) (*feeds.Feed, error) {
414 timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())
415 if err != nil {
416 return nil, err
417 }
418
419 author := &feeds.Author{
420 Name: fmt.Sprintf("@%s", id.Handle),
421 }
422
423 feed := feeds.Feed{
424 Title: fmt.Sprintf("%s's timeline", author.Name),
425 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.BaseUrl(), id.Handle), Type: "text/html", Rel: "alternate"},
426 Items: make([]*feeds.Item, 0),
427 Updated: time.UnixMilli(0),
428 Author: author,
429 }
430
431 for _, byMonth := range timeline.ByMonth {
432 if err := s.addPullRequestItems(ctx, &feed, byMonth.PullEvents.Items, author); err != nil {
433 return nil, err
434 }
435 if err := s.addIssueItems(ctx, &feed, byMonth.IssueEvents.Items, author); err != nil {
436 return nil, err
437 }
438 if err := s.addRepoItems(ctx, &feed, byMonth.RepoEvents, author); err != nil {
439 return nil, err
440 }
441 }
442
443 slices.SortFunc(feed.Items, func(a *feeds.Item, b *feeds.Item) int {
444 return int(b.Created.UnixMilli()) - int(a.Created.UnixMilli())
445 })
446
447 if len(feed.Items) > 0 {
448 feed.Updated = feed.Items[0].Created
449 }
450
451 return &feed, nil
452}
453
454func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*models.Pull, author *feeds.Author) error {
455 for _, pull := range pulls {
456 owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did)
457 if err != nil {
458 return err
459 }
460
461 // Add pull request creation item
462 feed.Items = append(feed.Items, s.createPullRequestItem(pull, owner, author))
463 }
464 return nil
465}
466
467func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*models.Issue, author *feeds.Author) error {
468 for _, issue := range issues {
469 owner, err := s.idResolver.ResolveIdent(ctx, issue.Repo.Did)
470 if err != nil {
471 return err
472 }
473
474 feed.Items = append(feed.Items, s.createIssueItem(issue, owner, author))
475 }
476 return nil
477}
478
479func (s *State) addRepoItems(ctx context.Context, feed *feeds.Feed, repos []models.RepoEvent, author *feeds.Author) error {
480 for _, repo := range repos {
481 item, err := s.createRepoItem(ctx, repo, author)
482 if err != nil {
483 return err
484 }
485 feed.Items = append(feed.Items, item)
486 }
487 return nil
488}
489
490func (s *State) createPullRequestItem(pull *models.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item {
491 return &feeds.Item{
492 Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name),
493 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.BaseUrl(), owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"},
494 Created: pull.Created,
495 Author: author,
496 }
497}
498
499func (s *State) createIssueItem(issue *models.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item {
500 return &feeds.Item{
501 Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Repo.Name),
502 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.BaseUrl(), owner.Handle, issue.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"},
503 Created: issue.Created,
504 Author: author,
505 }
506}
507
508func (s *State) createRepoItem(ctx context.Context, repo models.RepoEvent, author *feeds.Author) (*feeds.Item, error) {
509 var title string
510 if repo.Source != nil {
511 sourceOwner, err := s.idResolver.ResolveIdent(ctx, repo.Source.Did)
512 if err != nil {
513 return nil, err
514 }
515 title = fmt.Sprintf("%s forked repository @%s/%s to '%s'", author.Name, sourceOwner.Handle, repo.Source.Name, repo.Repo.Name)
516 } else {
517 title = fmt.Sprintf("%s created repository '%s'", author.Name, repo.Repo.Name)
518 }
519
520 return &feeds.Item{
521 Title: title,
522 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s", s.config.Core.BaseUrl(), author.Name[1:], repo.Repo.Name), Type: "text/html", Rel: "alternate"}, // Remove @ prefix
523 Created: repo.Repo.Created,
524 Author: author,
525 }, nil
526}
527
528func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {
529 user := s.oauth.GetMultiAccountUser(r)
530
531 err := r.ParseForm()
532 if err != nil {
533 log.Println("invalid profile update form", err)
534 s.pages.Notice(w, "update-profile", "Invalid form.")
535 return
536 }
537
538 profile, err := db.GetProfile(s.db, user.Active.Did)
539 if err != nil {
540 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
541 }
542 if profile == nil {
543 profile = &models.Profile{Did: user.Active.Did}
544 }
545
546 profile.Description = r.FormValue("description")
547 profile.IncludeBluesky = r.FormValue("includeBluesky") == "on"
548 profile.Location = r.FormValue("location")
549 profile.Pronouns = r.FormValue("pronouns")
550
551 var links [5]string
552 for i := range 5 {
553 iLink := r.FormValue(fmt.Sprintf("link%d", i))
554 links[i] = iLink
555 }
556 profile.Links = links
557
558 // Parse stats (exactly 2)
559 stat0 := r.FormValue("stat0")
560 stat1 := r.FormValue("stat1")
561
562 if stat0 != "" {
563 profile.Stats[0].Kind = models.VanityStatKind(stat0)
564 }
565
566 if stat1 != "" {
567 profile.Stats[1].Kind = models.VanityStatKind(stat1)
568 }
569
570 if err := db.ValidateProfile(s.db, profile); err != nil {
571 log.Println("invalid profile", err)
572 s.pages.Notice(w, "update-profile", err.Error())
573 return
574 }
575
576 s.updateProfile(profile, w, r)
577}
578
579func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) {
580 user := s.oauth.GetMultiAccountUser(r)
581
582 err := r.ParseForm()
583 if err != nil {
584 log.Println("invalid profile update form", err)
585 s.pages.Notice(w, "update-profile", "Invalid form.")
586 return
587 }
588
589 profile, err := db.GetProfile(s.db, user.Active.Did)
590 if err != nil {
591 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
592 }
593 if profile == nil {
594 profile = &models.Profile{Did: user.Active.Did}
595 }
596
597 i := 0
598 var pinnedRepos [6]syntax.ATURI
599 for key, values := range r.Form {
600 if i >= 6 {
601 log.Println("invalid pin update form", err)
602 s.pages.Notice(w, "update-profile", "Only 6 repositories can be pinned at a time.")
603 return
604 }
605 if strings.HasPrefix(key, "pinnedRepo") && len(values) > 0 && values[0] != "" && i < 6 {
606 aturi, err := syntax.ParseATURI(values[0])
607 if err != nil {
608 log.Println("invalid profile update form", err)
609 s.pages.Notice(w, "update-profile", "Invalid form.")
610 return
611 }
612 pinnedRepos[i] = aturi
613 i++
614 }
615 }
616 profile.PinnedRepos = pinnedRepos
617
618 s.updateProfile(profile, w, r)
619}
620
621func (s *State) updateProfile(profile *models.Profile, w http.ResponseWriter, r *http.Request) {
622 user := s.oauth.GetMultiAccountUser(r)
623 tx, err := s.db.BeginTx(r.Context(), nil)
624 if err != nil {
625 log.Println("failed to start transaction", err)
626 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
627 return
628 }
629
630 client, err := s.oauth.AuthorizedClient(r)
631 if err != nil {
632 log.Println("failed to get authorized client", err)
633 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
634 return
635 }
636
637 // yeah... lexgen dose not support syntax.ATURI in the record for some reason,
638 // nor does it support exact size arrays
639 var pinnedRepoStrings []string
640 for _, r := range profile.PinnedRepos {
641 pinnedRepoStrings = append(pinnedRepoStrings, r.String())
642 }
643
644 var vanityStats []string
645 for _, v := range profile.Stats {
646 vanityStats = append(vanityStats, string(v.Kind))
647 }
648
649 ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Active.Did, "self")
650 var cid *string
651 if ex != nil {
652 cid = ex.Cid
653 }
654
655 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
656 Collection: tangled.ActorProfileNSID,
657 Repo: user.Active.Did,
658 Rkey: "self",
659 Record: &lexutil.LexiconTypeDecoder{
660 Val: &tangled.ActorProfile{
661 Bluesky: profile.IncludeBluesky,
662 Description: &profile.Description,
663 Links: profile.Links[:],
664 Location: &profile.Location,
665 PinnedRepositories: pinnedRepoStrings,
666 Stats: vanityStats[:],
667 Pronouns: &profile.Pronouns,
668 }},
669 SwapRecord: cid,
670 })
671 if err != nil {
672 log.Println("failed to update profile", err)
673 s.pages.Notice(w, "update-profile", "Failed to update PDS, try again later.")
674 return
675 }
676
677 err = db.UpsertProfile(tx, profile)
678 if err != nil {
679 log.Println("failed to update profile", err)
680 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
681 return
682 }
683
684 s.notifier.UpdateProfile(r.Context(), profile)
685
686 s.pages.HxRedirect(w, "/"+user.Active.Did)
687}
688
689func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
690 user := s.oauth.GetMultiAccountUser(r)
691
692 profile, err := db.GetProfile(s.db, user.Active.Did)
693 if err != nil {
694 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
695 }
696 if profile == nil {
697 profile = &models.Profile{Did: user.Active.Did}
698 }
699
700 s.pages.EditBioFragment(w, pages.EditBioParams{
701 LoggedInUser: user,
702 Profile: profile,
703 })
704}
705
706func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
707 user := s.oauth.GetMultiAccountUser(r)
708
709 profile, err := db.GetProfile(s.db, user.Active.Did)
710 if err != nil {
711 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
712 }
713 if profile == nil {
714 profile = &models.Profile{Did: user.Active.Did}
715 }
716
717 repos, err := db.GetRepos(s.db, 0, orm.FilterEq("did", user.Active.Did))
718 if err != nil {
719 log.Printf("getting repos for %s: %s", user.Active.Did, err)
720 }
721
722 collaboratingRepos, err := db.CollaboratingIn(s.db, user.Active.Did)
723 if err != nil {
724 log.Printf("getting collaborating repos for %s: %s", user.Active.Did, err)
725 }
726
727 allRepos := []pages.PinnedRepo{}
728
729 for _, r := range repos {
730 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
731 allRepos = append(allRepos, pages.PinnedRepo{
732 IsPinned: isPinned,
733 Repo: r,
734 })
735 }
736 for _, r := range collaboratingRepos {
737 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
738 allRepos = append(allRepos, pages.PinnedRepo{
739 IsPinned: isPinned,
740 Repo: r,
741 })
742 }
743
744 s.pages.EditPinsFragment(w, pages.EditPinsParams{
745 LoggedInUser: user,
746 Profile: profile,
747 AllRepos: allRepos,
748 })
749}
750
751func (s *State) UploadProfileAvatar(w http.ResponseWriter, r *http.Request) {
752 l := s.logger.With("handler", "UploadProfileAvatar")
753 user := s.oauth.GetUser(r)
754 l = l.With("did", user.Did)
755
756 // Parse multipart form (10MB max)
757 if err := r.ParseMultipartForm(10 << 20); err != nil {
758 l.Error("failed to parse form", "err", err)
759 s.pages.Notice(w, "avatar-error", "Failed to parse form")
760 return
761 }
762
763 file, header, err := r.FormFile("avatar")
764 if err != nil {
765 l.Error("failed to read avatar file", "err", err)
766 s.pages.Notice(w, "avatar-error", "Failed to read avatar file")
767 return
768 }
769 defer file.Close()
770
771 if header.Size > 1000000 {
772 l.Warn("avatar file too large", "size", header.Size)
773 s.pages.Notice(w, "avatar-error", "Avatar file too large (max 1MB)")
774 return
775 }
776
777 contentType := header.Header.Get("Content-Type")
778 if contentType != "image/png" && contentType != "image/jpeg" {
779 l.Warn("invalid image type", "contentType", contentType)
780 s.pages.Notice(w, "avatar-error", "Invalid image type (only PNG and JPEG allowed)")
781 return
782 }
783
784 client, err := s.oauth.AuthorizedClient(r)
785 if err != nil {
786 l.Error("failed to get PDS client", "err", err)
787 s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS")
788 return
789 }
790
791 uploadBlobResp, err := xrpc.RepoUploadBlob(r.Context(), client, file, header.Header.Get("Content-Type"))
792 if err != nil {
793 l.Error("failed to upload avatar blob", "err", err)
794 s.pages.Notice(w, "avatar-error", "Failed to upload avatar to your PDS")
795 return
796 }
797
798 l.Info("uploaded avatar blob", "cid", uploadBlobResp.Blob.Ref.String())
799
800 // get current profile record from PDS to get its CID for swap
801 getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
802 if err != nil {
803 l.Error("failed to get current profile record", "err", err)
804 s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
805 return
806 }
807
808 var profileRecord *tangled.ActorProfile
809 if getRecordResp.Value != nil {
810 if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok {
811 profileRecord = val
812 } else {
813 l.Warn("profile record type assertion failed, creating new record")
814 profileRecord = &tangled.ActorProfile{}
815 }
816 } else {
817 l.Warn("no existing profile record, creating new record")
818 profileRecord = &tangled.ActorProfile{}
819 }
820
821 profileRecord.Avatar = uploadBlobResp.Blob
822
823 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
824 Collection: tangled.ActorProfileNSID,
825 Repo: user.Did,
826 Rkey: "self",
827 Record: &lexutil.LexiconTypeDecoder{Val: profileRecord},
828 SwapRecord: getRecordResp.Cid,
829 })
830
831 if err != nil {
832 l.Error("failed to update profile record", "err", err)
833 s.pages.Notice(w, "avatar-error", "Failed to update profile on your PDS")
834 return
835 }
836
837 l.Info("successfully updated profile with avatar")
838
839 profile, err := db.GetProfile(s.db, user.Did)
840 if err != nil {
841 l.Warn("getting profile data from DB", "err", err)
842 }
843 if profile == nil {
844 profile = &models.Profile{Did: user.Did}
845 }
846 profile.Avatar = uploadBlobResp.Blob.Ref.String()
847
848 tx, err := s.db.BeginTx(r.Context(), nil)
849 if err != nil {
850 l.Error("failed to start transaction", "err", err)
851 s.pages.HxRefresh(w)
852 w.WriteHeader(http.StatusOK)
853 return
854 }
855
856 err = db.UpsertProfile(tx, profile)
857 if err != nil {
858 l.Error("failed to update profile in DB", "err", err)
859 s.pages.HxRefresh(w)
860 w.WriteHeader(http.StatusOK)
861 return
862 }
863
864 s.pages.HxRedirect(w, r.Header.Get("Referer"))
865}
866
867func (s *State) RemoveProfileAvatar(w http.ResponseWriter, r *http.Request) {
868 l := s.logger.With("handler", "RemoveProfileAvatar")
869 user := s.oauth.GetUser(r)
870 l = l.With("did", user.Did)
871
872 client, err := s.oauth.AuthorizedClient(r)
873 if err != nil {
874 l.Error("failed to get PDS client", "err", err)
875 s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS")
876 return
877 }
878
879 getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
880 if err != nil {
881 l.Error("failed to get current profile record", "err", err)
882 s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
883 return
884 }
885
886 var profileRecord *tangled.ActorProfile
887 if getRecordResp.Value != nil {
888 if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok {
889 profileRecord = val
890 } else {
891 l.Warn("profile record type assertion failed")
892 profileRecord = &tangled.ActorProfile{}
893 }
894 } else {
895 l.Warn("no existing profile record")
896 profileRecord = &tangled.ActorProfile{}
897 }
898
899 profileRecord.Avatar = nil
900
901 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
902 Collection: tangled.ActorProfileNSID,
903 Repo: user.Did,
904 Rkey: "self",
905 Record: &lexutil.LexiconTypeDecoder{Val: profileRecord},
906 SwapRecord: getRecordResp.Cid,
907 })
908
909 if err != nil {
910 l.Error("failed to update profile record", "err", err)
911 s.pages.Notice(w, "avatar-error", "Failed to remove avatar from your PDS")
912 return
913 }
914
915 l.Info("successfully removed avatar from PDS")
916
917 profile, err := db.GetProfile(s.db, user.Did)
918 if err != nil {
919 l.Warn("getting profile data from DB", "err", err)
920 }
921 if profile == nil {
922 profile = &models.Profile{Did: user.Did}
923 }
924 profile.Avatar = ""
925
926 tx, err := s.db.BeginTx(r.Context(), nil)
927 if err != nil {
928 l.Error("failed to start transaction", "err", err)
929 s.pages.HxRefresh(w)
930 w.WriteHeader(http.StatusOK)
931 return
932 }
933
934 err = db.UpsertProfile(tx, profile)
935 if err != nil {
936 l.Error("failed to update profile in DB", "err", err)
937 s.pages.HxRefresh(w)
938 w.WriteHeader(http.StatusOK)
939 return
940 }
941
942 s.pages.HxRedirect(w, r.Header.Get("Referer"))
943}