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