Monorepo for Tangled
Something went wrong. Try again.
Go
at commit-links
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364package state
import ( "cmp" "context" "errors" "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} }
isTangledUser, err := db.IsTangledUser(s.db, did) if err != nil { return nil, fmt.Errorf("failed to determine tangled user status: %w", err) }
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, IsTangledUser: isTangledUser, 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")
if err := r.ParseForm(); err != nil { l.Error("invalid profile update form", "err", err) s.pages.Notice(w, "update-profile", "Invalid form.") return }
profile, err := s.bioFormToProfile(r) if err != nil { s.pages.Notice(w, "update-profile", err.Error()) return }
s.updateProfile(profile, w, r)}
// bioFormToProfile builds a validated Profile from an form, callers must have// called r.ParseForm.func (s *State) bioFormToProfile(r *http.Request) (*models.Profile, error) { user := s.oauth.GetMultiAccountUser(r)
profile, err := db.GetProfile(s.db, user.Did) if err != nil { s.logger.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 { return nil, errors.New("Invalid handle format.") }
ident, err := s.idResolver.ResolveIdent(r.Context(), user.Did) if err != nil || !slices.Contains(ident.AlsoKnownAs, "at://"+rawPreferredHandle) { return nil, errors.New("Handle not found in your DID document.") } profile.PreferredHandle = h } else { profile.PreferredHandle = "" }
var links [5]string for i := range 5 { links[i] = r.FormValue(fmt.Sprintf("link%d", i)) } profile.Links = links
// Parse stats (exactly 2) profile.Stats[0].Kind = models.ParseVanityStatKind(r.FormValue("stat0")) profile.Stats[1].Kind = models.ParseVanityStatKind(r.FormValue("stat1"))
if err := db.ValidateProfile(s.db, profile); err != nil { s.logger.Error("invalid profile", "err", err) return nil, err }
return profile, nil}
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) { user := s.oauth.GetMultiAccountUser(r)
if err := s.writeProfile(r, profile); err != nil { s.logger.With("handler", "updateProfile").Error("failed to write profile", "err", err) s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.") return }
s.pages.HxRedirect(w, "/"+user.Did)}
// writeProfile persists a profile to the PDS and local DB and updates caches.// It is shared by the profile settings handler and the onboarding flow; the// response (notice/redirect) is left to the caller.func (s *State) writeProfile(r *http.Request, profile *models.Profile) error { user := s.oauth.GetMultiAccountUser(r) l := s.logger.With("handler", "writeProfile")
client, err := s.oauth.AuthorizedClient(r) if err != nil { return fmt.Errorf("failed to get authorized client: %w", err) }
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 { return fmt.Errorf("failed to update profile on PDS: %w", err) }
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 { s.logger.Warn("failed to update preferred handle cache", "err", execErr) } }
s.notifier.UpdateProfile(r.Context(), profile)
return nil}
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. A new user // (e.g. mid-onboarding) may not have a profile record yet; treat any error // as "no existing record" and create a fresh one with no swap. getRecordResp, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.ActorProfileNSID, user.Did, "self")
var profileRecord *tangled.ActorProfile var swapCid *string switch { case err != nil: l.Warn("no existing profile record, creating new record", "err", err) profileRecord = &tangled.ActorProfile{} case 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{} } swapCid = getRecordResp.Cid default: l.Warn("no existing profile record, creating new record") profileRecord = &tangled.ActorProfile{} swapCid = getRecordResp.Cid }
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: swapCid, })
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 }
// inline uploads (e.g. the onboarding step) manage their own preview // client-side; skip the full reload so unsaved form fields aren't cleared. if r.FormValue("inline") == "true" { 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)}
func (s *State) UpdateProfileThemeSetting(w http.ResponseWriter, r *http.Request) { l := s.logger.With("handler", "UpdateProfileThemeSetting") err := r.ParseForm() if err != nil { l.Error("invalid profile update form", "err", err) return } user := s.oauth.GetMultiAccountUser(r)
theme := r.Form.Get("theme") if theme != "auto" && theme != "light" && theme != "dark" { l.Error("invalid theme value", "theme", theme) return }
err = db.UpsertThemePreference(s.db, user.Did, models.ThemePreference(theme)) if err != nil { l.Error("failed to update theme preferences", "err", err) return }
s.pages.HxRefresh(w)}