···
"github.com/gorilla/feeds"
"tangled.sh/tangled.sh/core/api/tangled"
"tangled.sh/tangled.sh/core/appview/db"
-
"tangled.sh/tangled.sh/core/appview/oauth"
"tangled.sh/tangled.sh/core/appview/pages"
func (s *State) Profile(w http.ResponseWriter, r *http.Request) {
tabVal := r.URL.Query().Get("tab")
-
s.profileHomePage(w, r)
-
type ProfilePageParams struct {
-
LoggedInUser *oauth.User
-
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) *ProfilePageParams {
didOrHandle := chi.URLParam(r, "user")
-
http.Error(w, "bad request", http.StatusBadRequest)
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
-
log.Printf("malformed middleware")
-
w.WriteHeader(http.StatusInternalServerError)
did := ident.DID.String()
profile, err := db.GetProfile(s.db, did)
-
log.Printf("getting profile data for %s: %s", did, err)
followStats, err := db.GetFollowerFollowingCount(s.db, did)
-
log.Printf("getting follow stats for %s: %s", did, err)
loggedInUser := s.oauth.GetUser(r)
···
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
-
return &ProfilePageParams{
-
LoggedInUser: loggedInUser,
-
Card: pages.ProfileCard{
-
UserHandle: ident.Handle.String(),
-
FollowStatus: followStatus,
-
FollowersCount: followStats.Followers,
-
FollowingCount: followStats.Following,
-
func (s *State) profileHomePage(w http.ResponseWriter, r *http.Request) {
-
pageWithProfile := s.profilePage(w, r)
-
if pageWithProfile == nil {
-
id := pageWithProfile.Id
repos, err := db.GetRepos(
-
db.FilterEq("did", id.DID),
-
log.Printf("getting repos for %s: %s", id.DID, err)
-
profile := pageWithProfile.Card.Profile
// filter out ones that are pinned
pinnedRepos := []db.Repo{}
for i, r := range repos {
// if this is a pinned repo, add it
-
if slices.Contains(profile.PinnedRepos[:], r.RepoAt()) {
pinnedRepos = append(pinnedRepos, r)
// if there are no saved pins, add the first 4 repos
-
if profile.IsPinnedReposEmpty() && i < 4 {
pinnedRepos = append(pinnedRepos, r)
-
collaboratingRepos, err := db.CollaboratingIn(s.db, id.DID.String())
-
log.Printf("getting collaborating repos for %s: %s", id.DID, err)
pinnedCollaboratingRepos := []db.Repo{}
for _, r := range collaboratingRepos {
// if this is a pinned repo, add it
-
if slices.Contains(profile.PinnedRepos[:], r.RepoAt()) {
pinnedCollaboratingRepos = append(pinnedCollaboratingRepos, r)
-
timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())
-
log.Printf("failed to create profile timeline for %s: %s", id.DID, err)
-
var didsToResolve []string
-
for _, r := range collaboratingRepos {
-
didsToResolve = append(didsToResolve, r.Did)
-
for _, byMonth := range timeline.ByMonth {
-
for _, pe := range byMonth.PullEvents.Items {
-
didsToResolve = append(didsToResolve, pe.Repo.Did)
-
for _, ie := range byMonth.IssueEvents.Items {
-
didsToResolve = append(didsToResolve, ie.Metadata.Repo.Did)
-
for _, re := range byMonth.RepoEvents {
-
didsToResolve = append(didsToResolve, re.Repo.Did)
-
didsToResolve = append(didsToResolve, re.Source.Did)
-
startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
-
punchcard, err := db.MakePunchcard(
-
db.FilterEq("did", id.DID),
-
db.FilterGte("date", startOfYear.Format(time.DateOnly)),
-
db.FilterLte("date", now.Format(time.DateOnly)),
-
log.Println("failed to get punchcard for did", "did", id.DID, "err", err)
-
s.pages.ProfileHomePage(w, pages.ProfileHomePageParams{
-
LoggedInUser: pageWithProfile.LoggedInUser,
-
CollaboratingRepos: pinnedCollaboratingRepos,
-
Card: pageWithProfile.Card,
-
ProfileTimeline: timeline,
-
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
-
pageWithProfile := s.profilePage(w, r)
-
if pageWithProfile == nil {
-
id := pageWithProfile.Id
repos, err := db.GetRepos(
-
db.FilterEq("did", id.DID),
-
log.Printf("getting repos for %s: %s", id.DID, err)
-
s.pages.ReposPage(w, pages.ReposPageParams{
-
LoggedInUser: pageWithProfile.LoggedInUser,
-
Card: pageWithProfile.Card,
type FollowsPageParams struct {
-
LoggedInUser *oauth.User
-
Follows []pages.FollowCard
-
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) (FollowsPageParams, error) {
-
pageWithProfile := s.profilePage(w, r)
-
if pageWithProfile == nil {
-
return FollowsPageParams{}, nil
-
id := pageWithProfile.Id
-
loggedInUser := pageWithProfile.LoggedInUser
-
follows, err := fetchFollows(s.db, id.DID.String())
-
log.Printf("getting followers for %s: %s", id.DID, err)
-
return FollowsPageParams{}, err
-
return FollowsPageParams{
-
LoggedInUser: loggedInUser,
-
Follows: []pages.FollowCard{},
-
Card: pageWithProfile.Card,
followDids := make([]string, 0, len(follows))
···
profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))
-
log.Printf("getting profile for %s: %s", followDids, err)
-
return FollowsPageParams{}, err
followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)
···
log.Printf("getting follow counts for %s: %s", followDids, err)
-
var loggedInUserFollowing map[string]struct{}
following, err := db.GetFollowing(s.db, loggedInUser.Did)
-
return FollowsPageParams{}, err
-
if len(following) > 0 {
-
loggedInUserFollowing = make(map[string]struct{}, len(following))
-
for _, follow := range following {
-
loggedInUserFollowing[follow.SubjectDid] = struct{}{}
-
followCards := make([]pages.FollowCard, 0, len(follows))
-
for _, did := range followDids {
-
followStats, exists := followStatsMap[did]
-
followStats = db.FollowStats{}
followStatus := db.IsNotFollowing
-
if loggedInUserFollowing != nil {
-
if _, exists := loggedInUserFollowing[did]; exists {
-
followStatus = db.IsFollowing
-
} else if loggedInUser.Did == did {
-
followStatus = db.IsSelf
if p, exists := profiles[did]; exists {
···
-
followCards = append(followCards, pages.FollowCard{
FollowStatus: followStatus,
FollowersCount: followStats.Followers,
FollowingCount: followStats.Following,
-
return FollowsPageParams{
-
LoggedInUser: loggedInUser,
-
Card: pageWithProfile.Card,
func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {
-
followPage, err := s.followPage(w, r, db.GetFollowers, func(f db.Follow) string { return f.UserDid })
s.pages.Notice(w, "all-followers", "Failed to load followers")
-
s.pages.FollowersPage(w, pages.FollowersPageParams{
-
LoggedInUser: followPage.LoggedInUser,
Followers: followPage.Follows,
func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {
-
followPage, err := s.followPage(w, r, db.GetFollowing, func(f db.Follow) string { return f.SubjectDid })
s.pages.Notice(w, "all-following", "Failed to load following")
-
s.pages.FollowingPage(w, pages.FollowingPageParams{
-
LoggedInUser: followPage.LoggedInUser,
Following: followPage.Follows,
···
"github.com/gorilla/feeds"
"tangled.sh/tangled.sh/core/api/tangled"
"tangled.sh/tangled.sh/core/appview/db"
+
// "tangled.sh/tangled.sh/core/appview/oauth"
"tangled.sh/tangled.sh/core/appview/pages"
func (s *State) Profile(w http.ResponseWriter, r *http.Request) {
tabVal := r.URL.Query().Get("tab")
+
s.profileOverview(w, r)
+
func (s *State) profile(r *http.Request) (*pages.ProfileCard, error) {
didOrHandle := chi.URLParam(r, "user")
+
return nil, fmt.Errorf("empty DID or handle")
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
+
return nil, fmt.Errorf("failed to resolve ID")
did := ident.DID.String()
profile, err := db.GetProfile(s.db, did)
+
return nil, fmt.Errorf("failed to get profile: %w", err)
followStats, err := db.GetFollowerFollowingCount(s.db, did)
+
return nil, fmt.Errorf("failed to get follower stats: %w", err)
loggedInUser := s.oauth.GetUser(r)
···
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
+
startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
+
punchcard, err := db.MakePunchcard(
+
db.FilterEq("did", did),
+
db.FilterGte("date", startOfYear.Format(time.DateOnly)),
+
db.FilterLte("date", now.Format(time.DateOnly)),
+
return nil, fmt.Errorf("failed to get punchcard for %s: %w", did, err)
+
return &pages.ProfileCard{
+
UserHandle: ident.Handle.String(),
+
FollowStatus: followStatus,
+
FollowersCount: followStats.Followers,
+
FollowingCount: followStats.Following,
+
func (s *State) profileOverview(w http.ResponseWriter, r *http.Request) {
+
l := s.logger.With("handler", "profileHomePage")
+
profile, err := s.profile(r)
+
l.Error("failed to build profile card", "err", err)
+
l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
repos, err := db.GetRepos(
+
db.FilterEq("did", profile.UserDid),
+
l.Error("failed to fetch repos", "err", err)
// filter out ones that are pinned
pinnedRepos := []db.Repo{}
for i, r := range repos {
// if this is a pinned repo, add it
+
if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
pinnedRepos = append(pinnedRepos, r)
// if there are no saved pins, add the first 4 repos
+
if profile.Profile.IsPinnedReposEmpty() && i < 4 {
pinnedRepos = append(pinnedRepos, r)
+
collaboratingRepos, err := db.CollaboratingIn(s.db, profile.UserDid)
+
l.Error("failed to fetch collaborating repos", "err", err)
pinnedCollaboratingRepos := []db.Repo{}
for _, r := range collaboratingRepos {
// if this is a pinned repo, add it
+
if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
pinnedCollaboratingRepos = append(pinnedCollaboratingRepos, r)
+
timeline, err := db.MakeProfileTimeline(s.db, profile.UserDid)
+
l.Error("failed to create timeline", "err", err)
+
s.pages.ProfileOverview(w, pages.ProfileOverviewParams{
+
LoggedInUser: s.oauth.GetUser(r),
+
CollaboratingRepos: pinnedCollaboratingRepos,
+
ProfileTimeline: timeline,
+
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
+
l := s.logger.With("handler", "reposPage")
+
profile, err := s.profile(r)
+
l.Error("failed to build profile card", "err", err)
+
l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
+
repos, err := db.GetRepos(
+
db.FilterEq("did", profile.UserDid),
+
l.Error("failed to get repos", "err", err)
+
err = s.pages.ProfileRepos(w, pages.ProfileReposParams{
+
LoggedInUser: s.oauth.GetUser(r),
+
func (s *State) starredPage(w http.ResponseWriter, r *http.Request) {
+
l := s.logger.With("handler", "starredPage")
+
profile, err := s.profile(r)
+
l.Error("failed to build profile card", "err", err)
+
l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
+
stars, err := db.GetStars(s.db, 0, db.FilterEq("starred_by_did", profile.UserDid))
+
l.Error("failed to get stars", "err", err)
+
for _, s := range stars {
+
repoAts = append(repoAts, string(s.RepoAt))
repos, err := db.GetRepos(
+
db.FilterIn("at_uri", repoAts),
+
l.Error("failed to get repos", "err", err)
+
err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{
+
LoggedInUser: s.oauth.GetUser(r),
type FollowsPageParams struct {
+
Follows []pages.FollowCard
+
Card *pages.ProfileCard
+
func (s *State) followPage(
+
fetchFollows func(db.Execer, string) ([]db.Follow, error),
+
extractDid func(db.Follow) string,
+
) (*FollowsPageParams, error) {
+
l := s.logger.With("handler", "reposPage")
+
profile, err := s.profile(r)
+
l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
+
loggedInUser := s.oauth.GetUser(r)
+
follows, err := fetchFollows(s.db, profile.UserDid)
+
l.Error("failed to fetch follows", "err", err)
followDids := make([]string, 0, len(follows))
···
profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))
+
l.Error("failed to get profiles", "followDids", followDids, "err", err)
followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)
···
log.Printf("getting follow counts for %s: %s", followDids, err)
+
loggedInUserFollowing := make(map[string]struct{})
following, err := db.GetFollowing(s.db, loggedInUser.Did)
+
l.Error("failed to get follow list", "err", err, "loggedInUser", loggedInUser.Did)
+
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 := db.IsNotFollowing
+
if _, exists := loggedInUserFollowing[did]; exists {
+
followStatus = db.IsFollowing
+
} else if loggedInUser.Did == did {
+
followStatus = db.IsSelf
if p, exists := profiles[did]; exists {
···
+
followCards[i] = pages.FollowCard{
FollowStatus: followStatus,
FollowersCount: followStats.Followers,
FollowingCount: followStats.Following,
+
return &FollowsPageParams{
func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {
+
followPage, err := s.followPage(r, db.GetFollowers, func(f db.Follow) string { return f.UserDid })
s.pages.Notice(w, "all-followers", "Failed to load followers")
+
s.pages.ProfileFollowers(w, pages.ProfileFollowersParams{
+
LoggedInUser: s.oauth.GetUser(r),
Followers: followPage.Follows,
func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {
+
followPage, err := s.followPage(r, db.GetFollowing, func(f db.Follow) string { return f.SubjectDid })
s.pages.Notice(w, "all-following", "Failed to load following")
+
s.pages.ProfileFollowing(w, pages.ProfileFollowingParams{
+
LoggedInUser: s.oauth.GetUser(r),
Following: followPage.Follows,
oppi.li