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