forked from
tangled.org/core
Monorepo for Tangled
1package state
2
3import (
4 "context"
5 "fmt"
6 "log"
7 "net/http"
8 "slices"
9 "strings"
10 "time"
11
12 comatproto "github.com/bluesky-social/indigo/api/atproto"
13 "github.com/bluesky-social/indigo/atproto/identity"
14 "github.com/bluesky-social/indigo/atproto/syntax"
15 lexutil "github.com/bluesky-social/indigo/lex/util"
16 "github.com/go-chi/chi/v5"
17 "github.com/gorilla/feeds"
18 "tangled.org/core/api/tangled"
19 "tangled.org/core/appview/db"
20 "tangled.org/core/appview/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 s.starredPage(w, r)
42 case "strings":
43 s.stringsPage(w, r)
44 default:
45 s.profileOverview(w, r)
46 }
47}
48
49func (s *State) profile(r *http.Request) (*pages.ProfileCard, error) {
50 didOrHandle := chi.URLParam(r, "user")
51 if didOrHandle == "" {
52 return nil, fmt.Errorf("empty DID or handle")
53 }
54
55 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
56 if !ok {
57 return nil, fmt.Errorf("failed to resolve ID")
58 }
59 did := ident.DID.String()
60
61 profile, err := db.GetProfile(s.db, did)
62 if err != nil {
63 return nil, fmt.Errorf("failed to get profile: %w", err)
64 }
65
66 hasProfile := profile != nil
67 if !hasProfile {
68 profile = &models.Profile{Did: did}
69 }
70
71 repoCount, err := db.CountRepos(s.db, orm.FilterEq("did", did))
72 if err != nil {
73 return nil, fmt.Errorf("failed to get repo count: %w", err)
74 }
75
76 stringCount, err := db.CountStrings(s.db, orm.FilterEq("did", did))
77 if err != nil {
78 return nil, fmt.Errorf("failed to get string count: %w", err)
79 }
80
81 starredCount, err := db.CountStars(s.db, orm.FilterEq("did", did))
82 if err != nil {
83 return nil, fmt.Errorf("failed to get starred repo count: %w", err)
84 }
85
86 followStats, err := db.GetFollowerFollowingCount(s.db, did)
87 if err != nil {
88 return nil, fmt.Errorf("failed to get follower stats: %w", err)
89 }
90
91 loggedInUser := s.oauth.GetMultiAccountUser(r)
92 followStatus := models.IsNotFollowing
93 if loggedInUser != nil {
94 followStatus = db.GetFollowStatus(s.db, loggedInUser.Active.Did, did)
95 }
96
97 var loggedInDid string
98 if loggedInUser != nil {
99 loggedInDid = loggedInUser.Did()
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 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, 0, 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 Card: profile,
347 })
348}
349
350func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {
351 l := s.logger.With("handler", "stringsPage")
352
353 profile, err := s.profile(r)
354 if err != nil {
355 l.Error("failed to build profile card", "err", err)
356 s.pages.Error500(w)
357 return
358 }
359 l = l.With("profileDid", profile.UserDid)
360
361 strings, err := db.GetStrings(s.db, 0, orm.FilterEq("did", profile.UserDid))
362 if err != nil {
363 l.Error("failed to get strings", "err", err)
364 s.pages.Error500(w)
365 return
366 }
367
368 err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{
369 LoggedInUser: s.oauth.GetMultiAccountUser(r),
370 Strings: strings,
371 Card: profile,
372 })
373}
374
375type FollowsPageParams struct {
376 Follows []pages.FollowCard
377 Card *pages.ProfileCard
378}
379
380func (s *State) followPage(
381 r *http.Request,
382 fetchFollows func(db.Execer, string) ([]models.Follow, error),
383 extractDid func(models.Follow) string,
384) (*FollowsPageParams, error) {
385 l := s.logger.With("handler", "reposPage")
386
387 profile, err := s.profile(r)
388 if err != nil {
389 return nil, err
390 }
391 l = l.With("profileDid", profile.UserDid)
392
393 loggedInUser := s.oauth.GetMultiAccountUser(r)
394 params := FollowsPageParams{
395 Card: profile,
396 }
397
398 follows, err := fetchFollows(s.db, profile.UserDid)
399 if err != nil {
400 l.Error("failed to fetch follows", "err", err)
401 return ¶ms, err
402 }
403
404 if len(follows) == 0 {
405 return ¶ms, nil
406 }
407
408 followDids := make([]string, 0, len(follows))
409 for _, follow := range follows {
410 followDids = append(followDids, extractDid(follow))
411 }
412
413 profiles, err := db.GetProfiles(s.db, orm.FilterIn("did", followDids))
414 if err != nil {
415 l.Error("failed to get profiles", "followDids", followDids, "err", err)
416 return ¶ms, err
417 }
418
419 followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)
420 if err != nil {
421 log.Printf("getting follow counts for %s: %s", followDids, err)
422 }
423
424 loggedInUserFollowing := make(map[string]struct{})
425 if loggedInUser != nil {
426 following, err := db.GetFollowing(s.db, loggedInUser.Active.Did)
427 if err != nil {
428 l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Active.Did)
429 return ¶ms, err
430 }
431 loggedInUserFollowing = make(map[string]struct{}, len(following))
432 for _, follow := range following {
433 loggedInUserFollowing[follow.SubjectDid] = struct{}{}
434 }
435 }
436
437 followCards := make([]pages.FollowCard, len(follows))
438 for i, did := range followDids {
439 followStats := followStatsMap[did]
440 followStatus := models.IsNotFollowing
441 if _, exists := loggedInUserFollowing[did]; exists {
442 followStatus = models.IsFollowing
443 } else if loggedInUser != nil && loggedInUser.Active.Did == did {
444 followStatus = models.IsSelf
445 }
446
447 var profile *models.Profile
448 if p, exists := profiles[did]; exists {
449 profile = p
450 } else {
451 profile = &models.Profile{}
452 profile.Did = did
453 }
454 followCards[i] = pages.FollowCard{
455 LoggedInUser: loggedInUser,
456 UserDid: did,
457 FollowStatus: followStatus,
458 FollowersCount: followStats.Followers,
459 FollowingCount: followStats.Following,
460 Profile: profile,
461 }
462 }
463
464 params.Follows = followCards
465
466 return ¶ms, nil
467}
468
469func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {
470 followPage, err := s.followPage(r, db.GetFollowers, func(f models.Follow) string { return f.UserDid })
471 if err != nil {
472 s.pages.Notice(w, "all-followers", "Failed to load followers")
473 return
474 }
475
476 s.pages.ProfileFollowers(w, pages.ProfileFollowersParams{
477 LoggedInUser: s.oauth.GetMultiAccountUser(r),
478 Followers: followPage.Follows,
479 Card: followPage.Card,
480 })
481}
482
483func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {
484 followPage, err := s.followPage(r, db.GetFollowing, func(f models.Follow) string { return f.SubjectDid })
485 if err != nil {
486 s.pages.Notice(w, "all-following", "Failed to load following")
487 return
488 }
489
490 s.pages.ProfileFollowing(w, pages.ProfileFollowingParams{
491 LoggedInUser: s.oauth.GetMultiAccountUser(r),
492 Following: followPage.Follows,
493 Card: followPage.Card,
494 })
495}
496
497func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) {
498 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
499 if !ok {
500 s.pages.Error404(w)
501 return
502 }
503
504 feed, err := s.getProfileFeed(r.Context(), &ident)
505 if err != nil {
506 s.pages.Error500(w)
507 return
508 }
509
510 if feed == nil {
511 return
512 }
513
514 atom, err := feed.ToAtom()
515 if err != nil {
516 s.pages.Error500(w)
517 return
518 }
519
520 w.Header().Set("content-type", "application/atom+xml")
521 w.Write([]byte(atom))
522}
523
524func (s *State) getProfileFeed(ctx context.Context, id *identity.Identity) (*feeds.Feed, error) {
525 timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())
526 if err != nil {
527 return nil, err
528 }
529
530 author := &feeds.Author{
531 Name: fmt.Sprintf("@%s", id.Handle),
532 }
533
534 feed := feeds.Feed{
535 Title: fmt.Sprintf("%s's timeline", author.Name),
536 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.BaseUrl(), id.Handle), Type: "text/html", Rel: "alternate"},
537 Items: make([]*feeds.Item, 0),
538 Updated: time.UnixMilli(0),
539 Author: author,
540 }
541
542 for _, byMonth := range timeline.ByMonth {
543 if err := s.addPullRequestItems(ctx, &feed, byMonth.PullEvents.Items, author); err != nil {
544 return nil, err
545 }
546 if err := s.addIssueItems(ctx, &feed, byMonth.IssueEvents.Items, author); err != nil {
547 return nil, err
548 }
549 if err := s.addRepoItems(ctx, &feed, byMonth.RepoEvents, author); err != nil {
550 return nil, err
551 }
552 }
553
554 slices.SortFunc(feed.Items, func(a *feeds.Item, b *feeds.Item) int {
555 return int(b.Created.UnixMilli()) - int(a.Created.UnixMilli())
556 })
557
558 if len(feed.Items) > 0 {
559 feed.Updated = feed.Items[0].Created
560 }
561
562 return &feed, nil
563}
564
565func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*models.Pull, author *feeds.Author) error {
566 for _, pull := range pulls {
567 owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did)
568 if err != nil {
569 return err
570 }
571
572 // Add pull request creation item
573 feed.Items = append(feed.Items, s.createPullRequestItem(pull, owner, author))
574 }
575 return nil
576}
577
578func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*models.Issue, author *feeds.Author) error {
579 for _, issue := range issues {
580 owner, err := s.idResolver.ResolveIdent(ctx, issue.Repo.Did)
581 if err != nil {
582 return err
583 }
584
585 feed.Items = append(feed.Items, s.createIssueItem(issue, owner, author))
586 }
587 return nil
588}
589
590func (s *State) addRepoItems(ctx context.Context, feed *feeds.Feed, repos []models.RepoEvent, author *feeds.Author) error {
591 for _, repo := range repos {
592 item, err := s.createRepoItem(ctx, repo, author)
593 if err != nil {
594 return err
595 }
596 feed.Items = append(feed.Items, item)
597 }
598 return nil
599}
600
601func (s *State) createPullRequestItem(pull *models.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item {
602 return &feeds.Item{
603 Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name),
604 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"},
605 Created: pull.Created,
606 Author: author,
607 }
608}
609
610func (s *State) createIssueItem(issue *models.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item {
611 return &feeds.Item{
612 Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Repo.Name),
613 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"},
614 Created: issue.Created,
615 Author: author,
616 }
617}
618
619func (s *State) createRepoItem(ctx context.Context, repo models.RepoEvent, author *feeds.Author) (*feeds.Item, error) {
620 var title string
621 if repo.Source != nil {
622 sourceOwner, err := s.idResolver.ResolveIdent(ctx, repo.Source.Did)
623 if err != nil {
624 return nil, err
625 }
626 title = fmt.Sprintf("%s forked repository @%s/%s to '%s'", author.Name, sourceOwner.Handle, repo.Source.Name, repo.Repo.Name)
627 } else {
628 title = fmt.Sprintf("%s created repository '%s'", author.Name, repo.Repo.Name)
629 }
630
631 return &feeds.Item{
632 Title: title,
633 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
634 Created: repo.Repo.Created,
635 Author: author,
636 }, nil
637}
638
639func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {
640 user := s.oauth.GetMultiAccountUser(r)
641
642 err := r.ParseForm()
643 if err != nil {
644 log.Println("invalid profile update form", err)
645 s.pages.Notice(w, "update-profile", "Invalid form.")
646 return
647 }
648
649 profile, err := db.GetProfile(s.db, user.Active.Did)
650 if err != nil {
651 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
652 }
653 if profile == nil {
654 profile = &models.Profile{Did: user.Active.Did}
655 }
656
657 profile.Description = r.FormValue("description")
658 profile.IncludeBluesky = r.FormValue("includeBluesky") == "on"
659 profile.Location = r.FormValue("location")
660 profile.Pronouns = r.FormValue("pronouns")
661 rawPreferredHandle := strings.TrimSpace(r.FormValue("preferredHandle"))
662 if rawPreferredHandle != "" {
663 h, err := syntax.ParseHandle(rawPreferredHandle)
664 if err != nil {
665 s.pages.Notice(w, "update-profile", "Invalid handle format.")
666 return
667 }
668
669 ident, err := s.idResolver.ResolveIdent(r.Context(), user.Active.Did)
670 if err != nil || !slices.Contains(ident.AlsoKnownAs, "at://"+rawPreferredHandle) {
671 s.pages.Notice(w, "update-profile", "Handle not found in your DID document.")
672 return
673 }
674 profile.PreferredHandle = h
675 } else {
676 profile.PreferredHandle = ""
677 }
678
679 var links [5]string
680 for i := range 5 {
681 iLink := r.FormValue(fmt.Sprintf("link%d", i))
682 links[i] = iLink
683 }
684 profile.Links = links
685
686 // Parse stats (exactly 2)
687 stat0 := r.FormValue("stat0")
688 stat1 := r.FormValue("stat1")
689
690 profile.Stats[0].Kind = models.ParseVanityStatKind(stat0)
691 profile.Stats[1].Kind = models.ParseVanityStatKind(stat1)
692
693 if err := db.ValidateProfile(s.db, profile); err != nil {
694 log.Println("invalid profile", err)
695 s.pages.Notice(w, "update-profile", err.Error())
696 return
697 }
698
699 s.updateProfile(profile, w, r)
700}
701
702func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) {
703 user := s.oauth.GetMultiAccountUser(r)
704
705 err := r.ParseForm()
706 if err != nil {
707 log.Println("invalid profile update form", err)
708 s.pages.Notice(w, "update-profile", "Invalid form.")
709 return
710 }
711
712 profile, err := db.GetProfile(s.db, user.Active.Did)
713 if err != nil {
714 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
715 }
716 if profile == nil {
717 profile = &models.Profile{Did: user.Active.Did}
718 }
719
720 i := 0
721 var pinnedRepos [6]string
722 for key, values := range r.Form {
723 if i >= 6 {
724 log.Println("invalid pin update form", err)
725 s.pages.Notice(w, "update-profile", "Only 6 repositories can be pinned at a time.")
726 return
727 }
728 if strings.HasPrefix(key, "pinnedRepo") && len(values) > 0 && values[0] != "" && i < 6 {
729 pinnedRepos[i] = values[0]
730 i++
731 }
732 }
733 profile.PinnedRepos = pinnedRepos
734
735 s.updateProfile(profile, w, r)
736}
737
738func (s *State) updateProfile(profile *models.Profile, w http.ResponseWriter, r *http.Request) {
739 user := s.oauth.GetMultiAccountUser(r)
740 tx, err := s.db.BeginTx(r.Context(), nil)
741 if err != nil {
742 log.Println("failed to start transaction", err)
743 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
744 return
745 }
746
747 client, err := s.oauth.AuthorizedClient(r)
748 if err != nil {
749 log.Println("failed to get authorized client", err)
750 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
751 return
752 }
753
754 var pinnedRepoStrings []string
755 for _, r := range profile.PinnedRepos {
756 if r != "" {
757 pinnedRepoStrings = append(pinnedRepoStrings, r)
758 }
759 }
760
761 var vanityStats []string
762 for _, v := range profile.Stats {
763 vanityStats = append(vanityStats, string(v.Kind))
764 }
765
766 ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Active.Did, "self")
767 var cid *string
768 var existingAvatar *lexutil.LexBlob
769 if ex != nil {
770 cid = ex.Cid
771 if rec, ok := ex.Value.Val.(*tangled.ActorProfile); ok {
772 existingAvatar = rec.Avatar
773 }
774 }
775
776 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
777 Collection: tangled.ActorProfileNSID,
778 Repo: user.Active.Did,
779 Rkey: "self",
780 Record: &lexutil.LexiconTypeDecoder{
781 Val: &tangled.ActorProfile{
782 Avatar: existingAvatar,
783 Bluesky: profile.IncludeBluesky,
784 Description: &profile.Description,
785 Links: profile.Links[:],
786 Location: &profile.Location,
787 PinnedRepositories: pinnedRepoStrings,
788 Stats: vanityStats[:],
789 Pronouns: &profile.Pronouns,
790 PreferredHandle: (*string)(&profile.PreferredHandle),
791 }},
792 SwapRecord: cid,
793 })
794 if err != nil {
795 log.Println("failed to update profile", err)
796 s.pages.Notice(w, "update-profile", "Failed to update PDS, try again later.")
797 return
798 }
799
800 err = db.UpsertProfile(tx, profile)
801 if err != nil {
802 log.Println("failed to update profile", err)
803 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
804 return
805 }
806
807 s.notifier.UpdateProfile(r.Context(), profile)
808
809 s.pages.HxRedirect(w, "/"+user.Active.Did)
810}
811
812func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
813 user := s.oauth.GetMultiAccountUser(r)
814
815 profile, err := db.GetProfile(s.db, user.Active.Did)
816 if err != nil {
817 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
818 }
819 if profile == nil {
820 profile = &models.Profile{Did: user.Active.Did}
821 }
822
823 var alsoKnownAs []string
824 ident, err := s.idResolver.ResolveIdent(r.Context(), user.Active.Did)
825 if err == nil {
826 alsoKnownAs = ident.AlsoKnownAs
827 }
828
829 s.pages.EditBioFragment(w, pages.EditBioParams{
830 LoggedInUser: user,
831 Profile: profile,
832 AlsoKnownAs: alsoKnownAs,
833 })
834}
835
836func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
837 user := s.oauth.GetMultiAccountUser(r)
838
839 profile, err := db.GetProfile(s.db, user.Active.Did)
840 if err != nil {
841 log.Printf("getting profile data for %s: %s", user.Active.Did, err)
842 }
843 if profile == nil {
844 profile = &models.Profile{Did: user.Active.Did}
845 }
846
847 repos, err := db.GetRepos(s.db, orm.FilterEq("did", user.Active.Did))
848 if err != nil {
849 log.Printf("getting repos for %s: %s", user.Active.Did, err)
850 }
851
852 collaboratingRepos, err := db.CollaboratingIn(s.db, user.Active.Did)
853 if err != nil {
854 log.Printf("getting collaborating repos for %s: %s", user.Active.Did, err)
855 }
856
857 allRepos := []pages.PinnedRepo{}
858
859 for _, r := range repos {
860 allRepos = append(allRepos, pages.PinnedRepo{
861 IsPinned: profile.MatchesPinnedRepo(r),
862 Repo: r,
863 })
864 }
865 for _, r := range collaboratingRepos {
866 allRepos = append(allRepos, pages.PinnedRepo{
867 IsPinned: profile.MatchesPinnedRepo(r),
868 Repo: r,
869 })
870 }
871
872 s.pages.EditPinsFragment(w, pages.EditPinsParams{
873 LoggedInUser: user,
874 Profile: profile,
875 AllRepos: allRepos,
876 })
877}
878
879func (s *State) UploadProfileAvatar(w http.ResponseWriter, r *http.Request) {
880 l := s.logger.With("handler", "UploadProfileAvatar")
881 user := s.oauth.GetUser(r)
882 l = l.With("did", user.Did)
883
884 // Parse multipart form (10MB max)
885 if err := r.ParseMultipartForm(10 << 20); err != nil {
886 l.Error("failed to parse form", "err", err)
887 s.pages.Notice(w, "avatar-error", "Failed to parse form")
888 return
889 }
890
891 file, header, err := r.FormFile("avatar")
892 if err != nil {
893 l.Error("failed to read avatar file", "err", err)
894 s.pages.Notice(w, "avatar-error", "Failed to read avatar file")
895 return
896 }
897 defer file.Close()
898
899 if header.Size > 5000000 {
900 l.Warn("avatar file too large", "size", header.Size)
901 s.pages.Notice(w, "avatar-error", "Avatar file too large (max 5MB)")
902 return
903 }
904
905 contentType := header.Header.Get("Content-Type")
906 if contentType != "image/png" && contentType != "image/jpeg" {
907 l.Warn("invalid image type", "contentType", contentType)
908 s.pages.Notice(w, "avatar-error", "Invalid image type (only PNG and JPEG allowed)")
909 return
910 }
911
912 client, err := s.oauth.AuthorizedClient(r)
913 if err != nil {
914 l.Error("failed to get PDS client", "err", err)
915 s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS")
916 return
917 }
918
919 uploadBlobResp, err := xrpc.RepoUploadBlob(r.Context(), client, file, header.Header.Get("Content-Type"))
920 if err != nil {
921 l.Error("failed to upload avatar blob", "err", err)
922 s.pages.Notice(w, "avatar-error", "Failed to upload avatar to your PDS")
923 return
924 }
925
926 l.Info("uploaded avatar blob", "cid", uploadBlobResp.Blob.Ref.String())
927
928 // get current profile record from PDS to get its CID for swap
929 getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
930 if err != nil {
931 l.Error("failed to get current profile record", "err", err)
932 s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
933 return
934 }
935
936 var profileRecord *tangled.ActorProfile
937 if getRecordResp.Value != nil {
938 if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok {
939 profileRecord = val
940 } else {
941 l.Warn("profile record type assertion failed, creating new record")
942 profileRecord = &tangled.ActorProfile{}
943 }
944 } else {
945 l.Warn("no existing profile record, creating new record")
946 profileRecord = &tangled.ActorProfile{}
947 }
948
949 profileRecord.Avatar = uploadBlobResp.Blob
950
951 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
952 Collection: tangled.ActorProfileNSID,
953 Repo: user.Did,
954 Rkey: "self",
955 Record: &lexutil.LexiconTypeDecoder{Val: profileRecord},
956 SwapRecord: getRecordResp.Cid,
957 })
958
959 if err != nil {
960 l.Error("failed to update profile record", "err", err)
961 s.pages.Notice(w, "avatar-error", "Failed to update profile on your PDS")
962 return
963 }
964
965 l.Info("successfully updated profile with avatar")
966
967 profile, err := db.GetProfile(s.db, user.Did)
968 if err != nil {
969 l.Warn("getting profile data from DB", "err", err)
970 }
971 if profile == nil {
972 profile = &models.Profile{Did: user.Did}
973 }
974 profile.Avatar = uploadBlobResp.Blob.Ref.String()
975
976 tx, err := s.db.BeginTx(r.Context(), nil)
977 if err != nil {
978 l.Error("failed to start transaction", "err", err)
979 s.pages.HxRefresh(w)
980 w.WriteHeader(http.StatusOK)
981 return
982 }
983
984 err = db.UpsertProfile(tx, profile)
985 if err != nil {
986 l.Error("failed to update profile in DB", "err", err)
987 s.pages.HxRefresh(w)
988 w.WriteHeader(http.StatusOK)
989 return
990 }
991
992 s.pages.HxRedirect(w, r.Header.Get("Referer"))
993}
994
995func (s *State) RemoveProfileAvatar(w http.ResponseWriter, r *http.Request) {
996 l := s.logger.With("handler", "RemoveProfileAvatar")
997 user := s.oauth.GetUser(r)
998 l = l.With("did", user.Did)
999
1000 client, err := s.oauth.AuthorizedClient(r)
1001 if err != nil {
1002 l.Error("failed to get PDS client", "err", err)
1003 s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS")
1004 return
1005 }
1006
1007 getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
1008 if err != nil {
1009 l.Error("failed to get current profile record", "err", err)
1010 s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS")
1011 return
1012 }
1013
1014 var profileRecord *tangled.ActorProfile
1015 if getRecordResp.Value != nil {
1016 if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok {
1017 profileRecord = val
1018 } else {
1019 l.Warn("profile record type assertion failed")
1020 profileRecord = &tangled.ActorProfile{}
1021 }
1022 } else {
1023 l.Warn("no existing profile record")
1024 profileRecord = &tangled.ActorProfile{}
1025 }
1026
1027 profileRecord.Avatar = nil
1028
1029 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1030 Collection: tangled.ActorProfileNSID,
1031 Repo: user.Did,
1032 Rkey: "self",
1033 Record: &lexutil.LexiconTypeDecoder{Val: profileRecord},
1034 SwapRecord: getRecordResp.Cid,
1035 })
1036
1037 if err != nil {
1038 l.Error("failed to update profile record", "err", err)
1039 s.pages.Notice(w, "avatar-error", "Failed to remove avatar from your PDS")
1040 return
1041 }
1042
1043 l.Info("successfully removed avatar from PDS")
1044
1045 profile, err := db.GetProfile(s.db, user.Did)
1046 if err != nil {
1047 l.Warn("getting profile data from DB", "err", err)
1048 }
1049 if profile == nil {
1050 profile = &models.Profile{Did: user.Did}
1051 }
1052 profile.Avatar = ""
1053
1054 tx, err := s.db.BeginTx(r.Context(), nil)
1055 if err != nil {
1056 l.Error("failed to start transaction", "err", err)
1057 s.pages.HxRefresh(w)
1058 w.WriteHeader(http.StatusOK)
1059 return
1060 }
1061
1062 err = db.UpsertProfile(tx, profile)
1063 if err != nil {
1064 l.Error("failed to update profile in DB", "err", err)
1065 s.pages.HxRefresh(w)
1066 w.WriteHeader(http.StatusOK)
1067 return
1068 }
1069
1070 s.pages.HxRedirect(w, r.Header.Get("Referer"))
1071}
1072
1073func (s *State) UpdateProfilePunchcardSetting(w http.ResponseWriter, r *http.Request) {
1074 err := r.ParseForm()
1075 if err != nil {
1076 log.Println("invalid profile update form", err)
1077 return
1078 }
1079 user := s.oauth.GetUser(r)
1080
1081 hideOthers := false
1082 hideMine := false
1083
1084 if r.Form.Get("hideMine") == "on" {
1085 hideMine = true
1086 }
1087 if r.Form.Get("hideOthers") == "on" {
1088 hideOthers = true
1089 }
1090
1091 err = db.UpsertPunchcardPreference(s.db, user.Did, hideMine, hideOthers)
1092 if err != nil {
1093 log.Println("failed to update punchcard preferences", err)
1094 return
1095 }
1096
1097 s.pages.HxRefresh(w)
1098}