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