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