julien.rbrt.fr
forked from
tangled.org/core
Monorepo for Tangled — https://tangled.org
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)
23
24func (s *State) Profile(w http.ResponseWriter, r *http.Request) {
25 tabVal := r.URL.Query().Get("tab")
26 switch tabVal {
27 case "repos":
28 s.reposPage(w, r)
29 case "followers":
30 s.followersPage(w, r)
31 case "following":
32 s.followingPage(w, r)
33 case "starred":
34 s.starredPage(w, r)
35 case "strings":
36 s.stringsPage(w, r)
37 default:
38 s.profileOverview(w, r)
39 }
40}
41
42func (s *State) profile(r *http.Request) (*pages.ProfileCard, error) {
43 didOrHandle := chi.URLParam(r, "user")
44 if didOrHandle == "" {
45 return nil, fmt.Errorf("empty DID or handle")
46 }
47
48 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
49 if !ok {
50 return nil, fmt.Errorf("failed to resolve ID")
51 }
52 did := ident.DID.String()
53
54 profile, err := db.GetProfile(s.db, did)
55 if err != nil {
56 return nil, fmt.Errorf("failed to get profile: %w", err)
57 }
58
59 repoCount, err := db.CountRepos(s.db, db.FilterEq("did", did))
60 if err != nil {
61 return nil, fmt.Errorf("failed to get repo count: %w", err)
62 }
63
64 stringCount, err := db.CountStrings(s.db, db.FilterEq("did", did))
65 if err != nil {
66 return nil, fmt.Errorf("failed to get string count: %w", err)
67 }
68
69 starredCount, err := db.CountStars(s.db, db.FilterEq("starred_by_did", did))
70 if err != nil {
71 return nil, fmt.Errorf("failed to get starred repo count: %w", err)
72 }
73
74 followStats, err := db.GetFollowerFollowingCount(s.db, did)
75 if err != nil {
76 return nil, fmt.Errorf("failed to get follower stats: %w", err)
77 }
78
79 loggedInUser := s.oauth.GetUser(r)
80 followStatus := models.IsNotFollowing
81 if loggedInUser != nil {
82 followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
83 }
84
85 now := time.Now()
86 startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
87 punchcard, err := db.MakePunchcard(
88 s.db,
89 db.FilterEq("did", did),
90 db.FilterGte("date", startOfYear.Format(time.DateOnly)),
91 db.FilterLte("date", now.Format(time.DateOnly)),
92 )
93 if err != nil {
94 return nil, fmt.Errorf("failed to get punchcard for %s: %w", did, err)
95 }
96
97 return &pages.ProfileCard{
98 UserDid: did,
99 UserHandle: ident.Handle.String(),
100 Profile: profile,
101 FollowStatus: followStatus,
102 Stats: pages.ProfileStats{
103 RepoCount: repoCount,
104 StringCount: stringCount,
105 StarredCount: starredCount,
106 FollowersCount: followStats.Followers,
107 FollowingCount: followStats.Following,
108 },
109 Punchcard: punchcard,
110 }, nil
111}
112
113func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {
114 l := s.logger.With("handler", "profileHomePage")
115
116 profile, err := s.profile(r)
117 if err != nil {
118 l.Error("failed to build profile card", "err", err)
119 s.pages.Error500(w)
120 return
121 }
122 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
123
124 repos, err := db.GetRepos(
125 s.db,
126 0,
127 db.FilterEq("did", profile.UserDid),
128 )
129 if err != nil {
130 l.Error("failed to fetch repos", "err", err)
131 }
132
133 // filter out ones that are pinned
134 pinnedRepos := []models.Repo{}
135 for i, r := range repos {
136 // if this is a pinned repo, add it
137 if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
138 pinnedRepos = append(pinnedRepos, r)
139 }
140
141 // if there are no saved pins, add the first 4 repos
142 if profile.Profile.IsPinnedReposEmpty() && i < 4 {
143 pinnedRepos = append(pinnedRepos, r)
144 }
145 }
146
147 collaboratingRepos, err := db.CollaboratingIn(s.db, profile.UserDid)
148 if err != nil {
149 l.Error("failed to fetch collaborating repos", "err", err)
150 }
151
152 pinnedCollaboratingRepos := []models.Repo{}
153 for _, r := range collaboratingRepos {
154 // if this is a pinned repo, add it
155 if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
156 pinnedCollaboratingRepos = append(pinnedCollaboratingRepos, r)
157 }
158 }
159
160 timeline, err := db.MakeProfileTimeline(s.db, profile.UserDid)
161 if err != nil {
162 l.Error("failed to create timeline", "err", err)
163 }
164
165 s.pages.ProfileOverview(w, pages.ProfileOverviewParams{
166 LoggedInUser: s.oauth.GetUser(r),
167 Card: profile,
168 Repos: pinnedRepos,
169 CollaboratingRepos: pinnedCollaboratingRepos,
170 ProfileTimeline: timeline,
171 })
172}
173
174func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
175 l := s.logger.With("handler", "reposPage")
176
177 profile, err := s.profile(r)
178 if err != nil {
179 l.Error("failed to build profile card", "err", err)
180 s.pages.Error500(w)
181 return
182 }
183 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
184
185 repos, err := db.GetRepos(
186 s.db,
187 0,
188 db.FilterEq("did", profile.UserDid),
189 )
190 if err != nil {
191 l.Error("failed to get repos", "err", err)
192 s.pages.Error500(w)
193 return
194 }
195
196 err = s.pages.ProfileRepos(w, pages.ProfileReposParams{
197 LoggedInUser: s.oauth.GetUser(r),
198 Repos: repos,
199 Card: profile,
200 })
201}
202
203func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {
204 l := s.logger.With("handler", "starredPage")
205
206 profile, err := s.profile(r)
207 if err != nil {
208 l.Error("failed to build profile card", "err", err)
209 s.pages.Error500(w)
210 return
211 }
212 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
213
214 stars, err := db.GetStars(s.db, 0, db.FilterEq("starred_by_did", profile.UserDid))
215 if err != nil {
216 l.Error("failed to get stars", "err", err)
217 s.pages.Error500(w)
218 return
219 }
220 var repos []models.Repo
221 for _, s := range stars {
222 if s.Repo != nil {
223 repos = append(repos, *s.Repo)
224 }
225 }
226
227 err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{
228 LoggedInUser: s.oauth.GetUser(r),
229 Repos: repos,
230 Card: profile,
231 })
232}
233
234func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) {
235 l := s.logger.With("handler", "stringsPage")
236
237 profile, err := s.profile(r)
238 if err != nil {
239 l.Error("failed to build profile card", "err", err)
240 s.pages.Error500(w)
241 return
242 }
243 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
244
245 strings, err := db.GetStrings(s.db, 0, db.FilterEq("did", profile.UserDid))
246 if err != nil {
247 l.Error("failed to get strings", "err", err)
248 s.pages.Error500(w)
249 return
250 }
251
252 err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{
253 LoggedInUser: s.oauth.GetUser(r),
254 Strings: strings,
255 Card: profile,
256 })
257}
258
259type FollowsPageParams struct {
260 Follows []pages.FollowCard
261 Card *pages.ProfileCard
262}
263
264func (s *State) followPage(
265 r *http.Request,
266 fetchFollows func(db.Execer, string) ([]models.Follow, error),
267 extractDid func(models.Follow) string,
268) (*FollowsPageParams, error) {
269 l := s.logger.With("handler", "reposPage")
270
271 profile, err := s.profile(r)
272 if err != nil {
273 return nil, err
274 }
275 l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
276
277 loggedInUser := s.oauth.GetUser(r)
278 params := FollowsPageParams{
279 Card: profile,
280 }
281
282 follows, err := fetchFollows(s.db, profile.UserDid)
283 if err != nil {
284 l.Error("failed to fetch follows", "err", err)
285 return ¶ms, err
286 }
287
288 if len(follows) == 0 {
289 return ¶ms, nil
290 }
291
292 followDids := make([]string, 0, len(follows))
293 for _, follow := range follows {
294 followDids = append(followDids, extractDid(follow))
295 }
296
297 profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))
298 if err != nil {
299 l.Error("failed to get profiles", "followDids", followDids, "err", err)
300 return ¶ms, err
301 }
302
303 followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)
304 if err != nil {
305 log.Printf("getting follow counts for %s: %s", followDids, err)
306 }
307
308 loggedInUserFollowing := make(map[string]struct{})
309 if loggedInUser != nil {
310 following, err := db.GetFollowing(s.db, loggedInUser.Did)
311 if err != nil {
312 l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Did)
313 return ¶ms, err
314 }
315 loggedInUserFollowing = make(map[string]struct{}, len(following))
316 for _, follow := range following {
317 loggedInUserFollowing[follow.SubjectDid] = struct{}{}
318 }
319 }
320
321 followCards := make([]pages.FollowCard, len(follows))
322 for i, did := range followDids {
323 followStats := followStatsMap[did]
324 followStatus := models.IsNotFollowing
325 if _, exists := loggedInUserFollowing[did]; exists {
326 followStatus = models.IsFollowing
327 } else if loggedInUser != nil && loggedInUser.Did == did {
328 followStatus = models.IsSelf
329 }
330
331 var profile *models.Profile
332 if p, exists := profiles[did]; exists {
333 profile = p
334 } else {
335 profile = &models.Profile{}
336 profile.Did = did
337 }
338 followCards[i] = pages.FollowCard{
339 LoggedInUser: loggedInUser,
340 UserDid: did,
341 FollowStatus: followStatus,
342 FollowersCount: followStats.Followers,
343 FollowingCount: followStats.Following,
344 Profile: profile,
345 }
346 }
347
348 params.Follows = followCards
349
350 return ¶ms, nil
351}
352
353func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {
354 followPage, err := s.followPage(r, db.GetFollowers, func(f models.Follow) string { return f.UserDid })
355 if err != nil {
356 s.pages.Notice(w, "all-followers", "Failed to load followers")
357 return
358 }
359
360 s.pages.ProfileFollowers(w, pages.ProfileFollowersParams{
361 LoggedInUser: s.oauth.GetUser(r),
362 Followers: followPage.Follows,
363 Card: followPage.Card,
364 })
365}
366
367func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {
368 followPage, err := s.followPage(r, db.GetFollowing, func(f models.Follow) string { return f.SubjectDid })
369 if err != nil {
370 s.pages.Notice(w, "all-following", "Failed to load following")
371 return
372 }
373
374 s.pages.ProfileFollowing(w, pages.ProfileFollowingParams{
375 LoggedInUser: s.oauth.GetUser(r),
376 Following: followPage.Follows,
377 Card: followPage.Card,
378 })
379}
380
381func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) {
382 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
383 if !ok {
384 s.pages.Error404(w)
385 return
386 }
387
388 feed, err := s.getProfileFeed(r.Context(), &ident)
389 if err != nil {
390 s.pages.Error500(w)
391 return
392 }
393
394 if feed == nil {
395 return
396 }
397
398 atom, err := feed.ToAtom()
399 if err != nil {
400 s.pages.Error500(w)
401 return
402 }
403
404 w.Header().Set("content-type", "application/atom+xml")
405 w.Write([]byte(atom))
406}
407
408func (s *State) getProfileFeed(ctx context.Context, id *identity.Identity) (*feeds.Feed, error) {
409 timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())
410 if err != nil {
411 return nil, err
412 }
413
414 author := &feeds.Author{
415 Name: fmt.Sprintf("@%s", id.Handle),
416 }
417
418 feed := feeds.Feed{
419 Title: fmt.Sprintf("%s's timeline", author.Name),
420 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.AppviewHost, id.Handle), Type: "text/html", Rel: "alternate"},
421 Items: make([]*feeds.Item, 0),
422 Updated: time.UnixMilli(0),
423 Author: author,
424 }
425
426 for _, byMonth := range timeline.ByMonth {
427 if err := s.addPullRequestItems(ctx, &feed, byMonth.PullEvents.Items, author); err != nil {
428 return nil, err
429 }
430 if err := s.addIssueItems(ctx, &feed, byMonth.IssueEvents.Items, author); err != nil {
431 return nil, err
432 }
433 if err := s.addRepoItems(ctx, &feed, byMonth.RepoEvents, author); err != nil {
434 return nil, err
435 }
436 }
437
438 slices.SortFunc(feed.Items, func(a *feeds.Item, b *feeds.Item) int {
439 return int(b.Created.UnixMilli()) - int(a.Created.UnixMilli())
440 })
441
442 if len(feed.Items) > 0 {
443 feed.Updated = feed.Items[0].Created
444 }
445
446 return &feed, nil
447}
448
449func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*models.Pull, author *feeds.Author) error {
450 for _, pull := range pulls {
451 owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did)
452 if err != nil {
453 return err
454 }
455
456 // Add pull request creation item
457 feed.Items = append(feed.Items, s.createPullRequestItem(pull, owner, author))
458 }
459 return nil
460}
461
462func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*models.Issue, author *feeds.Author) error {
463 for _, issue := range issues {
464 owner, err := s.idResolver.ResolveIdent(ctx, issue.Repo.Did)
465 if err != nil {
466 return err
467 }
468
469 feed.Items = append(feed.Items, s.createIssueItem(issue, owner, author))
470 }
471 return nil
472}
473
474func (s *State) addRepoItems(ctx context.Context, feed *feeds.Feed, repos []models.RepoEvent, author *feeds.Author) error {
475 for _, repo := range repos {
476 item, err := s.createRepoItem(ctx, repo, author)
477 if err != nil {
478 return err
479 }
480 feed.Items = append(feed.Items, item)
481 }
482 return nil
483}
484
485func (s *State) createPullRequestItem(pull *models.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item {
486 return &feeds.Item{
487 Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name),
488 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.AppviewHost, owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"},
489 Created: pull.Created,
490 Author: author,
491 }
492}
493
494func (s *State) createIssueItem(issue *models.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item {
495 return &feeds.Item{
496 Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Repo.Name),
497 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.AppviewHost, owner.Handle, issue.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"},
498 Created: issue.Created,
499 Author: author,
500 }
501}
502
503func (s *State) createRepoItem(ctx context.Context, repo models.RepoEvent, author *feeds.Author) (*feeds.Item, error) {
504 var title string
505 if repo.Source != nil {
506 sourceOwner, err := s.idResolver.ResolveIdent(ctx, repo.Source.Did)
507 if err != nil {
508 return nil, err
509 }
510 title = fmt.Sprintf("%s forked repository @%s/%s to '%s'", author.Name, sourceOwner.Handle, repo.Source.Name, repo.Repo.Name)
511 } else {
512 title = fmt.Sprintf("%s created repository '%s'", author.Name, repo.Repo.Name)
513 }
514
515 return &feeds.Item{
516 Title: title,
517 Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s", s.config.Core.AppviewHost, author.Name[1:], repo.Repo.Name), Type: "text/html", Rel: "alternate"}, // Remove @ prefix
518 Created: repo.Repo.Created,
519 Author: author,
520 }, nil
521}
522
523func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {
524 user := s.oauth.GetUser(r)
525
526 err := r.ParseForm()
527 if err != nil {
528 log.Println("invalid profile update form", err)
529 s.pages.Notice(w, "update-profile", "Invalid form.")
530 return
531 }
532
533 profile, err := db.GetProfile(s.db, user.Did)
534 if err != nil {
535 log.Printf("getting profile data for %s: %s", user.Did, err)
536 }
537
538 profile.Description = r.FormValue("description")
539 profile.IncludeBluesky = r.FormValue("includeBluesky") == "on"
540 profile.Location = r.FormValue("location")
541
542 var links [5]string
543 for i := range 5 {
544 iLink := r.FormValue(fmt.Sprintf("link%d", i))
545 links[i] = iLink
546 }
547 profile.Links = links
548
549 // Parse stats (exactly 2)
550 stat0 := r.FormValue("stat0")
551 stat1 := r.FormValue("stat1")
552
553 if stat0 != "" {
554 profile.Stats[0].Kind = models.VanityStatKind(stat0)
555 }
556
557 if stat1 != "" {
558 profile.Stats[1].Kind = models.VanityStatKind(stat1)
559 }
560
561 if err := db.ValidateProfile(s.db, profile); err != nil {
562 log.Println("invalid profile", err)
563 s.pages.Notice(w, "update-profile", err.Error())
564 return
565 }
566
567 s.updateProfile(profile, w, r)
568}
569
570func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) {
571 user := s.oauth.GetUser(r)
572
573 err := r.ParseForm()
574 if err != nil {
575 log.Println("invalid profile update form", err)
576 s.pages.Notice(w, "update-profile", "Invalid form.")
577 return
578 }
579
580 profile, err := db.GetProfile(s.db, user.Did)
581 if err != nil {
582 log.Printf("getting profile data for %s: %s", user.Did, err)
583 }
584
585 i := 0
586 var pinnedRepos [6]syntax.ATURI
587 for key, values := range r.Form {
588 if i >= 6 {
589 log.Println("invalid pin update form", err)
590 s.pages.Notice(w, "update-profile", "Only 6 repositories can be pinned at a time.")
591 return
592 }
593 if strings.HasPrefix(key, "pinnedRepo") && len(values) > 0 && values[0] != "" && i < 6 {
594 aturi, err := syntax.ParseATURI(values[0])
595 if err != nil {
596 log.Println("invalid profile update form", err)
597 s.pages.Notice(w, "update-profile", "Invalid form.")
598 return
599 }
600 pinnedRepos[i] = aturi
601 i++
602 }
603 }
604 profile.PinnedRepos = pinnedRepos
605
606 s.updateProfile(profile, w, r)
607}
608
609func (s *State) updateProfile(profile *models.Profile, w http.ResponseWriter, r *http.Request) {
610 user := s.oauth.GetUser(r)
611 tx, err := s.db.BeginTx(r.Context(), nil)
612 if err != nil {
613 log.Println("failed to start transaction", err)
614 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
615 return
616 }
617
618 client, err := s.oauth.AuthorizedClient(r)
619 if err != nil {
620 log.Println("failed to get authorized client", err)
621 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
622 return
623 }
624
625 // yeah... lexgen dose not support syntax.ATURI in the record for some reason,
626 // nor does it support exact size arrays
627 var pinnedRepoStrings []string
628 for _, r := range profile.PinnedRepos {
629 pinnedRepoStrings = append(pinnedRepoStrings, r.String())
630 }
631
632 var vanityStats []string
633 for _, v := range profile.Stats {
634 vanityStats = append(vanityStats, string(v.Kind))
635 }
636
637 ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
638 var cid *string
639 if ex != nil {
640 cid = ex.Cid
641 }
642
643 _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
644 Collection: tangled.ActorProfileNSID,
645 Repo: user.Did,
646 Rkey: "self",
647 Record: &lexutil.LexiconTypeDecoder{
648 Val: &tangled.ActorProfile{
649 Bluesky: profile.IncludeBluesky,
650 Description: &profile.Description,
651 Links: profile.Links[:],
652 Location: &profile.Location,
653 PinnedRepositories: pinnedRepoStrings,
654 Stats: vanityStats[:],
655 }},
656 SwapRecord: cid,
657 })
658 if err != nil {
659 log.Println("failed to update profile", err)
660 s.pages.Notice(w, "update-profile", "Failed to update PDS, try again later.")
661 return
662 }
663
664 err = db.UpsertProfile(tx, profile)
665 if err != nil {
666 log.Println("failed to update profile", err)
667 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
668 return
669 }
670
671 s.notifier.UpdateProfile(r.Context(), profile)
672
673 s.pages.HxRedirect(w, "/"+user.Did)
674}
675
676func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
677 user := s.oauth.GetUser(r)
678
679 profile, err := db.GetProfile(s.db, user.Did)
680 if err != nil {
681 log.Printf("getting profile data for %s: %s", user.Did, err)
682 }
683
684 s.pages.EditBioFragment(w, pages.EditBioParams{
685 LoggedInUser: user,
686 Profile: profile,
687 })
688}
689
690func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
691 user := s.oauth.GetUser(r)
692
693 profile, err := db.GetProfile(s.db, user.Did)
694 if err != nil {
695 log.Printf("getting profile data for %s: %s", user.Did, err)
696 }
697
698 repos, err := db.GetRepos(s.db, 0, db.FilterEq("did", user.Did))
699 if err != nil {
700 log.Printf("getting repos for %s: %s", user.Did, err)
701 }
702
703 collaboratingRepos, err := db.CollaboratingIn(s.db, user.Did)
704 if err != nil {
705 log.Printf("getting collaborating repos for %s: %s", user.Did, err)
706 }
707
708 allRepos := []pages.PinnedRepo{}
709
710 for _, r := range repos {
711 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
712 allRepos = append(allRepos, pages.PinnedRepo{
713 IsPinned: isPinned,
714 Repo: r,
715 })
716 }
717 for _, r := range collaboratingRepos {
718 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
719 allRepos = append(allRepos, pages.PinnedRepo{
720 IsPinned: isPinned,
721 Repo: r,
722 })
723 }
724
725 s.pages.EditPinsFragment(w, pages.EditPinsParams{
726 LoggedInUser: user,
727 Profile: profile,
728 AllRepos: allRepos,
729 })
730}