Something went wrong. Try again.
Monorepo for Tangled
Something went wrong. Try again.
37 kB · 1305 lines
Go
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306package state
import ( "cmp" "context" "fmt" "net/http" "slices" "strings" "time"
comatproto "github.com/bluesky-social/indigo/api/atproto" "github.com/bluesky-social/indigo/atproto/identity" "github.com/bluesky-social/indigo/atproto/syntax" lexutil "github.com/bluesky-social/indigo/lex/util" "github.com/go-chi/chi/v5" "github.com/gorilla/feeds" "tangled.org/core/api/tangled" "tangled.org/core/appview/cache" "tangled.org/core/appview/db" "tangled.org/core/appview/middleware" "tangled.org/core/appview/models" "tangled.org/core/appview/pages" "tangled.org/core/appview/pagination" "tangled.org/core/appview/searchquery" "tangled.org/core/orm" "tangled.org/core/xrpc")
func (s *State) Profile(w http.ResponseWriter, r *http.Request) { tabVal := r.URL.Query().Get("tab") switch tabVal { case "repos": middleware. Paginate(http.HandlerFunc(s.reposPage)). ServeHTTP(w, r) case "followers": s.followersPage(w, r) case "following": s.followingPage(w, r) case "starred": middleware. Paginate(http.HandlerFunc(s.starredPage)). ServeHTTP(w, r) case "strings": s.stringsPage(w, r) case "vouches": middleware. Paginate(http.HandlerFunc(s.vouchesPage)). ServeHTTP(w, r) default: s.profileOverview(w, r) }}
var profileScripts = map[string]string{ "did:plc:3fwecdnvtcscjnrx2p4n7alz": "/static/profile-fx/orrery.js", "did:plc:qfpnj4og54vl56wngdriaxug": "/static/profile-fx/oppili.js", "did:plc:oxdlsmnvpk2riyyuvq5jtdkd": "/static/profile-fx/wilb.me.js", "did:plc:lrphxvv25aibthe7xoc2eeyy": "/static/profile-fx/kandake.js", "did:plc:vzl336yxfrftoc23ygcqklzr": "/static/profile-fx/gdorsi.bsky.social.js", "did:plc:laqygfbyvnkyuhsuaxmp6ez3": "/static/profile-fx/punchcard-td.js", "did:plc:dfkjiu36xs6ogt7pux7i7o2b": "/static/profile-fx/willow.sh.js", "did:plc:doe7nkqeodssh6uc5jcq5iyw": "/static/profile-fx/luisstd.js", "did:plc:f2ablw5m3ashhpydt6u7h2rx": "/static/profile-fx/chancey.dev.js", "did:plc:4aah6pidgmlp36cvtispnwhu": "/static/profile-fx/matthewlipski.tngl.sh.js", "did:plc:7qubw2z53qzfturlblaozz4a": "/static/profile-fx/mihaizaurus.at.js", "did:plc:xmyx5qvyzd4fm77oehni7pvh": "/static/profile-fx/danschmidt.js",}
func (s *State) profile(r *http.Request) (*pages.ProfileCard, error) { didOrHandle := chi.URLParam(r, "user") if didOrHandle == "" { return nil, fmt.Errorf("empty DID or handle") }
ident, ok := r.Context().Value("resolvedId").(identity.Identity) if !ok { return nil, fmt.Errorf("failed to resolve ID") } did := ident.DID.String()
profile, err := db.GetProfile(s.db, did) if err != nil { return nil, fmt.Errorf("failed to get profile: %w", err) }
hasProfile := profile != nil if !hasProfile { profile = &models.Profile{Did: did} }
repoCount, err := db.CountRepos(s.db, orm.FilterEq("did", did)) if err != nil { return nil, fmt.Errorf("failed to get repo count: %w", err) }
stringCount, err := db.CountStrings(s.db, orm.FilterEq("did", did)) if err != nil { return nil, fmt.Errorf("failed to get string count: %w", err) }
starredCount, err := db.CountStars(s.db, orm.FilterEq("did", did)) if err != nil { return nil, fmt.Errorf("failed to get starred repo count: %w", err) }
followStats, err := db.GetFollowerFollowingCount(s.db, did) if err != nil { return nil, fmt.Errorf("failed to get follower stats: %w", err) }
loggedInUser := s.oauth.GetMultiAccountUser(r) followStatus := models.IsNotFollowing var loggedInDid string var vouchRelationship *models.VouchRelationship
if loggedInUser != nil { followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did) loggedInDid = loggedInUser.Did vouchRelationship, err = db.GetVouchRelationship(s.db, syntax.DID(loggedInUser.Did), syntax.DID(did)) }
showPunchcard := s.shouldShowPunchcard(did, loggedInDid)
var punchcard *models.Punchcard if showPunchcard { now := time.Now() startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC) punchcard, err = db.MakePunchcard( s.db, orm.FilterEq("did", did), orm.FilterGte("date", startOfYear.Format(time.DateOnly)), orm.FilterLte("date", now.Format(time.DateOnly)), ) if err != nil { return nil, fmt.Errorf("failed to get punchcard for %s: %w", did, err) } }
return &pages.ProfileCard{ UserDid: did, HasProfile: hasProfile, Profile: profile, FollowStatus: followStatus, VouchRelationship: vouchRelationship, Stats: pages.ProfileStats{ RepoCount: repoCount, StringCount: stringCount, StarredCount: starredCount, FollowersCount: followStats.Followers, FollowingCount: followStats.Following, }, Punchcard: punchcard, ProfileScript: profileScripts[did], }, nil}
func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "profileHomePage")
profile, err := s.profile(r) if err != nil { l.Error("failed to build profile card", "err", err) s.pages.Error500(w) return } l = l.With("profileDid", profile.UserDid)
repos, err := db.GetRepos( s.db, orm.FilterEq("did", profile.UserDid), ) if err != nil { l.Error("failed to fetch repos", "err", err) }
// filter out ones that are pinned pinnedRepos := []models.Repo{} for i, r := range repos { if profile.Profile.MatchesPinnedRepo(r) { pinnedRepos = append(pinnedRepos, r) } else if profile.Profile.IsPinnedReposEmpty() && i < 4 { pinnedRepos = append(pinnedRepos, r) } }
collaboratingRepos, err := db.CollaboratingIn(s.db, profile.UserDid) if err != nil { l.Error("failed to fetch collaborating repos", "err", err) }
pinnedCollaboratingRepos := []models.Repo{} for _, r := range collaboratingRepos { if profile.Profile.MatchesPinnedRepo(r) { pinnedCollaboratingRepos = append(pinnedCollaboratingRepos, r) } }
timeline, err := db.MakeProfileTimeline(s.db, profile.UserDid) if err != nil { l.Error("failed to create timeline", "err", err) }
err = s.pages.ProfileOverview(w, pages.ProfileOverviewParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Card: profile, Repos: pinnedRepos, CollaboratingRepos: pinnedCollaboratingRepos, ProfileTimeline: timeline, }) if err != nil { l.Error("failed to render template", "err", err) }}
func (s *State) shouldShowPunchcard(targetDid, requesterDid string) bool { l := s.logger.With("helper", "shouldShowPunchcard")
targetPunchcardPreferences, err := db.GetPunchcardPreference(s.db, targetDid) if err != nil { l.Error("failed to get target users punchcard preferences", "err", err) return true }
requesterPunchcardPreferences, err := db.GetPunchcardPreference(s.db, requesterDid) if err != nil { l.Error("failed to get requester users punchcard preferences", "err", err) return true }
showPunchcard := true
// looking at their own profile if targetDid == requesterDid { if targetPunchcardPreferences.HideMine { return false } return true }
if targetPunchcardPreferences.HideMine || requesterPunchcardPreferences.HideOthers { showPunchcard = false } return showPunchcard}
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "reposPage")
profile, err := s.profile(r) if err != nil { l.Error("failed to build profile card", "err", err) s.pages.Error500(w) return } l = l.With("profileDid", profile.UserDid)
params := r.URL.Query() page := pagination.FromContext(r.Context())
query := searchquery.Parse(params.Get("q"))
var language string if lang := cmp.Or(query.Get("language"), query.Get("lang")); lang != nil { language = *lang }
tf := searchquery.ExtractTextFilters(query)
searchOpts := models.RepoSearchOptions{ Keywords: tf.Keywords, Phrases: tf.Phrases, NegatedKeywords: tf.NegatedKeywords, NegatedPhrases: tf.NegatedPhrases, Did: profile.UserDid, Language: language, Page: page, }
var repos []models.Repo var totalRepos int64 loggedInUser := s.oauth.GetMultiAccountUser(r)
if searchOpts.HasSearchFilters() { res, err := s.indexer.Repos.Search(r.Context(), searchOpts) if err != nil { l.Error("failed to search repos", "err", err) s.pages.Error500(w) return }
if len(res.Hits) > 0 { repos, err = db.GetRepos(s.db, orm.FilterIn("id", res.Hits)) if err != nil { l.Error("failed to get repos by IDs", "err", err) s.pages.Error500(w) return }
// sort repos to match search result order (by relevance) repoMap := make(map[int64]models.Repo, len(repos)) for _, repo := range repos { repoMap[repo.Id] = repo } repos = make([]models.Repo, 0, len(res.Hits)) for _, id := range res.Hits { if repo, ok := repoMap[id]; ok { repos = append(repos, repo) } } } totalRepos = int64(res.Total) } else { repos, err = db.GetReposPaginated( s.db, page, orm.FilterEq("did", profile.UserDid), ) if err != nil { l.Error("failed to get repos", "err", err) s.pages.Error500(w) return }
totalRepos, err = db.CountRepos( s.db, orm.FilterEq("did", profile.UserDid), ) if err != nil { l.Error("failed to count repos", "err", err) s.pages.Error500(w) return } }
starStatuses := map[string]bool{} if loggedInUser != nil { repoDids := make([]string, 0, len(repos)) for _, repo := range repos { if repo.RepoDid != "" { repoDids = append(repoDids, repo.RepoDid) } }
starStatuses, err = db.GetStarStatuses(s.db, loggedInUser.Did, repoDids) if err != nil { l.Error("failed to get repo star statuses", "err", err) s.pages.Error500(w) return } }
err = s.pages.ProfileRepos(w, pages.ProfileReposParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Repos: repos, StarStatuses: starStatuses, Card: profile, Page: page, RepoCount: int(totalRepos), FilterQuery: query.String(), }) if err != nil { l.Error("failed to render page", "err", err) }}
func (s *State) starredPage(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "starredPage")
page := pagination.FromContext(r.Context()) l = l.With("page", page)
profile, err := s.profile(r) if err != nil { l.Error("failed to build profile card", "err", err) s.pages.Error500(w) return } l = l.With("profileDid", profile.UserDid)
stars, err := db.GetRepoStars(s.db, page, orm.FilterEq("did", profile.UserDid)) if err != nil { l.Error("failed to get stars", "err", err) s.pages.Error500(w) return } var repos []models.Repo for _, s := range stars { repos = append(repos, *s.Repo) }
err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Repos: repos, Total: int(profile.Stats.StarredCount), Card: profile, Page: page, }) if err != nil { l.Error("failed to render", "err", err) }}
func (s *State) stringsPage(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "stringsPage")
profile, err := s.profile(r) if err != nil { l.Error("failed to build profile card", "err", err) s.pages.Error500(w) return } l = l.With("profileDid", profile.UserDid)
strings, err := db.GetStrings(s.db, 0, orm.FilterEq("did", profile.UserDid)) if err != nil { l.Error("failed to get strings", "err", err) s.pages.Error500(w) return }
err = s.pages.ProfileStrings(w, pages.ProfileStringsParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Strings: strings, Card: profile, })}
func (s *State) vouchesPage(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "vouchesPage")
profile, err := s.profile(r) if err != nil { l.Error("failed to build profile card", "err", err) s.pages.Error500(w) return } l = l.With("profileDid", profile.UserDid)
loggedInUser := s.oauth.GetMultiAccountUser(r) page := pagination.FromContext(r.Context())
var vouches []models.Vouch var vouchCount int if loggedInUser != nil { vouches, err = db.GetNetworkVouchTimeline(s.db, loggedInUser.Did, profile.UserDid, page) if err != nil { l.Error("failed to get vouch timeline", "err", err) s.pages.Error500(w) return } vouchCount, err = db.CountNetworkVouchTimeline(s.db, loggedInUser.Did, profile.UserDid) if err != nil { l.Error("failed to count vouch timeline", "err", err) s.pages.Error500(w) return } }
var suggestions []models.VouchSuggestion if loggedInUser != nil && loggedInUser.Did == profile.UserDid { suggestions, err = db.GetVouchSuggestions(s.db, profile.UserDid, 5) if err != nil { l.Error("failed to get vouch suggestions", "err", err) }
if len(suggestions) > 0 { suggestionDids := make([]syntax.DID, len(suggestions)) for i, s := range suggestions { suggestionDids[i] = syntax.DID(s.Did) } relationships, err := db.GetVouchRelationshipsBatch(s.db, syntax.DID(loggedInUser.Did), suggestionDids) if err != nil { l.Error("failed to get vouch relationships for suggestions", "err", err) } else { for i := range suggestions { suggestions[i].VouchRelationship = relationships[suggestions[i].Did] } } } }
var pullAts, issueAts []syntax.ATURI for _, v := range vouches { for _, ev := range v.Evidences { switch ev.Collection().String() { case tangled.RepoPullNSID: pullAts = append(pullAts, ev) case tangled.RepoIssueNSID: issueAts = append(issueAts, ev) } } }
evidencePulls := make(map[syntax.ATURI]*models.Pull) if len(pullAts) > 0 { pulls, err := db.GetPulls(s.db, orm.FilterIn("at_uri", pullAts)) if err != nil { l.Error("failed to get evidence pulls", "err", err) } else { for _, p := range pulls { evidencePulls[p.AtUri()] = p } } }
evidenceIssues := make(map[syntax.ATURI]*models.Issue) if len(issueAts) > 0 { issues, err := db.GetIssues(s.db, orm.FilterIn("at_uri", issueAts)) if err != nil { l.Error("failed to get evidence issues", "err", err) } else { for i := range issues { evidenceIssues[issues[i].AtUri()] = &issues[i] } } }
err = s.pages.ProfileVouches(w, pages.ProfileVouchesParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Vouches: vouches, Suggestions: suggestions, Card: profile, Page: page, VouchCount: vouchCount, EvidencePulls: evidencePulls, EvidenceIssues: evidenceIssues, }) if err != nil { l.Error("failed to render page", "err", err) }}
type FollowsPageParams struct { Follows []pages.FollowCard Card *pages.ProfileCard}
func (s *State) followPage( r *http.Request, fetchFollows func(db.Execer, string) ([]models.Follow, error), extractDid func(models.Follow) string,) (*FollowsPageParams, error) { l := s.logger.With("handler", "reposPage")
profile, err := s.profile(r) if err != nil { return nil, err } l = l.With("profileDid", profile.UserDid)
loggedInUser := s.oauth.GetMultiAccountUser(r) params := FollowsPageParams{ Card: profile, }
follows, err := fetchFollows(s.db, profile.UserDid) if err != nil { l.Error("failed to fetch follows", "err", err) return ¶ms, err }
if len(follows) == 0 { return ¶ms, nil }
followDids := make([]string, 0, len(follows)) for _, follow := range follows { followDids = append(followDids, extractDid(follow)) }
profiles, err := db.GetProfiles(s.db, orm.FilterIn("did", followDids)) if err != nil { l.Error("failed to get profiles", "followDids", followDids, "err", err) return ¶ms, err }
followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids) if err != nil { l.Error("getting follow counts", "followDids", followDids, "err", err) }
loggedInUserFollowing := make(map[string]struct{}) if loggedInUser != nil { following, err := db.GetFollowing(s.db, loggedInUser.Did) if err != nil { l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Did) return ¶ms, err } loggedInUserFollowing = make(map[string]struct{}, len(following)) for _, follow := range following { loggedInUserFollowing[follow.SubjectDid] = struct{}{} } }
followCards := make([]pages.FollowCard, len(follows)) for i, did := range followDids { followStats := followStatsMap[did] followStatus := models.IsNotFollowing if _, exists := loggedInUserFollowing[did]; exists { followStatus = models.IsFollowing } else if loggedInUser != nil && loggedInUser.Did == did { followStatus = models.IsSelf }
var profile *models.Profile if p, exists := profiles[did]; exists { profile = p } else { profile = &models.Profile{} profile.Did = did } followCards[i] = pages.FollowCard{ BaseParams: pages.BaseParamsFromContext(r.Context()), UserDid: did, FollowStatus: followStatus, FollowersCount: followStats.Followers, FollowingCount: followStats.Following, Profile: profile, } }
params.Follows = followCards
return ¶ms, nil}
func (s *State) followersPage(w http.ResponseWriter, r *http.Request) { followPage, err := s.followPage(r, db.GetFollowers, func(f models.Follow) string { return f.UserDid }) if err != nil { s.pages.Notice(w, "all-followers", "Failed to load followers") return }
s.pages.ProfileFollowers(w, pages.ProfileFollowersParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Followers: followPage.Follows, Card: followPage.Card, })}
func (s *State) followingPage(w http.ResponseWriter, r *http.Request) { followPage, err := s.followPage(r, db.GetFollowing, func(f models.Follow) string { return f.SubjectDid }) if err != nil { s.pages.Notice(w, "all-following", "Failed to load following") return }
s.pages.ProfileFollowing(w, pages.ProfileFollowingParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Following: followPage.Follows, Card: followPage.Card, })}
func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) { ident, ok := r.Context().Value("resolvedId").(identity.Identity) if !ok { s.pages.Error404(w) return }
feed, err := s.getProfileFeed(r.Context(), &ident) if err != nil { s.pages.Error500(w) return }
if feed == nil { return }
atom, err := feed.ToAtom() if err != nil { s.pages.Error500(w) return }
w.Header().Set("content-type", "application/atom+xml") w.Write([]byte(atom))}
func (s *State) getProfileFeed(ctx context.Context, id *identity.Identity) (*feeds.Feed, error) { timeline, err := db.MakeProfileTimeline(s.db, id.DID.String()) if err != nil { return nil, err }
author := &feeds.Author{ Name: fmt.Sprintf("@%s", id.Handle), }
feed := feeds.Feed{ Title: fmt.Sprintf("%s's timeline", author.Name), Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.BaseUrl(), id.Handle), Type: "text/html", Rel: "alternate"}, Items: make([]*feeds.Item, 0), Updated: time.UnixMilli(0), Author: author, }
for _, byMonth := range timeline.ByMonth { if err := s.addPullRequestItems(ctx, &feed, byMonth.PullEvents.Items, author); err != nil { return nil, err } if err := s.addIssueItems(ctx, &feed, byMonth.IssueEvents.Items, author); err != nil { return nil, err } if err := s.addRepoItems(ctx, &feed, byMonth.RepoEvents, author); err != nil { return nil, err } }
slices.SortFunc(feed.Items, func(a *feeds.Item, b *feeds.Item) int { return int(b.Created.UnixMilli()) - int(a.Created.UnixMilli()) })
if len(feed.Items) > 0 { feed.Updated = feed.Items[0].Created }
return &feed, nil}
func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*models.Pull, author *feeds.Author) error { for _, pull := range pulls { owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did) if err != nil { return err }
// Add pull request creation item feed.Items = append(feed.Items, s.createPullRequestItem(pull, owner, author)) } return nil}
func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*models.Issue, author *feeds.Author) error { for _, issue := range issues { owner, err := s.idResolver.ResolveIdent(ctx, issue.Repo.Did) if err != nil { return err }
feed.Items = append(feed.Items, s.createIssueItem(issue, owner, author)) } return nil}
func (s *State) addRepoItems(ctx context.Context, feed *feeds.Feed, repos []models.RepoEvent, author *feeds.Author) error { for _, repo := range repos { item, err := s.createRepoItem(ctx, repo, author) if err != nil { return err } feed.Items = append(feed.Items, item) } return nil}
func (s *State) createPullRequestItem(pull *models.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item { return &feeds.Item{ Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name), 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"}, Created: pull.Created, Author: author, }}
func (s *State) createIssueItem(issue *models.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item { return &feeds.Item{ Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Repo.Name), 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"}, Created: issue.Created, Author: author, }}
func (s *State) createRepoItem(ctx context.Context, repo models.RepoEvent, author *feeds.Author) (*feeds.Item, error) { var title string if repo.Source != nil { sourceOwner, err := s.idResolver.ResolveIdent(ctx, repo.Source.Did) if err != nil { return nil, err } title = fmt.Sprintf("%s forked repository @%s/%s to '%s'", author.Name, sourceOwner.Handle, repo.Source.Name, repo.Repo.Name) } else { title = fmt.Sprintf("%s created repository '%s'", author.Name, repo.Repo.Name) }
return &feeds.Item{ Title: title, 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 Created: repo.Repo.Created, Author: author, }, nil}
func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "UpdateProfileBio") user := s.oauth.GetMultiAccountUser(r)
err := r.ParseForm() if err != nil { l.Error("invalid profile update form", "err", err) s.pages.Notice(w, "update-profile", "Invalid form.") return }
profile, err := db.GetProfile(s.db, user.Did) if err != nil { l.Error("getting profile data", "did", user.Did, "err", err) } if profile == nil { profile = &models.Profile{Did: user.Did} }
profile.Description = r.FormValue("description") profile.IncludeBluesky = r.FormValue("includeBluesky") == "on" profile.Location = r.FormValue("location") profile.Pronouns = r.FormValue("pronouns") rawPreferredHandle := strings.TrimSpace(r.FormValue("preferredHandle")) if rawPreferredHandle != "" { h, err := syntax.ParseHandle(rawPreferredHandle) if err != nil { s.pages.Notice(w, "update-profile", "Invalid handle format.") return }
ident, err := s.idResolver.ResolveIdent(r.Context(), user.Did) if err != nil || !slices.Contains(ident.AlsoKnownAs, "at://"+rawPreferredHandle) { s.pages.Notice(w, "update-profile", "Handle not found in your DID document.") return } profile.PreferredHandle = h } else { profile.PreferredHandle = "" }
var links [5]string for i := range 5 { iLink := r.FormValue(fmt.Sprintf("link%d", i)) links[i] = iLink } profile.Links = links
// Parse stats (exactly 2) stat0 := r.FormValue("stat0") stat1 := r.FormValue("stat1")
profile.Stats[0].Kind = models.ParseVanityStatKind(stat0) profile.Stats[1].Kind = models.ParseVanityStatKind(stat1)
if err := db.ValidateProfile(s.db, profile); err != nil { l.Error("invalid profile", "err", err) s.pages.Notice(w, "update-profile", err.Error()) return }
s.updateProfile(profile, w, r)}
func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "UpdateProfilePins") user := s.oauth.GetMultiAccountUser(r)
err := r.ParseForm() if err != nil { l.Error("invalid profile update form", "err", err) s.pages.Notice(w, "update-profile", "Invalid form.") return }
profile, err := db.GetProfile(s.db, user.Did) if err != nil { l.Error("getting profile data", "did", user.Did, "err", err) } if profile == nil { profile = &models.Profile{Did: user.Did} }
i := 0 var pinnedRepos [6]string for key, values := range r.Form { if i >= 6 { l.Warn("too many pinned repos") s.pages.Notice(w, "update-profile", "Only 6 repositories can be pinned at a time.") return } if strings.HasPrefix(key, "pinnedRepo") && len(values) > 0 && values[0] != "" && i < 6 { pinnedRepos[i] = values[0] i++ } } profile.PinnedRepos = pinnedRepos
s.updateProfile(profile, w, r)}
func (s *State) updateProfile(profile *models.Profile, w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "updateProfile") user := s.oauth.GetMultiAccountUser(r)
client, err := s.oauth.AuthorizedClient(r) if err != nil { l.Error("failed to get authorized client", "err", err) s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.") return }
var pinnedRepoStrings []string for _, r := range profile.PinnedRepos { if r != "" { pinnedRepoStrings = append(pinnedRepoStrings, r) } }
var vanityStats []string for _, v := range profile.Stats { vanityStats = append(vanityStats, string(v.Kind)) }
ex, _ := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self") var cid *string var existingAvatar *lexutil.LexBlob if ex != nil { cid = ex.Cid if rec, ok := ex.Value.Val.(*tangled.ActorProfile); ok { existingAvatar = rec.Avatar } }
_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ Collection: tangled.ActorProfileNSID, Repo: user.Did, Rkey: "self", Record: &lexutil.LexiconTypeDecoder{ Val: &tangled.ActorProfile{ Avatar: existingAvatar, Bluesky: profile.IncludeBluesky, Description: &profile.Description, Links: profile.Links[:], Location: &profile.Location, PinnedRepositories: pinnedRepoStrings, Stats: vanityStats[:], Pronouns: &profile.Pronouns, PreferredHandle: (*string)(&profile.PreferredHandle), }}, SwapRecord: cid, }) if err != nil { l.Error("failed to update profile on PDS", "err", err) s.pages.Notice(w, "update-profile", "Failed to update PDS, try again later.") return }
if err := db.UpsertProfile(s.db, profile); err != nil { // db failed, but PDS operation succeed. // log error and continue l.Error("failed to update profile in DB", "err", err) }
if s.rdb != nil { ctx := r.Context() pipe := s.rdb.Pipeline() didKey := fmt.Sprintf(cache.PreferredHandleByDid, profile.Did) if profile.PreferredHandle != "" { pipe.Set(ctx, didKey, string(profile.PreferredHandle), cache.PreferredHandleTTL) pipe.Set(ctx, fmt.Sprintf(cache.PreferredHandleByHandle, string(profile.PreferredHandle)), profile.Did, cache.PreferredHandleTTL) } else { pipe.Del(ctx, didKey) } if _, execErr := pipe.Exec(ctx); execErr != nil { l.Warn("failed to update preferred handle cache", "err", execErr) } }
s.notifier.UpdateProfile(r.Context(), profile)
s.pages.HxRedirect(w, "/"+user.Did)}
func (s *State) ProfilePopover(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "ProfilePopover")
did := r.URL.Query().Get("did") if did == "" { l.Warn("missing did param") w.WriteHeader(http.StatusBadRequest) return }
profile, err := db.GetProfile(s.db, did) if err != nil { l.Error("failed to get profile", "did", did, "err", err) w.WriteHeader(http.StatusInternalServerError) return } if profile == nil { profile = &models.Profile{Did: did} }
followStats, err := db.GetFollowerFollowingCount(s.db, did) if err != nil { l.Error("failed to get follower stats", "did", did, "err", err) w.WriteHeader(http.StatusInternalServerError) return }
loggedInUser := s.oauth.GetMultiAccountUser(r) followStatus := models.IsNotFollowing var vouchRelationship *models.VouchRelationship
if loggedInUser != nil { followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did) vouchRelationship, _ = db.GetVouchRelationship(s.db, syntax.DID(loggedInUser.Did), syntax.DID(did)) }
s.pages.ProfilePopoverFragment(w, pages.ProfilePopoverParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), UserDid: did, Profile: profile, FollowStatus: followStatus, VouchRelationship: vouchRelationship, Stats: pages.ProfilePopoverStats{ FollowersCount: followStats.Followers, FollowingCount: followStats.Following, }, })}
func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "EditBioFragment") user := s.oauth.GetMultiAccountUser(r)
profile, err := db.GetProfile(s.db, user.Did) if err != nil { l.Error("getting profile data", "did", user.Did, "err", err) } if profile == nil { profile = &models.Profile{Did: user.Did} }
var alsoKnownAs []string ident, err := s.idResolver.ResolveIdent(r.Context(), user.Did) if err == nil { alsoKnownAs = ident.AlsoKnownAs }
s.pages.EditBioFragment(w, pages.EditBioParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Profile: profile, AlsoKnownAs: alsoKnownAs, })}
func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "EditPinsFragment") user := s.oauth.GetMultiAccountUser(r)
profile, err := db.GetProfile(s.db, user.Did) if err != nil { l.Error("getting profile data", "did", user.Did, "err", err) } if profile == nil { profile = &models.Profile{Did: user.Did} }
repos, err := db.GetRepos(s.db, orm.FilterEq("did", user.Did)) if err != nil { l.Error("getting repos", "did", user.Did, "err", err) }
collaboratingRepos, err := db.CollaboratingIn(s.db, user.Did) if err != nil { l.Error("getting collaborating repos", "did", user.Did, "err", err) }
allRepos := []pages.PinnedRepo{}
for _, r := range repos { allRepos = append(allRepos, pages.PinnedRepo{ IsPinned: profile.MatchesPinnedRepo(r), Repo: r, }) } for _, r := range collaboratingRepos { allRepos = append(allRepos, pages.PinnedRepo{ IsPinned: profile.MatchesPinnedRepo(r), Repo: r, }) }
s.pages.EditPinsFragment(w, pages.EditPinsParams{ BaseParams: pages.BaseParamsFromContext(r.Context()), Profile: profile, AllRepos: allRepos, })}
func (s *State) UploadProfileAvatar(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "UploadProfileAvatar") user := s.oauth.GetMultiAccountUser(r) l = l.With("did", user.Did)
// Parse multipart form (10MB max) if err := r.ParseMultipartForm(10 << 20); err != nil { l.Error("failed to parse form", "err", err) s.pages.Notice(w, "avatar-error", "Failed to parse form") return }
file, header, err := r.FormFile("avatar") if err != nil { l.Error("failed to read avatar file", "err", err) s.pages.Notice(w, "avatar-error", "Failed to read avatar file") return } defer file.Close()
if header.Size > 5000000 { l.Warn("avatar file too large", "size", header.Size) s.pages.Notice(w, "avatar-error", "Avatar file too large (max 5MB)") return }
contentType := header.Header.Get("Content-Type") if contentType != "image/png" && contentType != "image/jpeg" { l.Warn("invalid image type", "contentType", contentType) s.pages.Notice(w, "avatar-error", "Invalid image type (only PNG and JPEG allowed)") return }
client, err := s.oauth.AuthorizedClient(r) if err != nil { l.Error("failed to get PDS client", "err", err) s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS") return }
uploadBlobResp, err := xrpc.RepoUploadBlob(r.Context(), client, file, header.Header.Get("Content-Type")) if err != nil { l.Error("failed to upload avatar blob", "err", err) s.pages.Notice(w, "avatar-error", "Failed to upload avatar to your PDS") return }
l.Info("uploaded avatar blob", "cid", uploadBlobResp.Blob.Ref.String())
// get current profile record from PDS to get its CID for swap getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self") if err != nil { l.Error("failed to get current profile record", "err", err) s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS") return }
var profileRecord *tangled.ActorProfile if getRecordResp.Value != nil { if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok { profileRecord = val } else { l.Warn("profile record type assertion failed, creating new record") profileRecord = &tangled.ActorProfile{} } } else { l.Warn("no existing profile record, creating new record") profileRecord = &tangled.ActorProfile{} }
profileRecord.Avatar = uploadBlobResp.Blob
_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ Collection: tangled.ActorProfileNSID, Repo: user.Did, Rkey: "self", Record: &lexutil.LexiconTypeDecoder{Val: profileRecord}, SwapRecord: getRecordResp.Cid, })
if err != nil { l.Error("failed to update profile record", "err", err) s.pages.Notice(w, "avatar-error", "Failed to update profile on your PDS") return }
l.Info("successfully updated profile with avatar")
profile, err := db.GetProfile(s.db, user.Did) if err != nil { l.Warn("getting profile data from DB", "err", err) } if profile == nil { profile = &models.Profile{Did: user.Did} } profile.Avatar = uploadBlobResp.Blob.Ref.String()
err = db.UpsertProfile(s.db, profile) if err != nil { l.Error("failed to update profile in DB", "err", err) s.pages.HxRefresh(w) w.WriteHeader(http.StatusOK) return }
s.pages.HxRedirect(w, r.Header.Get("Referer"))}
func (s *State) RemoveProfileAvatar(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "RemoveProfileAvatar") user := s.oauth.GetMultiAccountUser(r) l = l.With("did", user.Did)
client, err := s.oauth.AuthorizedClient(r) if err != nil { l.Error("failed to get PDS client", "err", err) s.pages.Notice(w, "avatar-error", "Failed to connect to your PDS") return }
getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self") if err != nil { l.Error("failed to get current profile record", "err", err) s.pages.Notice(w, "avatar-error", "Failed to get current profile from your PDS") return }
var profileRecord *tangled.ActorProfile if getRecordResp.Value != nil { if val, ok := getRecordResp.Value.Val.(*tangled.ActorProfile); ok { profileRecord = val } else { l.Warn("profile record type assertion failed") profileRecord = &tangled.ActorProfile{} } } else { l.Warn("no existing profile record") profileRecord = &tangled.ActorProfile{} }
profileRecord.Avatar = nil
_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ Collection: tangled.ActorProfileNSID, Repo: user.Did, Rkey: "self", Record: &lexutil.LexiconTypeDecoder{Val: profileRecord}, SwapRecord: getRecordResp.Cid, })
if err != nil { l.Error("failed to update profile record", "err", err) s.pages.Notice(w, "avatar-error", "Failed to remove avatar from your PDS") return }
l.Info("successfully removed avatar from PDS")
profile, err := db.GetProfile(s.db, user.Did) if err != nil { l.Warn("getting profile data from DB", "err", err) } if profile == nil { profile = &models.Profile{Did: user.Did} } profile.Avatar = ""
err = db.UpsertProfile(s.db, profile) if err != nil { l.Error("failed to update profile in DB", "err", err) s.pages.HxRefresh(w) w.WriteHeader(http.StatusOK) return }
s.pages.HxRedirect(w, r.Header.Get("Referer"))}
func (s *State) UpdateProfilePunchcardSetting(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "UpdateProfilePunchcardSetting") err := r.ParseForm() if err != nil { l.Error("invalid profile update form", "err", err) return } user := s.oauth.GetMultiAccountUser(r)
hideOthers := false hideMine := false
if r.Form.Get("hideMine") == "on" { hideMine = true } if r.Form.Get("hideOthers") == "on" { hideOthers = true }
err = db.UpsertPunchcardPreference(s.db, user.Did, hideMine, hideOthers) if err != nil { l.Error("failed to update punchcard preferences", "err", err) return }
s.pages.HxRefresh(w)}