forked from
tangled.org/core
Monorepo for Tangled
1package state
2
3import (
4 "context"
5 "fmt"
6 "net/http"
7 "slices"
8 "strings"
9 "time"
10
11 comatproto "github.com/bluesky-social/indigo/api/atproto"
12 "github.com/bluesky-social/indigo/atproto/identity"
13 "github.com/bluesky-social/indigo/atproto/syntax"
14 lexutil "github.com/bluesky-social/indigo/lex/util"
15 "github.com/go-chi/chi/v5"
16 "github.com/gorilla/feeds"
17 "tangled.org/core/api/tangled"
18 "tangled.org/core/appview/cache"
19 "tangled.org/core/appview/db"
20 "tangled.org/core/appview/middleware"
21 "tangled.org/core/appview/models"
22 "tangled.org/core/appview/pages"
23 "tangled.org/core/appview/pagination"
24 "tangled.org/core/appview/searchquery"
25 "tangled.org/core/orm"
26 "tangled.org/core/xrpc"
27)
28
29func (s *State) Profile(w http.ResponseWriter, r *http.Request) {
30 tabVal := r.URL.Query().Get("tab")
31 switch tabVal {
32 case "repos":
33 middleware.
34 Paginate(http.HandlerFunc(s.reposPage)).
35 ServeHTTP(w, r)
36 case "followers":
37 s.followersPage(w, r)
38 case "following":
39 s.followingPage(w, r)
40 case "starred":
41 middleware.
42 Paginate(http.HandlerFunc(s.starredPage)).
43 ServeHTTP(w, r)
44 case "strings":
45 s.stringsPage(w, r)
46 default:
47 s.profileOverview(w, r)
48 }
49}
50
51func (s *State) profile(r *http.Request) (*pages.ProfileCard, error) {
52 didOrHandle := chi.URLParam(r, "user")
53 if didOrHandle == "" {
54 return nil, fmt.Errorf("empty DID or handle")
55 }
56
57 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
58 if !ok {
59 return nil, fmt.Errorf("failed to resolve ID")
60 }
61 did := ident.DID.String()
62
63 profile, err := db.GetProfile(s.db, did)
64 if err != nil {
65 return nil, fmt.Errorf("failed to get profile: %w", err)
66 }
67
68 hasProfile := profile != nil
69 if !hasProfile {
70 profile = &models.Profile{Did: did}
71 }
72
73 repoCount, err := db.CountRepos(s.db, orm.FilterEq("did", did))
74 if err != nil {
75 return nil, fmt.Errorf("failed to get repo count: %w", err)
76 }
77
78 stringCount, err := db.CountStrings(s.db, orm.FilterEq("did", did))
79 if err != nil {
80 return nil, fmt.Errorf("failed to get string count: %w", err)
81 }
82
83 starredCount, err := db.CountStars(s.db, orm.FilterEq("did", did))
84 if err != nil {
85 return nil, fmt.Errorf("failed to get starred repo count: %w", err)
86 }
87
88 followStats, err := db.GetFollowerFollowingCount(s.db, did)
89 if err != nil {
90 return nil, fmt.Errorf("failed to get follower stats: %w", err)
91 }
92
93 loggedInUser := s.oauth.GetMultiAccountUser(r)
94 followStatus := models.IsNotFollowing
95 var loggedInDid string
96 if loggedInUser != nil {
97 followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
98 loggedInDid = loggedInUser.Did
99 }
100
101 showPunchcard := s.shouldShowPunchcard(did, loggedInDid)
102
103 var punchcard *models.Punchcard
104 if showPunchcard {
105 now := time.Now()
106 startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
107 punchcard, err = db.MakePunchcard(
108 s.db,
109 orm.FilterEq("did", did),
110 orm.FilterGte("date", startOfYear.Format(time.DateOnly)),
111 orm.FilterLte("date", now.Format(time.DateOnly)),
112 )
113 if err != nil {
114 return nil, fmt.Errorf("failed to get punchcard for %s: %w", did, err)
115 }
116 }
117
118 return &pages.ProfileCard{
119 UserDid: did,
120 HasProfile: hasProfile,
121 Profile: profile,
122 FollowStatus: followStatus,
123 Stats: pages.ProfileStats{
124 RepoCount: repoCount,
125 StringCount: stringCount,
126 StarredCount: starredCount,
127 FollowersCount: followStats.Followers,
128 FollowingCount: followStats.Following,
129 },
130 Punchcard: punchcard,
131 }, nil
132}
133
134func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {
135 l := s.logger.With("handler", "profileHomePage")
136
137 profile, err := s.profile(r)
138 if err != nil {
139 l.Error("failed to build profile card", "err", err)
140 s.pages.Error500(w)
141 return
142 }
143 l = l.With("profileDid", profile.UserDid)
144
145 repos, err := db.GetRepos(
146 s.db,
147 orm.FilterEq("did", profile.UserDid),
148 )
149 if err != nil {
150 l.Error("failed to fetch repos", "err", err)
151 }
152
153 // filter out ones that are pinned
154 pinnedRepos := []models.Repo{}
155 for i, r := range repos {
156 if profile.Profile.MatchesPinnedRepo(r) {
157 pinnedRepos = append(pinnedRepos, r)
158 } else if profile.Profile.IsPinnedReposEmpty() && i < 4 {
159 pinnedRepos = append(pinnedRepos, r)
160 }
161 }
162
163 collaboratingRepos, err := db.CollaboratingIn(s.db, profile.UserDid)
164 if err != nil {
165 l.Error("failed to fetch collaborating repos", "err", err)
166 }
167
168 pinnedCollaboratingRepos := []models.Repo{}
169 for _, r := range collaboratingRepos {
170 if profile.Profile.MatchesPinnedRepo(r) {
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 params := r.URL.Query()
232 page := pagination.FromContext(r.Context())
233
234 query := searchquery.Parse(params.Get("q"))
235
236 var language string
237 if lang := query.Get("language"); lang != nil {
238 language = *lang
239 }
240
241 tf := searchquery.ExtractTextFilters(query)
242
243 searchOpts := models.RepoSearchOptions{
244 Keywords: tf.Keywords,
245 Phrases: tf.Phrases,
246 NegatedKeywords: tf.NegatedKeywords,
247 NegatedPhrases: tf.NegatedPhrases,
248 Did: profile.UserDid,
249 Language: language,
250 Page: page,
251 }
252
253 var repos []models.Repo
254 var totalRepos int64
255
256 if searchOpts.HasSearchFilters() {
257 res, err := s.indexer.Repos.Search(r.Context(), searchOpts)
258 if err != nil {
259 l.Error("failed to search repos", "err", err)
260 s.pages.Error500(w)
261 return
262 }
263
264 if len(res.Hits) > 0 {
265 repos, err = db.GetRepos(s.db, orm.FilterIn("id", res.Hits))
266 if err != nil {
267 l.Error("failed to get repos by IDs", "err", err)
268 s.pages.Error500(w)
269 return
270 }
271
272 // sort repos to match search result order (by relevance)
273 repoMap := make(map[int64]models.Repo, len(repos))
274 for _, repo := range repos {
275 repoMap[repo.Id] = repo
276 }
277 repos = make([]models.Repo, 0, len(res.Hits))
278 for _, id := range res.Hits {
279 if repo, ok := repoMap[id]; ok {
280 repos = append(repos, repo)
281 }
282 }
283 }
284 totalRepos = int64(res.Total)
285 } else {
286 repos, err = db.GetReposPaginated(
287 s.db,
288 page,
289 orm.FilterEq("did", profile.UserDid),
290 )
291 if err != nil {
292 l.Error("failed to get repos", "err", err)
293 s.pages.Error500(w)
294 return
295 }
296
297 totalRepos, err = db.CountRepos(
298 s.db,
299 orm.FilterEq("did", profile.UserDid),
300 )
301 if err != nil {
302 l.Error("failed to count repos", "err", err)
303 s.pages.Error500(w)
304 return
305 }
306 }
307
308 err = s.pages.ProfileRepos(w, pages.ProfileReposParams{
309 LoggedInUser: s.oauth.GetMultiAccountUser(r),
310 Repos: repos,
311 Card: profile,
312 Page: page,
313 RepoCount: int(totalRepos),
314 FilterQuery: query.String(),
315 })
316 if err != nil {
317 l.Error("failed to render page", "err", err)
318 }
319}
320
321func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {
322 l := s.logger.With("handler", "starredPage")
323
324 page := pagination.FromContext(r.Context())
325 l = l.With("page", page)
326
327 profile, err := s.profile(r)
328 if err != nil {
329 l.Error("failed to build profile card", "err", err)
330 s.pages.Error500(w)
331 return
332 }
333 l = l.With("profileDid", profile.UserDid)
334
335 stars, err := db.GetRepoStars(s.db, page, orm.FilterEq("did", profile.UserDid))
336 if err != nil {
337 l.Error("failed to get stars", "err", err)
338 s.pages.Error500(w)
339 return
340 }
341 var repos []models.Repo
342 for _, s := range stars {
343 repos = append(repos, *s.Repo)
344 }
345
346 err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{
347 LoggedInUser: s.oauth.GetMultiAccountUser(r),
348 Repos: repos,
349 Total: int(profile.Stats.StarredCount),
350 Card: profile,
351 Page: page,
352 })
353 if err != nil {
354 l.Error("failed to render", "err", err)
355 }
356}
357
358func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {
359 l := s.logger.With("handler", "stringsPage")
360
361 profile, err := s.profile(r)
362 if err != nil {
363 l.Error("failed to build profile card", "err", err)
364 s.pages.Error500(w)
365 return
366 }
367 l = l.With("profileDid", profile.UserDid)
368
369 strings, err := db.GetStrings(s.db, 0, orm.FilterEq("did", profile.UserDid))
370 if err != nil {
371 l.Error("failed to get strings", "err", err)
372 s.pages.Error500(w)
373 return
374 }
375
376 err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{
377 LoggedInUser: s.oauth.GetMultiAccountUser(r),
378 Strings: strings,
379 Card: profile,
380 })
381}
382
383type FollowsPageParams struct {
384 Follows []pages.FollowCard
385 Card *pages.ProfileCard
386}
387
388func (s *State) followPage(
389 r *http.Request,
390 fetchFollows func(db.Execer, string) ([]models.Follow, error),
391 extractDid func(models.Follow) string,
392) (*FollowsPageParams, error) {
393 l := s.logger.With("handler", "reposPage")
394
395 profile, err := s.profile(r)
396 if err != nil {
397 return nil, err
398 }
399 l = l.With("profileDid", profile.UserDid)
400
401 loggedInUser := s.oauth.GetMultiAccountUser(r)
402 params := FollowsPageParams{
403 Card: profile,
404 }
405
406 follows, err := fetchFollows(s.db, profile.UserDid)
407 if err != nil {
408 l.Error("failed to fetch follows", "err", err)
409 return ¶ms, err
410 }
411
412 if len(follows) == 0 {
413 return ¶ms, nil
414 }
415
416 followDids := make([]string, 0, len(follows))
417 for _, follow := range follows {
418 followDids = append(followDids, extractDid(follow))
419 }
420
421 profiles, err := db.GetProfiles(s.db, orm.FilterIn("did", followDids))
422 if err != nil {
423 l.Error("failed to get profiles", "followDids", followDids, "err", err)
424 return ¶ms, err
425 }
426
427 followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)
428 if err != nil {
429 l.Error("getting follow counts", "followDids", followDids, "err", err)
430 }
431
432 loggedInUserFollowing := make(map[string]struct{})
433 if loggedInUser != nil {
434 following, err := db.GetFollowing(s.db, loggedInUser.Did)
435 if err != nil {
436 l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Did)
437 return ¶ms, err
438 }
439 loggedInUserFollowing = make(map[string]struct{}, len(following))
440 for _, follow := range following {
441 loggedInUserFollowing[follow.SubjectDid] = struct{}{}
442 }
443 }
444
445 followCards := make([]pages.FollowCard, len(follows))
446 for i, did := range followDids {
447 followStats := followStatsMap[did]
448 followStatus := models.IsNotFollowing
449 if _, exists := loggedInUserFollowing[did]; exists {
450 followStatus = models.IsFollowing
451 } else if loggedInUser != nil && loggedInUser.Did == did {
452 followStatus = models.IsSelf
453 }
454
455 var profile *models.Profile
456 if p, exists := profiles[did]; exists {
457 profile = p
458 } else {
459 profile = &models.Profile{}
460 profile.Did = did
461 }
462 followCards[i] = pages.FollowCard{
463 LoggedInUser: loggedInUser,
464 UserDid: did,
465 FollowStatus: followStatus,
466 FollowersCount: followStats.Followers,
467 FollowingCount: followStats.Following,
468 Profile: profile,
469 }
470 }
471
472 params.Follows = followCards
473
474 return ¶ms, nil
475}
476
477func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {
478 followPage, err := s.followPage(r, db.GetFollowers, func(f models.Follow) string { return f.UserDid })
479 if err != nil {
480 s.pages.Notice(w, "all-followers", "Failed to load followers")
481 return
482 }
483
484 s.pages.ProfileFollowers(w, pages.ProfileFollowersParams{
485 LoggedInUser: s.oauth.GetMultiAccountUser(r),
486 Followers: followPage.Follows,
487 Card: followPage.Card,
488 })
489}
490
491func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {
492 followPage, err := s.followPage(r, db.GetFollowing, func(f models.Follow) string { return f.SubjectDid })
493 if err != nil {
494 s.pages.Notice(w, "all-following", "Failed to load following")
495 return
496 }
497
498 s.pages.ProfileFollowing(w, pages.ProfileFollowingParams{
499 LoggedInUser: s.oauth.GetMultiAccountUser(r),
500 Following: followPage.Follows,
501 Card: followPage.Card,
502 })
503}
504
505func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) {
506 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
507 if !ok {
508 s.pages.Error404(w)
509 return
510 }
511
512 feed, err := s.getProfileFeed(r.Context(), &ident)
513 if err != nil {
514 s.pages.Error500(w)
515 return
516 }
517
518 if feed == nil {
519 return
520 }
521
522 atom, err := feed.ToAtom()
523 if err != nil {
524 s.pages.Error500(w)
525 return
526 }
527
528 w.Header().Set("content-type", "application/atom+xml")
529 w.Write([]byte(atom))
530}
531
532func (s *State) getProfileFeed(ctx context.Context, id *identity.Identity) (*feeds.Feed, error) {
533 timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())
534 if err != nil {
535 return nil, err
536 }
537
538 author := &feeds.Author{
539 Name: fmt.Sprintf("@%s", id.Handle),
540 }
541
542 feed := feeds.Feed{
543 Title: fmt.Sprintf("%s's timeline", author.Name),
544 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.BaseUrl(), id.Handle), Type: "text/html", Rel: "alternate"},
545 Items: make([]*feeds.Item, 0),
546 Updated: time.UnixMilli(0),
547 Author: author,
548 }
549
550 for _, byMonth := range timeline.ByMonth {
551 if err := s.addPullRequestItems(ctx, &feed, byMonth.PullEvents.Items, author); err != nil {
552 return nil, err
553 }
554 if err := s.addIssueItems(ctx, &feed, byMonth.IssueEvents.Items, author); err != nil {
555 return nil, err
556 }
557 if err := s.addRepoItems(ctx, &feed, byMonth.RepoEvents, author); err != nil {
558 return nil, err
559 }
560 }
561
562 slices.SortFunc(feed.Items, func(a *feeds.Item, b *feeds.Item) int {
563 return int(b.Created.UnixMilli()) - int(a.Created.UnixMilli())
564 })
565
566 if len(feed.Items) > 0 {
567 feed.Updated = feed.Items[0].Created
568 }
569
570 return &feed, nil
571}
572
573func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*models.Pull, author *feeds.Author) error {
574 for _, pull := range pulls {
575 owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did)
576 if err != nil {
577 return err
578 }
579
580 // Add pull request creation item
581 feed.Items = append(feed.Items, s.createPullRequestItem(pull, owner, author))
582 }
583 return nil
584}
585
586func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*models.Issue, author *feeds.Author) error {
587 for _, issue := range issues {
588 owner, err := s.idResolver.ResolveIdent(ctx, issue.Repo.Did)
589 if err != nil {
590 return err
591 }
592
593 feed.Items = append(feed.Items, s.createIssueItem(issue, owner, author))
594 }
595 return nil
596}
597
598func (s *State) addRepoItems(ctx context.Context, feed *feeds.Feed, repos []models.RepoEvent, author *feeds.Author) error {
599 for _, repo := range repos {
600 item, err := s.createRepoItem(ctx, repo, author)
601 if err != nil {
602 return err
603 }
604 feed.Items = append(feed.Items, item)
605 }
606 return nil
607}
608
609func (s *State) createPullRequestItem(pull *models.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item {
610 return &feeds.Item{
611 Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name),
612 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"},
613 Created: pull.Created,
614 Author: author,
615 }
616}
617
618func (s *State) createIssueItem(issue *models.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item {
619 return &feeds.Item{
620 Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Repo.Name),
621 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"},
622 Created: issue.Created,
623 Author: author,
624 }
625}
626
627func (s *State) createRepoItem(ctx context.Context, repo models.RepoEvent, author *feeds.Author) (*feeds.Item, error) {
628 var title string
629 if repo.Source != nil {
630 sourceOwner, err := s.idResolver.ResolveIdent(ctx, repo.Source.Did)
631 if err != nil {
632 return nil, err
633 }
634 title = fmt.Sprintf("%s forked repository @%s/%s to '%s'", author.Name, sourceOwner.Handle, repo.Source.Name, repo.Repo.Name)
635 } else {
636 title = fmt.Sprintf("%s created repository '%s'", author.Name, repo.Repo.Name)
637 }
638
639 return &feeds.Item{
640 Title: title,
641 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
642 Created: repo.Repo.Created,
643 Author: author,
644 }, nil
645}
646
647func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {
648 l := s.logger.With("handler", "UpdateProfileBio")
649 user := s.oauth.GetMultiAccountUser(r)
650
651 err := r.ParseForm()
652 if err != nil {
653 l.Error("invalid profile update form", "err", err)
654 s.pages.Notice(w, "update-profile", "Invalid form.")
655 return
656 }
657
658 profile, err := db.GetProfile(s.db, user.Did)
659 if err != nil {
660 l.Error("getting profile data", "did", user.Did, "err", err)
661 }
662 if profile == nil {
663 profile = &models.Profile{Did: user.Did}
664 }
665
666 profile.Description = r.FormValue("description")
667 profile.IncludeBluesky = r.FormValue("includeBluesky") == "on"
668 profile.Location = r.FormValue("location")
669 profile.Pronouns = r.FormValue("pronouns")
670 rawPreferredHandle := strings.TrimSpace(r.FormValue("preferredHandle"))
671 if rawPreferredHandle != "" {
672 h, err := syntax.ParseHandle(rawPreferredHandle)
673 if err != nil {
674 s.pages.Notice(w, "update-profile", "Invalid handle format.")
675 return
676 }
677
678 ident, err := s.idResolver.ResolveIdent(r.Context(), user.Did)
679 if err != nil || !slices.Contains(ident.AlsoKnownAs, "at://"+rawPreferredHandle) {
680 s.pages.Notice(w, "update-profile", "Handle not found in your DID document.")
681 return
682 }
683 profile.PreferredHandle = h
684 } else {
685 profile.PreferredHandle = ""
686 }
687
688 var links [5]string
689 for i := range 5 {
690 iLink := r.FormValue(fmt.Sprintf("link%d", i))
691 links[i] = iLink
692 }
693 profile.Links = links
694
695 // Parse stats (exactly 2)
696 stat0 := r.FormValue("stat0")
697 stat1 := r.FormValue("stat1")
698
699 profile.Stats[0].Kind = models.ParseVanityStatKind(stat0)
700 profile.Stats[1].Kind = models.ParseVanityStatKind(stat1)
701
702 if err := db.ValidateProfile(s.db, profile); err != nil {
703 l.Error("invalid profile", "err", err)
704 s.pages.Notice(w, "update-profile", err.Error())
705 return
706 }
707
708 s.updateProfile(profile, w, r)
709}
710
711func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) {
712 l := s.logger.With("handler", "UpdateProfilePins")
713 user := s.oauth.GetMultiAccountUser(r)
714
715 err := r.ParseForm()
716 if err != nil {
717 l.Error("invalid profile update form", "err", err)
718 s.pages.Notice(w, "update-profile", "Invalid form.")
719 return
720 }
721
722 profile, err := db.GetProfile(s.db, user.Did)
723 if err != nil {
724 l.Error("getting profile data", "did", user.Did, "err", err)
725 }
726 if profile == nil {
727 profile = &models.Profile{Did: user.Did}
728 }
729
730 i := 0
731 var pinnedRepos [6]string
732 for key, values := range r.Form {
733 if i >= 6 {
734 l.Warn("too many pinned repos")
735 s.pages.Notice(w, "update-profile", "Only 6 repositories can be pinned at a time.")
736 return
737 }
738 if strings.HasPrefix(key, "pinnedRepo") && len(values) > 0 && values[0] != "" && i < 6 {
739 pinnedRepos[i] = values[0]
740 i++
741 }
742 }
743 profile.PinnedRepos = pinnedRepos
744
745 s.updateProfile(profile, w, r)
746}
747
748func (s *State) updateProfile(profile *models.Profile, w http.ResponseWriter, r *http.Request) {
749 l := s.logger.With("handler", "updateProfile")
750 user := s.oauth.GetMultiAccountUser(r)
751
752 client, err := s.oauth.AuthorizedClient(r)
753 if err != nil {
754 l.Error("failed to get authorized client", "err", err)
755 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
756 return
757 }
758
759 var pinnedRepoStrings []string
760 for _, r := range profile.PinnedRepos {
761 if r != "" {
762 pinnedRepoStrings = append(pinnedRepoStrings, r)
763 }
764 }
765
766 var vanityStats []string
767 for _, v := range profile.Stats {
768 vanityStats = append(vanityStats, string(v.Kind))
769 }
770
771 ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
772 var cid *string
773 var existingAvatar *lexutil.LexBlob
774 if ex != nil {
775 cid = ex.Cid
776 if rec, ok := ex.Value.Val.(*tangled.ActorProfile); ok {
777 existingAvatar = rec.Avatar
778 }
779 }
780
781 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
782 Collection: tangled.ActorProfileNSID,
783 Repo: user.Did,
784 Rkey: "self",
785 Record: &lexutil.LexiconTypeDecoder{
786 Val: &tangled.ActorProfile{
787 Avatar: existingAvatar,
788 Bluesky: profile.IncludeBluesky,
789 Description: &profile.Description,
790 Links: profile.Links[:],
791 Location: &profile.Location,
792 PinnedRepositories: pinnedRepoStrings,
793 Stats: vanityStats[:],
794 Pronouns: &profile.Pronouns,
795 PreferredHandle: (*string)(&profile.PreferredHandle),
796 }},
797 SwapRecord: cid,
798 })
799 if err != nil {
800 l.Error("failed to update profile on PDS", "err", err)
801 s.pages.Notice(w, "update-profile", "Failed to update PDS, try again later.")
802 return
803 }
804
805 tx, err := s.db.BeginTx(r.Context(), nil)
806 if err != nil {
807 l.Error("failed to start transaction", "err", err)
808 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
809 return
810 }
811
812 if err := db.UpsertProfile(tx, profile); err != nil {
813 l.Error("failed to update profile in DB", "err", err)
814 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
815 return
816 }
817
818 if s.rdb != nil {
819 ctx := r.Context()
820 pipe := s.rdb.Pipeline()
821 didKey := fmt.Sprintf(cache.PreferredHandleByDid, profile.Did)
822 if profile.PreferredHandle != "" {
823 pipe.Set(ctx, didKey, string(profile.PreferredHandle), cache.PreferredHandleTTL)
824 pipe.Set(ctx, fmt.Sprintf(cache.PreferredHandleByHandle, string(profile.PreferredHandle)), profile.Did, cache.PreferredHandleTTL)
825 } else {
826 pipe.Del(ctx, didKey)
827 }
828 if _, execErr := pipe.Exec(ctx); execErr != nil {
829 l.Warn("failed to update preferred handle cache", "err", execErr)
830 }
831 }
832
833 s.notifier.UpdateProfile(r.Context(), profile)
834
835 s.pages.HxRedirect(w, "/"+user.Did)
836}
837
838func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
839 l := s.logger.With("handler", "EditBioFragment")
840 user := s.oauth.GetMultiAccountUser(r)
841
842 profile, err := db.GetProfile(s.db, user.Did)
843 if err != nil {
844 l.Error("getting profile data", "did", user.Did, "err", err)
845 }
846 if profile == nil {
847 profile = &models.Profile{Did: user.Did}
848 }
849
850 var alsoKnownAs []string
851 ident, err := s.idResolver.ResolveIdent(r.Context(), user.Did)
852 if err == nil {
853 alsoKnownAs = ident.AlsoKnownAs
854 }
855
856 s.pages.EditBioFragment(w, pages.EditBioParams{
857 LoggedInUser: user,
858 Profile: profile,
859 AlsoKnownAs: alsoKnownAs,
860 })
861}
862
863func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
864 l := s.logger.With("handler", "EditPinsFragment")
865 user := s.oauth.GetMultiAccountUser(r)
866
867 profile, err := db.GetProfile(s.db, user.Did)
868 if err != nil {
869 l.Error("getting profile data", "did", user.Did, "err", err)
870 }
871 if profile == nil {
872 profile = &models.Profile{Did: user.Did}
873 }
874
875 repos, err := db.GetRepos(s.db, orm.FilterEq("did", user.Did))
876 if err != nil {
877 l.Error("getting repos", "did", user.Did, "err", err)
878 }
879
880 collaboratingRepos, err := db.CollaboratingIn(s.db, user.Did)
881 if err != nil {
882 l.Error("getting collaborating repos", "did", user.Did, "err", err)
883 }
884
885 allRepos := []pages.PinnedRepo{}
886
887 for _, r := range repos {
888 allRepos = append(allRepos, pages.PinnedRepo{
889 IsPinned: profile.MatchesPinnedRepo(r),
890 Repo: r,
891 })
892 }
893 for _, r := range collaboratingRepos {
894 allRepos = append(allRepos, pages.PinnedRepo{
895 IsPinned: profile.MatchesPinnedRepo(r),
896 Repo: r,
897 })
898 }
899
900 s.pages.EditPinsFragment(w, pages.EditPinsParams{
901 LoggedInUser: user,
902 Profile: profile,
903 AllRepos: allRepos,
904 })
905}
906
907func (s *State) UploadProfileAvatar(w http.ResponseWriter, r *http.Request) {
908 l := s.logger.With("handler", "UploadProfileAvatar")
909 user := s.oauth.GetMultiAccountUser(r)
910 l = l.With("did", user.Did)
911
912 // Parse multipart form (10MB max)
913 if err := r.ParseMultipartForm(10 << 20); err != nil {
914 l.Error("failed to parse form", "err", err)
915 s.pages.Notice(w, "avatar-error", "Failed to parse form")
916 return
917 }
918
919 file, header, err := r.FormFile("avatar")
920 if err != nil {
921 l.Error("failed to read avatar file", "err", err)
922 s.pages.Notice(w, "avatar-error", "Failed to read avatar file")
923 return
924 }
925 defer file.Close()
926
927 if header.Size > 5000000 {
928 l.Warn("avatar file too large", "size", header.Size)
929 s.pages.Notice(w, "avatar-error", "Avatar file too large (max 5MB)")
930 return
931 }
932
933 contentType := header.Header.Get("Content-Type")
934 if contentType != "image/png" && contentType != "image/jpeg" {
935 l.Warn("invalid image type", "contentType", contentType)
936 s.pages.Notice(w, "avatar-error", "Invalid image type (only PNG and JPEG allowed)")
937 return
938 }
939
940 client, err := s.oauth.AuthorizedClient(r)
941 if err != nil {
942 l.Error("failed to get PDS client", "err", err)
943 s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS")
944 return
945 }
946
947 uploadBlobResp, err := xrpc.RepoUploadBlob(r.Context(), client, file, header.Header.Get("Content-Type"))
948 if err != nil {
949 l.Error("failed to upload avatar blob", "err", err)
950 s.pages.Notice(w, "avatar-error", "Failed to upload avatar to your PDS")
951 return
952 }
953
954 l.Info("uploaded avatar blob", "cid", uploadBlobResp.Blob.Ref.String())
955
956 // get current profile record from PDS to get its CID for swap
957 getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
958 if err != nil {
959 l.Error("failed to get current profile record", "err", err)
960 s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
961 return
962 }
963
964 var profileRecord *tangled.ActorProfile
965 if getRecordResp.Value != nil {
966 if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok {
967 profileRecord = val
968 } else {
969 l.Warn("profile record type assertion failed, creating new record")
970 profileRecord = &tangled.ActorProfile{}
971 }
972 } else {
973 l.Warn("no existing profile record, creating new record")
974 profileRecord = &tangled.ActorProfile{}
975 }
976
977 profileRecord.Avatar = uploadBlobResp.Blob
978
979 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
980 Collection: tangled.ActorProfileNSID,
981 Repo: user.Did,
982 Rkey: "self",
983 Record: &lexutil.LexiconTypeDecoder{Val: profileRecord},
984 SwapRecord: getRecordResp.Cid,
985 })
986
987 if err != nil {
988 l.Error("failed to update profile record", "err", err)
989 s.pages.Notice(w, "avatar-error", "Failed to update profile on your PDS")
990 return
991 }
992
993 l.Info("successfully updated profile with avatar")
994
995 profile, err := db.GetProfile(s.db, user.Did)
996 if err != nil {
997 l.Warn("getting profile data from DB", "err", err)
998 }
999 if profile == nil {
1000 profile = &models.Profile{Did: user.Did}
1001 }
1002 profile.Avatar = uploadBlobResp.Blob.Ref.String()
1003
1004 tx, err := s.db.BeginTx(r.Context(), nil)
1005 if err != nil {
1006 l.Error("failed to start transaction", "err", err)
1007 s.pages.HxRefresh(w)
1008 w.WriteHeader(http.StatusOK)
1009 return
1010 }
1011
1012 err = db.UpsertProfile(tx, profile)
1013 if err != nil {
1014 l.Error("failed to update profile in DB", "err", err)
1015 s.pages.HxRefresh(w)
1016 w.WriteHeader(http.StatusOK)
1017 return
1018 }
1019
1020 s.pages.HxRedirect(w, r.Header.Get("Referer"))
1021}
1022
1023func (s *State) RemoveProfileAvatar(w http.ResponseWriter, r *http.Request) {
1024 l := s.logger.With("handler", "RemoveProfileAvatar")
1025 user := s.oauth.GetMultiAccountUser(r)
1026 l = l.With("did", user.Did)
1027
1028 client, err := s.oauth.AuthorizedClient(r)
1029 if err != nil {
1030 l.Error("failed to get PDS client", "err", err)
1031 s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS")
1032 return
1033 }
1034
1035 getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
1036 if err != nil {
1037 l.Error("failed to get current profile record", "err", err)
1038 s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
1039 return
1040 }
1041
1042 var profileRecord *tangled.ActorProfile
1043 if getRecordResp.Value != nil {
1044 if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok {
1045 profileRecord = val
1046 } else {
1047 l.Warn("profile record type assertion failed")
1048 profileRecord = &tangled.ActorProfile{}
1049 }
1050 } else {
1051 l.Warn("no existing profile record")
1052 profileRecord = &tangled.ActorProfile{}
1053 }
1054
1055 profileRecord.Avatar = nil
1056
1057 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1058 Collection: tangled.ActorProfileNSID,
1059 Repo: user.Did,
1060 Rkey: "self",
1061 Record: &lexutil.LexiconTypeDecoder{Val: profileRecord},
1062 SwapRecord: getRecordResp.Cid,
1063 })
1064
1065 if err != nil {
1066 l.Error("failed to update profile record", "err", err)
1067 s.pages.Notice(w, "avatar-error", "Failed to remove avatar from your PDS")
1068 return
1069 }
1070
1071 l.Info("successfully removed avatar from PDS")
1072
1073 profile, err := db.GetProfile(s.db, user.Did)
1074 if err != nil {
1075 l.Warn("getting profile data from DB", "err", err)
1076 }
1077 if profile == nil {
1078 profile = &models.Profile{Did: user.Did}
1079 }
1080 profile.Avatar = ""
1081
1082 tx, err := s.db.BeginTx(r.Context(), nil)
1083 if err != nil {
1084 l.Error("failed to start transaction", "err", err)
1085 s.pages.HxRefresh(w)
1086 w.WriteHeader(http.StatusOK)
1087 return
1088 }
1089
1090 err = db.UpsertProfile(tx, profile)
1091 if err != nil {
1092 l.Error("failed to update profile in DB", "err", err)
1093 s.pages.HxRefresh(w)
1094 w.WriteHeader(http.StatusOK)
1095 return
1096 }
1097
1098 s.pages.HxRedirect(w, r.Header.Get("Referer"))
1099}
1100
1101func (s *State) UpdateProfilePunchcardSetting(w http.ResponseWriter, r *http.Request) {
1102 l := s.logger.With("handler", "UpdateProfilePunchcardSetting")
1103 err := r.ParseForm()
1104 if err != nil {
1105 l.Error("invalid profile update form", "err", err)
1106 return
1107 }
1108 user := s.oauth.GetMultiAccountUser(r)
1109
1110 hideOthers := false
1111 hideMine := false
1112
1113 if r.Form.Get("hideMine") == "on" {
1114 hideMine = true
1115 }
1116 if r.Form.Get("hideOthers") == "on" {
1117 hideOthers = true
1118 }
1119
1120 err = db.UpsertPunchcardPreference(s.db, user.Did, hideMine, hideOthers)
1121 if err != nil {
1122 l.Error("failed to update punchcard preferences", "err", err)
1123 return
1124 }
1125
1126 s.pages.HxRefresh(w)
1127}