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