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