appview: state: dedup profile pages #504

···

       
407
       
 
       
	return p.execute("repo/fork", w, params)

     

       
408
       
 
       
}

     

       
409
       
 
       


     

       
0
       
 
       

     

       
410
       
-
       
type ProfileHomePageParams struct {

     

       
411
       
 
       
	LoggedInUser       *oauth.User

     

       
412
       
 
       
	Repos              []db.Repo

     

       
413
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
426
       
 
       
	Profile *db.Profile

     

       
427
       
 
       
}

     

       
428
       
 
       


     

       
0
       
 
       

     

       
429
       
-
       
func (p *Pages) ProfileHomePage(w io.Writer, params ProfileHomePageParams) error {

     

       
430
       
 
       
	return p.execute("user/profile", w, params)

     

       
431
       
 
       
}

     

       
432
       
 
       


     

···

       
407
       
 
       
	return p.execute("repo/fork", w, params)

     

       
408
       
 
       
}

     

       
409
       
 
       


     

       
410
       
+
       
type ProfilePageParams struct {

     

       
0
       
 
       

     

       
411
       
 
       
	LoggedInUser       *oauth.User

     

       
412
       
 
       
	Repos              []db.Repo

     

       
413
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
426
       
 
       
	Profile *db.Profile

     

       
427
       
 
       
}

     

       
428
       
 
       


     

       
429
       
+
       
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {

     

       
0
       
 
       

     

       
430
       
 
       
	return p.execute("user/profile", w, params)

     

       
431
       
 
       
}

     

       
432
       
 
       


     

···

       
25
       
 
       
	tabVal := r.URL.Query().Get("tab")

     

       
26
       
 
       
	switch tabVal {

     

       
27
       
 
       
	case "":

     

       
0
       
 
       

     

       
28
       
-
       
		s.profileHomePage(w, r)

     

       
29
       
 
       
	case "repos":

     

       
30
       
 
       
		s.reposPage(w, r)

     

       
31
       
 
       
	case "followers":

     
···

       
35
       
 
       
	}

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
0
       
 
       

     

       
38
       
-
       
type ProfilePageParams struct {

     

       
39
       
-
       
	Id           identity.Identity

     

       
40
       
-
       
	LoggedInUser *oauth.User

     

       
41
       
-
       
	Card         pages.ProfileCard

     

       
42
       
-
       
}

     

       
43
       
-
       


     

       
44
       
-
       
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) *ProfilePageParams {

     

       
45
       
 
       
	didOrHandle := chi.URLParam(r, "user")

     

       
46
       
 
       
	if didOrHandle == "" {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
47
       
-
       
		http.Error(w, "bad request", http.StatusBadRequest)

     

       
48
       
-
       
		return nil

     

       
49
       
 
       
	}

     

       
50
       
 
       


     

       
51
       
 
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
52
       
 
       
	if !ok {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
53
       
-
       
		log.Printf("malformed middleware")

     

       
54
       
-
       
		w.WriteHeader(http.StatusInternalServerError)

     

       
55
       
-
       
		return nil

     

       
56
       
-
       
	}

     

       
57
       
-
       
	did := ident.DID.String()

     

       
58
       
-
       


     

       
59
       
-
       
	profile, err := db.GetProfile(s.db, did)

     

       
60
       
-
       
	if err != nil {

     

       
61
       
-
       
		log.Printf("getting profile data for %s: %s", did, err)

     

       
62
       
 
       
	}

     

       
63
       
 
       


     

       
0
       
 
       

     

       
64
       
-
       
	followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)

     

       
65
       
 
       
	if err != nil {

     

       
0
       
 
       

     

       
66
       
-
       
		log.Printf("getting follow stats for %s: %s", did, err)

     

       
67
       
 
       
	}

     

       
68
       
 
       


     

       
69
       
-
       
	loggedInUser := s.oauth.GetUser(r)

     

       
70
       
-
       
	followStatus := db.IsNotFollowing

     

       
71
       
-
       
	if loggedInUser != nil {

     

       
72
       
-
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)

     

       
73
       
-
       
	}

     

       
74
       
-
       


     

       
75
       
-
       
	return &ProfilePageParams{

     

       
76
       
-
       
		Id:           ident,

     

       
77
       
-
       
		LoggedInUser: loggedInUser,

     

       
78
       
-
       
		Card: pages.ProfileCard{

     

       
79
       
-
       
			UserDid:        did,

     

       
80
       
-
       
			UserHandle:     ident.Handle.String(),

     

       
81
       
-
       
			Profile:        profile,

     

       
82
       
-
       
			FollowStatus:   followStatus,

     

       
83
       
-
       
			FollowersCount: followersCount,

     

       
84
       
-
       
			FollowingCount: followingCount,

     

       
85
       
-
       
		},

     

       
86
       
-
       
	}

     

       
87
       
-
       
}

     

       
88
       
-
       


     

       
89
       
-
       
func (s *State) profileHomePage(w http.ResponseWriter, r *http.Request) {

     

       
90
       
-
       
	pageWithProfile := s.profilePage(w, r)

     

       
91
       
-
       
	if pageWithProfile == nil {

     

       
92
       
-
       
		return

     

       
93
       
-
       
	}

     

       
94
       
-
       


     

       
95
       
-
       
	id := pageWithProfile.Id

     

       
96
       
 
       
	repos, err := db.GetRepos(

     

       
97
       
 
       
		s.db,

     

       
98
       
 
       
		0,

     

       
0
       
 
       

     

       
99
       
-
       
		db.FilterEq("did", id.DID),

     

       
100
       
 
       
	)

     

       
101
       
 
       
	if err != nil {

     

       
0
       
 
       

     

       
102
       
-
       
		log.Printf("getting repos for %s: %s", id.DID, err)

     

       
103
       
 
       
	}

     

       
104
       
 
       


     

       
105
       
-
       
	profile := pageWithProfile.Card.Profile

     

       
106
       
 
       
	// filter out ones that are pinned

     

       
107
       
 
       
	pinnedRepos := []db.Repo{}

     

       
108
       
 
       
	for i, r := range repos {

     
···

       
117
       
 
       
		}

     

       
118
       
 
       
	}

     

       
119
       
 
       


     

       
0
       
 
       

     

       
120
       
-
       
	collaboratingRepos, err := db.CollaboratingIn(s.db, id.DID.String())

     

       
121
       
 
       
	if err != nil {

     

       
0
       
 
       

     

       
122
       
-
       
		log.Printf("getting collaborating repos for %s: %s", id.DID, err)

     

       
123
       
 
       
	}

     

       
124
       
 
       


     

       
125
       
 
       
	pinnedCollaboratingRepos := []db.Repo{}

     
···

       
130
       
 
       
		}

     

       
131
       
 
       
	}

     

       
132
       
 
       


     

       
0
       
 
       

     

       
133
       
-
       
	timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())

     

       
134
       
 
       
	if err != nil {

     

       
0
       
 
       

     

       
135
       
-
       
		log.Printf("failed to create profile timeline for %s: %s", id.DID, err)

     

       
136
       
 
       
	}

     

       
137
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
138
       
-
       
	var didsToResolve []string

     

       
139
       
-
       
	for _, r := range collaboratingRepos {

     

       
140
       
-
       
		didsToResolve = append(didsToResolve, r.Did)

     

       
141
       
 
       
	}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
142
       
-
       
	for _, byMonth := range timeline.ByMonth {

     

       
143
       
-
       
		for _, pe := range byMonth.PullEvents.Items {

     

       
144
       
-
       
			didsToResolve = append(didsToResolve, pe.Repo.Did)

     

       
145
       
-
       
		}

     

       
146
       
-
       
		for _, ie := range byMonth.IssueEvents.Items {

     

       
147
       
-
       
			didsToResolve = append(didsToResolve, ie.Metadata.Repo.Did)

     

       
148
       
-
       
		}

     

       
149
       
-
       
		for _, re := range byMonth.RepoEvents {

     

       
150
       
-
       
			didsToResolve = append(didsToResolve, re.Repo.Did)

     

       
151
       
-
       
			if re.Source != nil {

     

       
152
       
-
       
				didsToResolve = append(didsToResolve, re.Source.Did)

     

       
153
       
-
       
			}

     

       
154
       
-
       
		}

     

       
155
       
 
       
	}

     

       
156
       
 
       


     

       
157
       
 
       
	now := time.Now()

     

       
158
       
 
       
	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

       
159
       
 
       
	punchcard, err := db.MakePunchcard(

     

       
160
       
 
       
		s.db,

     

       
0
       
 
       

     

       
161
       
-
       
		db.FilterEq("did", id.DID),

     

       
162
       
 
       
		db.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       
163
       
 
       
		db.FilterLte("date", now.Format(time.DateOnly)),

     

       
164
       
 
       
	)

     

       
165
       
 
       
	if err != nil {

     

       
0
       
 
       

     

       
166
       
-
       
		log.Println("failed to get punchcard for did", "did", id.DID, "err", err)

     

       
167
       
 
       
	}

     

       
168
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
169
       
-
       
	s.pages.ProfileHomePage(w, pages.ProfileHomePageParams{

     

       
170
       
-
       
		LoggedInUser:       pageWithProfile.LoggedInUser,

     

       
171
       
 
       
		Repos:              pinnedRepos,

     

       
172
       
 
       
		CollaboratingRepos: pinnedCollaboratingRepos,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
173
       
-
       
		Card:               pageWithProfile.Card,

     

       
174
       
-
       
		Punchcard:          punchcard,

     

       
175
       
-
       
		ProfileTimeline:    timeline,

     

       
176
       
 
       
	})

     

       
177
       
 
       
}

     

       
178
       
 
       


     

       
179
       
 
       
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
180
       
-
       
	pageWithProfile := s.profilePage(w, r)

     

       
181
       
-
       
	if pageWithProfile == nil {

     

       
182
       
 
       
		return

     

       
183
       
 
       
	}

     

       
184
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
185
       
-
       
	id := pageWithProfile.Id

     

       
186
       
 
       
	repos, err := db.GetRepos(

     

       
187
       
 
       
		s.db,

     

       
188
       
 
       
		0,

     

       
0
       
 
       

     

       
189
       
-
       
		db.FilterEq("did", id.DID),

     

       
190
       
 
       
	)

     

       
191
       
 
       
	if err != nil {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
192
       
-
       
		log.Printf("getting repos for %s: %s", id.DID, err)

     

       
193
       
 
       
	}

     

       
194
       
 
       


     

       
195
       
 
       
	s.pages.ReposPage(w, pages.ReposPageParams{

     

       
0
       
 
       

     

       
196
       
-
       
		LoggedInUser: pageWithProfile.LoggedInUser,

     

       
197
       
 
       
		Repos:        repos,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
198
       
-
       
		Card:         pageWithProfile.Card,

     

       
199
       
 
       
	})

     

       
200
       
 
       
}

     

       
201
       
 
       


     
···

       
206
       
 
       
}

     

       
207
       
 
       


     

       
208
       
 
       
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) *FollowsPageParams {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
209
       
-
       
	pageWithProfile := s.profilePage(w, r)

     

       
210
       
-
       
	if pageWithProfile == nil {

     

       
211
       
 
       
		return nil

     

       
212
       
 
       
	}

     

       
0
       
 
       

     

       
213
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
214
       
-
       
	id := pageWithProfile.Id

     

       
215
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
216
       
-
       
	follows, err := fetchFollows(s.db, id.DID.String())

     

       
217
       
 
       
	if err != nil {

     

       
0
       
 
       

     

       
218
       
-
       
		log.Printf("getting followers for %s: %s", id.DID, err)

     

       
219
       
 
       
	}

     

       
220
       
 
       


     

       
221
       
 
       
	if len(follows) == 0 {

     
···

       
233
       
 
       
		return nil

     

       
234
       
 
       
	}

     

       
235
       
 
       


     

       
236
       
-
       
	loggedInUser := pageWithProfile.LoggedInUser

     

       
237
       
 
       
	var loggedInUserFollowing map[string]struct{}

     

       
238
       
 
       
	if loggedInUser != nil {

     

       
239
       
 
       
		following, err := db.GetFollowing(s.db, loggedInUser.Did)

     
···

       
278
       
 
       
		})

     

       
279
       
 
       
	}

     

       
280
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
281
       
 
       
	return &FollowsPageParams{

     

       
282
       
 
       
		LoggedInUser: loggedInUser,

     

       
283
       
 
       
		Follows:      followCards,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
284
       
-
       
		Card:         pageWithProfile.Card,

     

       
285
       
 
       
	}

     

       
286
       
 
       
}

     

       
287
       
 
       


     

···

       
25
       
 
       
	tabVal := r.URL.Query().Get("tab")

     

       
26
       
 
       
	switch tabVal {

     

       
27
       
 
       
	case "":

     

       
28
       
+
       
		s.profilePage(w, r)

     

       
0
       
 
       

     

       
29
       
 
       
	case "repos":

     

       
30
       
 
       
		s.reposPage(w, r)

     

       
31
       
 
       
	case "followers":

     
···

       
35
       
 
       
	}

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
38
       
+
       
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
39
       
 
       
	didOrHandle := chi.URLParam(r, "user")

     

       
40
       
 
       
	if didOrHandle == "" {

     

       
41
       
+
       
		http.Error(w, "Bad request", http.StatusBadRequest)

     

       
42
       
+
       
		return

     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
	}

     

       
44
       
 
       


     

       
45
       
 
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
46
       
 
       
	if !ok {

     

       
47
       
+
       
		s.pages.Error404(w)

     

       
48
       
+
       
		return

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
	}

     

       
50
       
 
       


     

       
51
       
+
       
	profile, err := db.GetProfile(s.db, ident.DID.String())

     

       
0
       
 
       

     

       
52
       
 
       
	if err != nil {

     

       
53
       
+
       
		log.Printf("getting profile data for %s: %s", ident.DID.String(), err)

     

       
0
       
 
       

     

       
54
       
 
       
	}

     

       
55
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
56
       
 
       
	repos, err := db.GetRepos(

     

       
57
       
 
       
		s.db,

     

       
58
       
 
       
		0,

     

       
59
       
+
       
		db.FilterEq("did", ident.DID.String()),

     

       
0
       
 
       

     

       
60
       
 
       
	)

     

       
61
       
 
       
	if err != nil {

     

       
62
       
+
       
		log.Printf("getting repos for %s: %s", ident.DID.String(), err)

     

       
0
       
 
       

     

       
63
       
 
       
	}

     

       
64
       
 
       


     

       
0
       
 
       

     

       
65
       
 
       
	// filter out ones that are pinned

     

       
66
       
 
       
	pinnedRepos := []db.Repo{}

     

       
67
       
 
       
	for i, r := range repos {

     
···

       
76
       
 
       
		}

     

       
77
       
 
       
	}

     

       
78
       
 
       


     

       
79
       
+
       
	collaboratingRepos, err := db.CollaboratingIn(s.db, ident.DID.String())

     

       
0
       
 
       

     

       
80
       
 
       
	if err != nil {

     

       
81
       
+
       
		log.Printf("getting collaborating repos for %s: %s", ident.DID.String(), err)

     

       
0
       
 
       

     

       
82
       
 
       
	}

     

       
83
       
 
       


     

       
84
       
 
       
	pinnedCollaboratingRepos := []db.Repo{}

     
···

       
89
       
 
       
		}

     

       
90
       
 
       
	}

     

       
91
       
 
       


     

       
92
       
+
       
	timeline, err := db.MakeProfileTimeline(s.db, ident.DID.String())

     

       
0
       
 
       

     

       
93
       
 
       
	if err != nil {

     

       
94
       
+
       
		log.Printf("failed to create profile timeline for %s: %s", ident.DID.String(), err)

     

       
0
       
 
       

     

       
95
       
 
       
	}

     

       
96
       
 
       


     

       
97
       
+
       
	followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())

     

       
98
       
+
       
	if err != nil {

     

       
99
       
+
       
		log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
100
       
 
       
	}

     

       
101
       
+
       


     

       
102
       
+
       
	loggedInUser := s.oauth.GetUser(r)

     

       
103
       
+
       
	followStatus := db.IsNotFollowing

     

       
104
       
+
       
	if loggedInUser != nil {

     

       
105
       
+
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
106
       
 
       
	}

     

       
107
       
 
       


     

       
108
       
 
       
	now := time.Now()

     

       
109
       
 
       
	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

       
110
       
 
       
	punchcard, err := db.MakePunchcard(

     

       
111
       
 
       
		s.db,

     

       
112
       
+
       
		db.FilterEq("did", ident.DID.String()),

     

       
0
       
 
       

     

       
113
       
 
       
		db.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       
114
       
 
       
		db.FilterLte("date", now.Format(time.DateOnly)),

     

       
115
       
 
       
	)

     

       
116
       
 
       
	if err != nil {

     

       
117
       
+
       
		log.Println("failed to get punchcard for did", "did", ident.DID.String(), "err", err)

     

       
0
       
 
       

     

       
118
       
 
       
	}

     

       
119
       
 
       


     

       
120
       
+
       
	s.pages.ProfilePage(w, pages.ProfilePageParams{

     

       
121
       
+
       
		LoggedInUser:       loggedInUser,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
122
       
 
       
		Repos:              pinnedRepos,

     

       
123
       
 
       
		CollaboratingRepos: pinnedCollaboratingRepos,

     

       
124
       
+
       
		Card: pages.ProfileCard{

     

       
125
       
+
       
			UserDid:        ident.DID.String(),

     

       
126
       
+
       
			UserHandle:     ident.Handle.String(),

     

       
127
       
+
       
			Profile:        profile,

     

       
128
       
+
       
			FollowStatus:   followStatus,

     

       
129
       
+
       
			FollowersCount: followers,

     

       
130
       
+
       
			FollowingCount: following,

     

       
131
       
+
       
		},

     

       
132
       
+
       
		Punchcard:       punchcard,

     

       
133
       
+
       
		ProfileTimeline: timeline,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
134
       
 
       
	})

     

       
135
       
 
       
}

     

       
136
       
 
       


     

       
137
       
 
       
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       
138
       
+
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
139
       
+
       
	if !ok {

     

       
140
       
+
       
		s.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
141
       
 
       
		return

     

       
142
       
 
       
	}

     

       
143
       
 
       


     

       
144
       
+
       
	profile, err := db.GetProfile(s.db, ident.DID.String())

     

       
145
       
+
       
	if err != nil {

     

       
146
       
+
       
		log.Printf("getting profile data for %s: %s", ident.DID.String(), err)

     

       
147
       
+
       
	}

     

       
148
       
+
       


     

       
0
       
 
       

     

       
149
       
 
       
	repos, err := db.GetRepos(

     

       
150
       
 
       
		s.db,

     

       
151
       
 
       
		0,

     

       
152
       
+
       
		db.FilterEq("did", ident.DID.String()),

     

       
0
       
 
       

     

       
153
       
 
       
	)

     

       
154
       
 
       
	if err != nil {

     

       
155
       
+
       
		log.Printf("getting repos for %s: %s", ident.DID.String(), err)

     

       
156
       
+
       
	}

     

       
157
       
+
       


     

       
158
       
+
       
	loggedInUser := s.oauth.GetUser(r)

     

       
159
       
+
       
	followStatus := db.IsNotFollowing

     

       
160
       
+
       
	if loggedInUser != nil {

     

       
161
       
+
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())

     

       
162
       
+
       
	}

     

       
163
       
+
       


     

       
164
       
+
       
	followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())

     

       
165
       
+
       
	if err != nil {

     

       
166
       
+
       
		log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)

     

       
0
       
 
       

     

       
167
       
 
       
	}

     

       
168
       
 
       


     

       
169
       
 
       
	s.pages.ReposPage(w, pages.ReposPageParams{

     

       
170
       
+
       
		LoggedInUser: loggedInUser,

     

       
0
       
 
       

     

       
171
       
 
       
		Repos:        repos,

     

       
172
       
+
       
		Card: pages.ProfileCard{

     

       
173
       
+
       
			UserDid:        ident.DID.String(),

     

       
174
       
+
       
			UserHandle:     ident.Handle.String(),

     

       
175
       
+
       
			Profile:        profile,

     

       
176
       
+
       
			FollowStatus:   followStatus,

     

       
177
       
+
       
			FollowersCount: followers,

     

       
178
       
+
       
			FollowingCount: following,

     

       
179
       
+
       
		},

     

       
0
       
 
       

     

       
180
       
 
       
	})

     

       
181
       
 
       
}

     

       
182
       
 
       


     
···

       
187
       
 
       
}

     

       
188
       
 
       


     

       
189
       
 
       
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) *FollowsPageParams {

     

       
190
       
+
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
191
       
+
       
	if !ok {

     

       
192
       
+
       
		s.pages.Error404(w)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
193
       
 
       
		return nil

     

       
194
       
 
       
	}

     

       
195
       
+
       
	did := ident.DID.String()

     

       
196
       
 
       


     

       
197
       
+
       
	profile, err := db.GetProfile(s.db, did)

     

       
198
       
+
       
	if err != nil {

     

       
199
       
+
       
		log.Printf("getting profile data for %s: %s", did, err)

     

       
200
       
+
       
	}

     

       
0
       
 
       

     

       
201
       
 
       


     

       
202
       
+
       
	loggedInUser := s.oauth.GetUser(r)

     

       
203
       
+
       


     

       
204
       
+
       
	follows, err := fetchFollows(s.db, did)

     

       
0
       
 
       

     

       
205
       
 
       
	if err != nil {

     

       
206
       
+
       
		log.Printf("getting followers for %s: %s", did, err)

     

       
0
       
 
       

     

       
207
       
 
       
	}

     

       
208
       
 
       


     

       
209
       
 
       
	if len(follows) == 0 {

     
···

       
221
       
 
       
		return nil

     

       
222
       
 
       
	}

     

       
223
       
 
       


     

       
0
       
 
       

     

       
224
       
 
       
	var loggedInUserFollowing map[string]struct{}

     

       
225
       
 
       
	if loggedInUser != nil {

     

       
226
       
 
       
		following, err := db.GetFollowing(s.db, loggedInUser.Did)

     
···

       
265
       
 
       
		})

     

       
266
       
 
       
	}

     

       
267
       
 
       


     

       
268
       
+
       
	followStatus := db.IsNotFollowing

     

       
269
       
+
       
	if loggedInUser != nil {

     

       
270
       
+
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)

     

       
271
       
+
       
	}

     

       
272
       
+
       


     

       
273
       
+
       
	followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)

     

       
274
       
+
       
	if err != nil {

     

       
275
       
+
       
		log.Printf("getting follow stats followers for %s: %s", did, err)

     

       
276
       
+
       
	}

     

       
277
       
+
       


     

       
278
       
 
       
	return &FollowsPageParams{

     

       
279
       
 
       
		LoggedInUser: loggedInUser,

     

       
280
       
 
       
		Follows:      followCards,

     

       
281
       
+
       
		Card: pages.ProfileCard{

     

       
282
       
+
       
			UserDid:        did,

     

       
283
       
+
       
			UserHandle:     ident.Handle.String(),

     

       
284
       
+
       
			Profile:        profile,

     

       
285
       
+
       
			FollowStatus:   followStatus,

     

       
286
       
+
       
			FollowersCount: followersCount,

     

       
287
       
+
       
			FollowingCount: followingCount,

     

       
288
       
+
       
		},

     

       
0
       
 
       

     

       
289
       
 
       
	}

     

       
290
       
 
       
}

     

       
291
       
 
       


     

···

       
408
       
 
       
	return p.execute("repo/fork", w, params)

     

       
409
       
 
       
}

     

       
410
       
 
       


     

       
411
       
-
       
type ProfilePageParams struct {

     

       
412
       
 
       
	LoggedInUser       *oauth.User

     

       
413
       
 
       
	Repos              []db.Repo

     

       
414
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
427
       
 
       
	Profile *db.Profile

     

       
428
       
 
       
}

     

       
429
       
 
       


     

       
430
       
-
       
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {

     

       
431
       
 
       
	return p.execute("user/profile", w, params)

     

       
432
       
 
       
}

     

       
433
       
 
       


     

···

       
408
       
 
       
	return p.execute("repo/fork", w, params)

     

       
409
       
 
       
}

     

       
410
       
 
       


     

       
411
       
+
       
type ProfileHomePageParams struct {

     

       
412
       
 
       
	LoggedInUser       *oauth.User

     

       
413
       
 
       
	Repos              []db.Repo

     

       
414
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
427
       
 
       
	Profile *db.Profile

     

       
428
       
 
       
}

     

       
429
       
 
       


     

       
430
       
+
       
func (p *Pages) ProfileHomePage(w io.Writer, params ProfileHomePageParams) error {

     

       
431
       
 
       
	return p.execute("user/profile", w, params)

     

       
432
       
 
       
}

     

       
433
       
 
       


     

···

       
25
       
 
       
	tabVal := r.URL.Query().Get("tab")

     

       
26
       
 
       
	switch tabVal {

     

       
27
       
 
       
	case "":

     

       
28
       
-
       
		s.profilePage(w, r)

     

       
29
       
 
       
	case "repos":

     

       
30
       
 
       
		s.reposPage(w, r)

     

       
31
       
 
       
	case "followers":

     
···

       
35
       
 
       
	}

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
38
       
-
       
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
39
       
 
       
	didOrHandle := chi.URLParam(r, "user")

     

       
40
       
 
       
	if didOrHandle == "" {

     

       
41
       
-
       
		http.Error(w, "Bad request", http.StatusBadRequest)

     

       
42
       
-
       
		return

     

       
43
       
 
       
	}

     

       
44
       
 
       


     

       
45
       
 
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
46
       
 
       
	if !ok {

     

       
47
       
-
       
		s.pages.Error404(w)

     

       
48
       
-
       
		return

     

       
0
       
 
       

     

       
49
       
 
       
	}

     

       
0
       
 
       

     

       
50
       
 
       


     

       
51
       
-
       
	profile, err := db.GetProfile(s.db, ident.DID.String())

     

       
52
       
 
       
	if err != nil {

     

       
53
       
-
       
		log.Printf("getting profile data for %s: %s", ident.DID.String(), err)

     

       
54
       
 
       
	}

     

       
55
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
56
       
 
       
	repos, err := db.GetRepos(

     

       
57
       
 
       
		s.db,

     

       
58
       
 
       
		0,

     

       
59
       
-
       
		db.FilterEq("did", ident.DID.String()),

     

       
60
       
 
       
	)

     

       
61
       
 
       
	if err != nil {

     

       
62
       
-
       
		log.Printf("getting repos for %s: %s", ident.DID.String(), err)

     

       
63
       
 
       
	}

     

       
64
       
 
       


     

       
0
       
 
       

     

       
65
       
 
       
	// filter out ones that are pinned

     

       
66
       
 
       
	pinnedRepos := []db.Repo{}

     

       
67
       
 
       
	for i, r := range repos {

     
···

       
76
       
 
       
		}

     

       
77
       
 
       
	}

     

       
78
       
 
       


     

       
79
       
-
       
	collaboratingRepos, err := db.CollaboratingIn(s.db, ident.DID.String())

     

       
80
       
 
       
	if err != nil {

     

       
81
       
-
       
		log.Printf("getting collaborating repos for %s: %s", ident.DID.String(), err)

     

       
82
       
 
       
	}

     

       
83
       
 
       


     

       
84
       
 
       
	pinnedCollaboratingRepos := []db.Repo{}

     
···

       
89
       
 
       
		}

     

       
90
       
 
       
	}

     

       
91
       
 
       


     

       
92
       
-
       
	timeline, err := db.MakeProfileTimeline(s.db, ident.DID.String())

     

       
93
       
 
       
	if err != nil {

     

       
94
       
-
       
		log.Printf("failed to create profile timeline for %s: %s", ident.DID.String(), err)

     

       
95
       
 
       
	}

     

       
96
       
 
       


     

       
97
       
-
       
	followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())

     

       
98
       
-
       
	if err != nil {

     

       
99
       
-
       
		log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)

     

       
100
       
 
       
	}

     

       
101
       
-
       


     

       
102
       
-
       
	loggedInUser := s.oauth.GetUser(r)

     

       
103
       
-
       
	followStatus := db.IsNotFollowing

     

       
104
       
-
       
	if loggedInUser != nil {

     

       
105
       
-
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
106
       
 
       
	}

     

       
107
       
 
       


     

       
108
       
 
       
	now := time.Now()

     

       
109
       
 
       
	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

       
110
       
 
       
	punchcard, err := db.MakePunchcard(

     

       
111
       
 
       
		s.db,

     

       
112
       
-
       
		db.FilterEq("did", ident.DID.String()),

     

       
113
       
 
       
		db.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       
114
       
 
       
		db.FilterLte("date", now.Format(time.DateOnly)),

     

       
115
       
 
       
	)

     

       
116
       
 
       
	if err != nil {

     

       
117
       
-
       
		log.Println("failed to get punchcard for did", "did", ident.DID.String(), "err", err)

     

       
118
       
 
       
	}

     

       
119
       
 
       


     

       
120
       
-
       
	s.pages.ProfilePage(w, pages.ProfilePageParams{

     

       
121
       
-
       
		LoggedInUser:       loggedInUser,

     

       
122
       
 
       
		Repos:              pinnedRepos,

     

       
123
       
 
       
		CollaboratingRepos: pinnedCollaboratingRepos,

     

       
124
       
-
       
		Card: pages.ProfileCard{

     

       
125
       
-
       
			UserDid:        ident.DID.String(),

     

       
126
       
-
       
			UserHandle:     ident.Handle.String(),

     

       
127
       
-
       
			Profile:        profile,

     

       
128
       
-
       
			FollowStatus:   followStatus,

     

       
129
       
-
       
			FollowersCount: followers,

     

       
130
       
-
       
			FollowingCount: following,

     

       
131
       
-
       
		},

     

       
132
       
-
       
		Punchcard:       punchcard,

     

       
133
       
-
       
		ProfileTimeline: timeline,

     

       
134
       
 
       
	})

     

       
135
       
 
       
}

     

       
136
       
 
       


     

       
137
       
 
       
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       
138
       
-
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
139
       
-
       
	if !ok {

     

       
140
       
-
       
		s.pages.Error404(w)

     

       
141
       
 
       
		return

     

       
142
       
 
       
	}

     

       
143
       
 
       


     

       
144
       
-
       
	profile, err := db.GetProfile(s.db, ident.DID.String())

     

       
145
       
-
       
	if err != nil {

     

       
146
       
-
       
		log.Printf("getting profile data for %s: %s", ident.DID.String(), err)

     

       
147
       
-
       
	}

     

       
148
       
-
       


     

       
149
       
 
       
	repos, err := db.GetRepos(

     

       
150
       
 
       
		s.db,

     

       
151
       
 
       
		0,

     

       
152
       
-
       
		db.FilterEq("did", ident.DID.String()),

     

       
153
       
 
       
	)

     

       
154
       
 
       
	if err != nil {

     

       
155
       
-
       
		log.Printf("getting repos for %s: %s", ident.DID.String(), err)

     

       
156
       
-
       
	}

     

       
157
       
-
       


     

       
158
       
-
       
	loggedInUser := s.oauth.GetUser(r)

     

       
159
       
-
       
	followStatus := db.IsNotFollowing

     

       
160
       
-
       
	if loggedInUser != nil {

     

       
161
       
-
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())

     

       
162
       
-
       
	}

     

       
163
       
-
       


     

       
164
       
-
       
	followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())

     

       
165
       
-
       
	if err != nil {

     

       
166
       
-
       
		log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)

     

       
167
       
 
       
	}

     

       
168
       
 
       


     

       
169
       
 
       
	s.pages.ReposPage(w, pages.ReposPageParams{

     

       
170
       
-
       
		LoggedInUser: loggedInUser,

     

       
171
       
 
       
		Repos:        repos,

     

       
172
       
-
       
		Card: pages.ProfileCard{

     

       
173
       
-
       
			UserDid:        ident.DID.String(),

     

       
174
       
-
       
			UserHandle:     ident.Handle.String(),

     

       
175
       
-
       
			Profile:        profile,

     

       
176
       
-
       
			FollowStatus:   followStatus,

     

       
177
       
-
       
			FollowersCount: followers,

     

       
178
       
-
       
			FollowingCount: following,

     

       
179
       
-
       
		},

     

       
180
       
 
       
	})

     

       
181
       
 
       
}

     

       
182
       
 
       


     
···

       
187
       
 
       
}

     

       
188
       
 
       


     

       
189
       
 
       
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) *FollowsPageParams {

     

       
190
       
-
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
191
       
-
       
	if !ok {

     

       
192
       
-
       
		s.pages.Error404(w)

     

       
193
       
 
       
		return nil

     

       
194
       
 
       
	}

     

       
195
       
-
       
	did := ident.DID.String()

     

       
196
       
 
       


     

       
197
       
-
       
	profile, err := db.GetProfile(s.db, did)

     

       
198
       
-
       
	if err != nil {

     

       
199
       
-
       
		log.Printf("getting profile data for %s: %s", did, err)

     

       
200
       
-
       
	}

     

       
201
       
 
       


     

       
202
       
-
       
	loggedInUser := s.oauth.GetUser(r)

     

       
203
       
-
       


     

       
204
       
-
       
	follows, err := fetchFollows(s.db, did)

     

       
205
       
 
       
	if err != nil {

     

       
206
       
-
       
		log.Printf("getting followers for %s: %s", did, err)

     

       
207
       
 
       
	}

     

       
208
       
 
       


     

       
209
       
 
       
	if len(follows) == 0 {

     

       
210
       
-
       
		return nil

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
211
       
 
       
	}

     

       
212
       
 
       


     

       
213
       
 
       
	followDids := make([]string, 0, len(follows))

     
···

       
218
       
 
       
	profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))

     

       
219
       
 
       
	if err != nil {

     

       
220
       
 
       
		log.Printf("getting profile for %s: %s", followDids, err)

     

       
221
       
-
       
		return nil

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
222
       
 
       
	}

     

       
223
       
 
       


     

       
224
       
 
       
	var loggedInUserFollowing map[string]struct{}

     
···

       
237
       
 
       


     

       
238
       
 
       
	followCards := make([]pages.FollowCard, 0, len(follows))

     

       
239
       
 
       
	for _, did := range followDids {

     

       
240
       
-
       
		followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)

     

       
241
       
-
       
		if err != nil {

     

       
242
       
-
       
			log.Printf("getting follow stats for %s: %s", did, err)

     

       
243
       
 
       
		}

     

       
244
       
 
       
		followStatus := db.IsNotFollowing

     

       
245
       
 
       
		if loggedInUserFollowing != nil {

     
···

       
259
       
 
       
		followCards = append(followCards, pages.FollowCard{

     

       
260
       
 
       
			UserDid:        did,

     

       
261
       
 
       
			FollowStatus:   followStatus,

     

       
262
       
-
       
			FollowersCount: followersCount,

     

       
263
       
-
       
			FollowingCount: followingCount,

     

       
264
       
 
       
			Profile:        profile,

     

       
265
       
 
       
		})

     

       
266
       
 
       
	}

     

       
267
       
 
       


     

       
268
       
-
       
	followStatus := db.IsNotFollowing

     

       
269
       
-
       
	if loggedInUser != nil {

     

       
270
       
-
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)

     

       
271
       
-
       
	}

     

       
272
       
-
       


     

       
273
       
-
       
	followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)

     

       
274
       
-
       
	if err != nil {

     

       
275
       
-
       
		log.Printf("getting follow stats followers for %s: %s", did, err)

     

       
276
       
-
       
	}

     

       
277
       
-
       


     

       
278
       
 
       
	return &FollowsPageParams{

     

       
279
       
 
       
		LoggedInUser: loggedInUser,

     

       
280
       
 
       
		Follows:      followCards,

     

       
281
       
-
       
		Card: pages.ProfileCard{

     

       
282
       
-
       
			UserDid:        did,

     

       
283
       
-
       
			UserHandle:     ident.Handle.String(),

     

       
284
       
-
       
			Profile:        profile,

     

       
285
       
-
       
			FollowStatus:   followStatus,

     

       
286
       
-
       
			FollowersCount: followersCount,

     

       
287
       
-
       
			FollowingCount: followingCount,

     

       
288
       
-
       
		},

     

       
289
       
 
       
	}

     

       
290
       
 
       
}

     

       
291
       
 
       


     

       
292
       
 
       
func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {

     

       
293
       
 
       
	followPage := s.followPage(w, r, db.GetFollowers, func(f db.Follow) string { return f.UserDid })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
294
       
 
       


     

       
295
       
 
       
	s.pages.FollowersPage(w, pages.FollowersPageParams{

     

       
296
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     
···

       
301
       
 
       


     

       
302
       
 
       
func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {

     

       
303
       
 
       
	followPage := s.followPage(w, r, db.GetFollowing, func(f db.Follow) string { return f.SubjectDid })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
304
       
 
       


     

       
305
       
 
       
	s.pages.FollowingPage(w, pages.FollowingPageParams{

     

       
306
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     

···

       
25
       
 
       
	tabVal := r.URL.Query().Get("tab")

     

       
26
       
 
       
	switch tabVal {

     

       
27
       
 
       
	case "":

     

       
28
       
+
       
		s.profileHomePage(w, r)

     

       
29
       
 
       
	case "repos":

     

       
30
       
 
       
		s.reposPage(w, r)

     

       
31
       
 
       
	case "followers":

     
···

       
35
       
 
       
	}

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
38
       
+
       
type ProfilePageParams struct {

     

       
39
       
+
       
	Id           identity.Identity

     

       
40
       
+
       
	LoggedInUser *oauth.User

     

       
41
       
+
       
	Card         pages.ProfileCard

     

       
42
       
+
       
}

     

       
43
       
+
       


     

       
44
       
+
       
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) *ProfilePageParams {

     

       
45
       
 
       
	didOrHandle := chi.URLParam(r, "user")

     

       
46
       
 
       
	if didOrHandle == "" {

     

       
47
       
+
       
		http.Error(w, "bad request", http.StatusBadRequest)

     

       
48
       
+
       
		return nil

     

       
49
       
 
       
	}

     

       
50
       
 
       


     

       
51
       
 
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
52
       
 
       
	if !ok {

     

       
53
       
+
       
		log.Printf("malformed middleware")

     

       
54
       
+
       
		w.WriteHeader(http.StatusInternalServerError)

     

       
55
       
+
       
		return nil

     

       
56
       
 
       
	}

     

       
57
       
+
       
	did := ident.DID.String()

     

       
58
       
 
       


     

       
59
       
+
       
	profile, err := db.GetProfile(s.db, did)

     

       
60
       
 
       
	if err != nil {

     

       
61
       
+
       
		log.Printf("getting profile data for %s: %s", did, err)

     

       
62
       
 
       
	}

     

       
63
       
 
       


     

       
64
       
+
       
	followStats, err := db.GetFollowerFollowingCount(s.db, did)

     

       
65
       
+
       
	if err != nil {

     

       
66
       
+
       
		log.Printf("getting follow stats for %s: %s", did, err)

     

       
67
       
+
       
	}

     

       
68
       
+
       


     

       
69
       
+
       
	loggedInUser := s.oauth.GetUser(r)

     

       
70
       
+
       
	followStatus := db.IsNotFollowing

     

       
71
       
+
       
	if loggedInUser != nil {

     

       
72
       
+
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)

     

       
73
       
+
       
	}

     

       
74
       
+
       


     

       
75
       
+
       
	return &ProfilePageParams{

     

       
76
       
+
       
		Id:           ident,

     

       
77
       
+
       
		LoggedInUser: loggedInUser,

     

       
78
       
+
       
		Card: pages.ProfileCard{

     

       
79
       
+
       
			UserDid:        did,

     

       
80
       
+
       
			UserHandle:     ident.Handle.String(),

     

       
81
       
+
       
			Profile:        profile,

     

       
82
       
+
       
			FollowStatus:   followStatus,

     

       
83
       
+
       
			FollowersCount: followStats.Followers,

     

       
84
       
+
       
			FollowingCount: followStats.Following,

     

       
85
       
+
       
		},

     

       
86
       
+
       
	}

     

       
87
       
+
       
}

     

       
88
       
+
       


     

       
89
       
+
       
func (s *State) profileHomePage(w http.ResponseWriter, r *http.Request) {

     

       
90
       
+
       
	pageWithProfile := s.profilePage(w, r)

     

       
91
       
+
       
	if pageWithProfile == nil {

     

       
92
       
+
       
		return

     

       
93
       
+
       
	}

     

       
94
       
+
       


     

       
95
       
+
       
	id := pageWithProfile.Id

     

       
96
       
 
       
	repos, err := db.GetRepos(

     

       
97
       
 
       
		s.db,

     

       
98
       
 
       
		0,

     

       
99
       
+
       
		db.FilterEq("did", id.DID),

     

       
100
       
 
       
	)

     

       
101
       
 
       
	if err != nil {

     

       
102
       
+
       
		log.Printf("getting repos for %s: %s", id.DID, err)

     

       
103
       
 
       
	}

     

       
104
       
 
       


     

       
105
       
+
       
	profile := pageWithProfile.Card.Profile

     

       
106
       
 
       
	// filter out ones that are pinned

     

       
107
       
 
       
	pinnedRepos := []db.Repo{}

     

       
108
       
 
       
	for i, r := range repos {

     
···

       
117
       
 
       
		}

     

       
118
       
 
       
	}

     

       
119
       
 
       


     

       
120
       
+
       
	collaboratingRepos, err := db.CollaboratingIn(s.db, id.DID.String())

     

       
121
       
 
       
	if err != nil {

     

       
122
       
+
       
		log.Printf("getting collaborating repos for %s: %s", id.DID, err)

     

       
123
       
 
       
	}

     

       
124
       
 
       


     

       
125
       
 
       
	pinnedCollaboratingRepos := []db.Repo{}

     
···

       
130
       
 
       
		}

     

       
131
       
 
       
	}

     

       
132
       
 
       


     

       
133
       
+
       
	timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())

     

       
134
       
 
       
	if err != nil {

     

       
135
       
+
       
		log.Printf("failed to create profile timeline for %s: %s", id.DID, err)

     

       
136
       
 
       
	}

     

       
137
       
 
       


     

       
138
       
+
       
	var didsToResolve []string

     

       
139
       
+
       
	for _, r := range collaboratingRepos {

     

       
140
       
+
       
		didsToResolve = append(didsToResolve, r.Did)

     

       
141
       
 
       
	}

     

       
142
       
+
       
	for _, byMonth := range timeline.ByMonth {

     

       
143
       
+
       
		for _, pe := range byMonth.PullEvents.Items {

     

       
144
       
+
       
			didsToResolve = append(didsToResolve, pe.Repo.Did)

     

       
145
       
+
       
		}

     

       
146
       
+
       
		for _, ie := range byMonth.IssueEvents.Items {

     

       
147
       
+
       
			didsToResolve = append(didsToResolve, ie.Metadata.Repo.Did)

     

       
148
       
+
       
		}

     

       
149
       
+
       
		for _, re := range byMonth.RepoEvents {

     

       
150
       
+
       
			didsToResolve = append(didsToResolve, re.Repo.Did)

     

       
151
       
+
       
			if re.Source != nil {

     

       
152
       
+
       
				didsToResolve = append(didsToResolve, re.Source.Did)

     

       
153
       
+
       
			}

     

       
154
       
+
       
		}

     

       
155
       
 
       
	}

     

       
156
       
 
       


     

       
157
       
 
       
	now := time.Now()

     

       
158
       
 
       
	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

       
159
       
 
       
	punchcard, err := db.MakePunchcard(

     

       
160
       
 
       
		s.db,

     

       
161
       
+
       
		db.FilterEq("did", id.DID),

     

       
162
       
 
       
		db.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       
163
       
 
       
		db.FilterLte("date", now.Format(time.DateOnly)),

     

       
164
       
 
       
	)

     

       
165
       
 
       
	if err != nil {

     

       
166
       
+
       
		log.Println("failed to get punchcard for did", "did", id.DID, "err", err)

     

       
167
       
 
       
	}

     

       
168
       
 
       


     

       
169
       
+
       
	s.pages.ProfileHomePage(w, pages.ProfileHomePageParams{

     

       
170
       
+
       
		LoggedInUser:       pageWithProfile.LoggedInUser,

     

       
171
       
 
       
		Repos:              pinnedRepos,

     

       
172
       
 
       
		CollaboratingRepos: pinnedCollaboratingRepos,

     

       
173
       
+
       
		Card:               pageWithProfile.Card,

     

       
174
       
+
       
		Punchcard:          punchcard,

     

       
175
       
+
       
		ProfileTimeline:    timeline,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
176
       
 
       
	})

     

       
177
       
 
       
}

     

       
178
       
 
       


     

       
179
       
 
       
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       
180
       
+
       
	pageWithProfile := s.profilePage(w, r)

     

       
181
       
+
       
	if pageWithProfile == nil {

     

       
0
       
 
       

     

       
182
       
 
       
		return

     

       
183
       
 
       
	}

     

       
184
       
 
       


     

       
185
       
+
       
	id := pageWithProfile.Id

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
186
       
 
       
	repos, err := db.GetRepos(

     

       
187
       
 
       
		s.db,

     

       
188
       
 
       
		0,

     

       
189
       
+
       
		db.FilterEq("did", id.DID),

     

       
190
       
 
       
	)

     

       
191
       
 
       
	if err != nil {

     

       
192
       
+
       
		log.Printf("getting repos for %s: %s", id.DID, err)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
193
       
 
       
	}

     

       
194
       
 
       


     

       
195
       
 
       
	s.pages.ReposPage(w, pages.ReposPageParams{

     

       
196
       
+
       
		LoggedInUser: pageWithProfile.LoggedInUser,

     

       
197
       
 
       
		Repos:        repos,

     

       
198
       
+
       
		Card:         pageWithProfile.Card,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
199
       
 
       
	})

     

       
200
       
 
       
}

     

       
201
       
 
       


     
···

       
206
       
 
       
}

     

       
207
       
 
       


     

       
208
       
 
       
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) *FollowsPageParams {

     

       
209
       
+
       
	pageWithProfile := s.profilePage(w, r)

     

       
210
       
+
       
	if pageWithProfile == nil {

     

       
0
       
 
       

     

       
211
       
 
       
		return nil

     

       
212
       
 
       
	}

     

       
0
       
 
       

     

       
213
       
 
       


     

       
214
       
+
       
	id := pageWithProfile.Id

     

       
215
       
+
       
	loggedInUser := pageWithProfile.LoggedInUser

     

       
0
       
 
       

     

       
0
       
 
       

     

       
216
       
 
       


     

       
217
       
+
       
	follows, err := fetchFollows(s.db, id.DID.String())

     

       
0
       
 
       

     

       
0
       
 
       

     

       
218
       
 
       
	if err != nil {

     

       
219
       
+
       
		log.Printf("getting followers for %s: %s", id.DID, err)

     

       
220
       
 
       
	}

     

       
221
       
 
       


     

       
222
       
 
       
	if len(follows) == 0 {

     

       
223
       
+
       
		return &FollowsPageParams{

     

       
224
       
+
       
			LoggedInUser: loggedInUser,

     

       
225
       
+
       
			Follows:      []pages.FollowCard{},

     

       
226
       
+
       
			Card:         pageWithProfile.Card,

     

       
227
       
+
       
		}

     

       
228
       
 
       
	}

     

       
229
       
 
       


     

       
230
       
 
       
	followDids := make([]string, 0, len(follows))

     
···

       
235
       
 
       
	profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))

     

       
236
       
 
       
	if err != nil {

     

       
237
       
 
       
		log.Printf("getting profile for %s: %s", followDids, err)

     

       
238
       
+
       
	}

     

       
239
       
+
       


     

       
240
       
+
       
	followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)

     

       
241
       
+
       
	if err != nil {

     

       
242
       
+
       
		log.Printf("getting follow counts for %s: %s", followDids, err)

     

       
243
       
 
       
	}

     

       
244
       
 
       


     

       
245
       
 
       
	var loggedInUserFollowing map[string]struct{}

     
···

       
258
       
 
       


     

       
259
       
 
       
	followCards := make([]pages.FollowCard, 0, len(follows))

     

       
260
       
 
       
	for _, did := range followDids {

     

       
261
       
+
       
		followStats, exists := followStatsMap[did]

     

       
262
       
+
       
		if !exists {

     

       
263
       
+
       
			followStats = db.FollowStats{}

     

       
264
       
 
       
		}

     

       
265
       
 
       
		followStatus := db.IsNotFollowing

     

       
266
       
 
       
		if loggedInUserFollowing != nil {

     
···

       
280
       
 
       
		followCards = append(followCards, pages.FollowCard{

     

       
281
       
 
       
			UserDid:        did,

     

       
282
       
 
       
			FollowStatus:   followStatus,

     

       
283
       
+
       
			FollowersCount: followStats.Followers,

     

       
284
       
+
       
			FollowingCount: followStats.Following,

     

       
285
       
 
       
			Profile:        profile,

     

       
286
       
 
       
		})

     

       
287
       
 
       
	}

     

       
288
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
289
       
 
       
	return &FollowsPageParams{

     

       
290
       
 
       
		LoggedInUser: loggedInUser,

     

       
291
       
 
       
		Follows:      followCards,

     

       
292
       
+
       
		Card:         pageWithProfile.Card,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
293
       
 
       
	}

     

       
294
       
 
       
}

     

       
295
       
 
       


     

       
296
       
 
       
func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {

     

       
297
       
 
       
	followPage := s.followPage(w, r, db.GetFollowers, func(f db.Follow) string { return f.UserDid })

     

       
298
       
+
       
	if followPage == nil {

     

       
299
       
+
       
		return

     

       
300
       
+
       
	}

     

       
301
       
 
       


     

       
302
       
 
       
	s.pages.FollowersPage(w, pages.FollowersPageParams{

     

       
303
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     
···

       
308
       
 
       


     

       
309
       
 
       
func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {

     

       
310
       
 
       
	followPage := s.followPage(w, r, db.GetFollowing, func(f db.Follow) string { return f.SubjectDid })

     

       
311
       
+
       
	if followPage == nil {

     

       
312
       
+
       
		return

     

       
313
       
+
       
	}

     

       
314
       
 
       


     

       
315
       
 
       
	s.pages.FollowingPage(w, pages.FollowingPageParams{

     

       
316
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     

···

       
408
       
 
       
	return p.execute("repo/fork", w, params)

     

       
409
       
 
       
}

     

       
410
       
 
       


     

       
411
       
-
       
type ProfilePageParams struct {

     

       
412
       
 
       
	LoggedInUser       *oauth.User

     

       
413
       
 
       
	Repos              []db.Repo

     

       
414
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
427
       
 
       
	Profile *db.Profile

     

       
428
       
 
       
}

     

       
429
       
 
       


     

       
430
       
-
       
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {

     

       
431
       
 
       
	return p.execute("user/profile", w, params)

     

       
432
       
 
       
}

     

       
433
       
 
       


     

···

       
408
       
 
       
	return p.execute("repo/fork", w, params)

     

       
409
       
 
       
}

     

       
410
       
 
       


     

       
411
       
+
       
type ProfileHomePageParams struct {

     

       
412
       
 
       
	LoggedInUser       *oauth.User

     

       
413
       
 
       
	Repos              []db.Repo

     

       
414
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
427
       
 
       
	Profile *db.Profile

     

       
428
       
 
       
}

     

       
429
       
 
       


     

       
430
       
+
       
func (p *Pages) ProfileHomePage(w io.Writer, params ProfileHomePageParams) error {

     

       
431
       
 
       
	return p.execute("user/profile", w, params)

     

       
432
       
 
       
}

     

       
433
       
 
       


     

···

       
61
       
 
       
		log.Printf("getting profile data for %s: %s", did, err)

     

       
62
       
 
       
	}

     

       
63
       
 
       


     

       
64
       
-
       
	followStats, err := db.GetFollowerFollowingCount(s.db, did)

     

       
65
       
 
       
	if err != nil {

     

       
66
       
 
       
		log.Printf("getting follow stats for %s: %s", did, err)

     

       
67
       
 
       
	}

     
···

       
80
       
 
       
			UserHandle:     ident.Handle.String(),

     

       
81
       
 
       
			Profile:        profile,

     

       
82
       
 
       
			FollowStatus:   followStatus,

     

       
83
       
-
       
			FollowersCount: followStats.Followers,

     

       
84
       
-
       
			FollowingCount: followStats.Following,

     

       
85
       
 
       
		},

     

       
86
       
 
       
	}

     

       
87
       
 
       
}

     
···

       
212
       
 
       
	}

     

       
213
       
 
       


     

       
214
       
 
       
	id := pageWithProfile.Id

     

       
215
       
-
       
	loggedInUser := pageWithProfile.LoggedInUser

     

       
216
       
 
       


     

       
217
       
 
       
	follows, err := fetchFollows(s.db, id.DID.String())

     

       
218
       
 
       
	if err != nil {

     
···

       
220
       
 
       
	}

     

       
221
       
 
       


     

       
222
       
 
       
	if len(follows) == 0 {

     

       
223
       
-
       
		return &FollowsPageParams{

     

       
224
       
-
       
			LoggedInUser: loggedInUser,

     

       
225
       
-
       
			Follows:      []pages.FollowCard{},

     

       
226
       
-
       
			Card:         pageWithProfile.Card,

     

       
227
       
-
       
		}

     

       
228
       
 
       
	}

     

       
229
       
 
       


     

       
230
       
 
       
	followDids := make([]string, 0, len(follows))

     
···

       
235
       
 
       
	profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))

     

       
236
       
 
       
	if err != nil {

     

       
237
       
 
       
		log.Printf("getting profile for %s: %s", followDids, err)

     

       
0
       
 
       

     

       
238
       
 
       
	}

     

       
239
       
 
       


     

       
240
       
-
       
	followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids)

     

       
241
       
-
       
	if err != nil {

     

       
242
       
-
       
		log.Printf("getting follow counts for %s: %s", followDids, err)

     

       
243
       
-
       
	}

     

       
244
       
-
       


     

       
245
       
 
       
	var loggedInUserFollowing map[string]struct{}

     

       
246
       
 
       
	if loggedInUser != nil {

     

       
247
       
 
       
		following, err := db.GetFollowing(s.db, loggedInUser.Did)

     
···

       
258
       
 
       


     

       
259
       
 
       
	followCards := make([]pages.FollowCard, 0, len(follows))

     

       
260
       
 
       
	for _, did := range followDids {

     

       
261
       
-
       
		followStats, exists := followStatsMap[did]

     

       
262
       
-
       
		if !exists {

     

       
263
       
-
       
			followStats = db.FollowStats{}

     

       
264
       
 
       
		}

     

       
265
       
 
       
		followStatus := db.IsNotFollowing

     

       
266
       
 
       
		if loggedInUserFollowing != nil {

     
···

       
280
       
 
       
		followCards = append(followCards, pages.FollowCard{

     

       
281
       
 
       
			UserDid:        did,

     

       
282
       
 
       
			FollowStatus:   followStatus,

     

       
283
       
-
       
			FollowersCount: followStats.Followers,

     

       
284
       
-
       
			FollowingCount: followStats.Following,

     

       
285
       
 
       
			Profile:        profile,

     

       
286
       
 
       
		})

     

       
287
       
 
       
	}

     
···

       
295
       
 
       


     

       
296
       
 
       
func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {

     

       
297
       
 
       
	followPage := s.followPage(w, r, db.GetFollowers, func(f db.Follow) string { return f.UserDid })

     

       
298
       
-
       
	if followPage == nil {

     

       
299
       
-
       
		return

     

       
300
       
-
       
	}

     

       
301
       
 
       


     

       
302
       
 
       
	s.pages.FollowersPage(w, pages.FollowersPageParams{

     

       
303
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     
···

       
308
       
 
       


     

       
309
       
 
       
func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {

     

       
310
       
 
       
	followPage := s.followPage(w, r, db.GetFollowing, func(f db.Follow) string { return f.SubjectDid })

     

       
311
       
-
       
	if followPage == nil {

     

       
312
       
-
       
		return

     

       
313
       
-
       
	}

     

       
314
       
 
       


     

       
315
       
 
       
	s.pages.FollowingPage(w, pages.FollowingPageParams{

     

       
316
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     

···

       
61
       
 
       
		log.Printf("getting profile data for %s: %s", did, err)

     

       
62
       
 
       
	}

     

       
63
       
 
       


     

       
64
       
+
       
	followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)

     

       
65
       
 
       
	if err != nil {

     

       
66
       
 
       
		log.Printf("getting follow stats for %s: %s", did, err)

     

       
67
       
 
       
	}

     
···

       
80
       
 
       
			UserHandle:     ident.Handle.String(),

     

       
81
       
 
       
			Profile:        profile,

     

       
82
       
 
       
			FollowStatus:   followStatus,

     

       
83
       
+
       
			FollowersCount: followersCount,

     

       
84
       
+
       
			FollowingCount: followingCount,

     

       
85
       
 
       
		},

     

       
86
       
 
       
	}

     

       
87
       
 
       
}

     
···

       
212
       
 
       
	}

     

       
213
       
 
       


     

       
214
       
 
       
	id := pageWithProfile.Id

     

       
0
       
 
       

     

       
215
       
 
       


     

       
216
       
 
       
	follows, err := fetchFollows(s.db, id.DID.String())

     

       
217
       
 
       
	if err != nil {

     
···

       
219
       
 
       
	}

     

       
220
       
 
       


     

       
221
       
 
       
	if len(follows) == 0 {

     

       
222
       
+
       
		return nil

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
223
       
 
       
	}

     

       
224
       
 
       


     

       
225
       
 
       
	followDids := make([]string, 0, len(follows))

     
···

       
230
       
 
       
	profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids))

     

       
231
       
 
       
	if err != nil {

     

       
232
       
 
       
		log.Printf("getting profile for %s: %s", followDids, err)

     

       
233
       
+
       
		return nil

     

       
234
       
 
       
	}

     

       
235
       
 
       


     

       
236
       
+
       
	loggedInUser := pageWithProfile.LoggedInUser

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
237
       
 
       
	var loggedInUserFollowing map[string]struct{}

     

       
238
       
 
       
	if loggedInUser != nil {

     

       
239
       
 
       
		following, err := db.GetFollowing(s.db, loggedInUser.Did)

     
···

       
250
       
 
       


     

       
251
       
 
       
	followCards := make([]pages.FollowCard, 0, len(follows))

     

       
252
       
 
       
	for _, did := range followDids {

     

       
253
       
+
       
		followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)

     

       
254
       
+
       
		if err != nil {

     

       
255
       
+
       
			log.Printf("getting follow stats for %s: %s", did, err)

     

       
256
       
 
       
		}

     

       
257
       
 
       
		followStatus := db.IsNotFollowing

     

       
258
       
 
       
		if loggedInUserFollowing != nil {

     
···

       
272
       
 
       
		followCards = append(followCards, pages.FollowCard{

     

       
273
       
 
       
			UserDid:        did,

     

       
274
       
 
       
			FollowStatus:   followStatus,

     

       
275
       
+
       
			FollowersCount: followersCount,

     

       
276
       
+
       
			FollowingCount: followingCount,

     

       
277
       
 
       
			Profile:        profile,

     

       
278
       
 
       
		})

     

       
279
       
 
       
	}

     
···

       
287
       
 
       


     

       
288
       
 
       
func (s *State) followersPage(w http.ResponseWriter, r *http.Request) {

     

       
289
       
 
       
	followPage := s.followPage(w, r, db.GetFollowers, func(f db.Follow) string { return f.UserDid })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
290
       
 
       


     

       
291
       
 
       
	s.pages.FollowersPage(w, pages.FollowersPageParams{

     

       
292
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     
···

       
297
       
 
       


     

       
298
       
 
       
func (s *State) followingPage(w http.ResponseWriter, r *http.Request) {

     

       
299
       
 
       
	followPage := s.followPage(w, r, db.GetFollowing, func(f db.Follow) string { return f.SubjectDid })

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
300
       
 
       


     

       
301
       
 
       
	s.pages.FollowingPage(w, pages.FollowingPageParams{

     

       
302
       
 
       
		LoggedInUser: followPage.LoggedInUser,

     

···

       
408
       
 
       
	return p.execute("repo/fork", w, params)

     

       
409
       
 
       
}

     

       
410
       
 
       


     

       
411
       
-
       
type ProfilePageParams struct {

     

       
412
       
 
       
	LoggedInUser       *oauth.User

     

       
413
       
 
       
	Repos              []db.Repo

     

       
414
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
427
       
 
       
	Profile *db.Profile

     

       
428
       
 
       
}

     

       
429
       
 
       


     

       
430
       
-
       
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {

     

       
431
       
 
       
	return p.execute("user/profile", w, params)

     

       
432
       
 
       
}

     

       
433
       
 
       


     

···

       
408
       
 
       
	return p.execute("repo/fork", w, params)

     

       
409
       
 
       
}

     

       
410
       
 
       


     

       
411
       
+
       
type ProfileHomePageParams struct {

     

       
412
       
 
       
	LoggedInUser       *oauth.User

     

       
413
       
 
       
	Repos              []db.Repo

     

       
414
       
 
       
	CollaboratingRepos []db.Repo

     
···

       
427
       
 
       
	Profile *db.Profile

     

       
428
       
 
       
}

     

       
429
       
 
       


     

       
430
       
+
       
func (p *Pages) ProfileHomePage(w io.Writer, params ProfileHomePageParams) error {

     

       
431
       
 
       
	return p.execute("user/profile", w, params)

     

       
432
       
 
       
}

     

       
433
       
 
       


     

···

       
25
       
 
       
	tabVal := r.URL.Query().Get("tab")

     

       
26
       
 
       
	switch tabVal {

     

       
27
       
 
       
	case "":

     

       
28
       
-
       
		s.profilePage(w, r)

     

       
29
       
 
       
	case "repos":

     

       
30
       
 
       
		s.reposPage(w, r)

     

       
31
       
 
       
	case "followers":

     
···

       
35
       
 
       
	}

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
38
       
-
       
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
39
       
 
       
	didOrHandle := chi.URLParam(r, "user")

     

       
40
       
 
       
	if didOrHandle == "" {

     

       
41
       
-
       
		http.Error(w, "Bad request", http.StatusBadRequest)

     

       
42
       
-
       
		return

     

       
43
       
 
       
	}

     

       
44
       
 
       


     

       
45
       
 
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
46
       
 
       
	if !ok {

     

       
47
       
-
       
		s.pages.Error404(w)

     

       
48
       
-
       
		return

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
	}

     

       
50
       
 
       


     

       
51
       
-
       
	profile, err := db.GetProfile(s.db, ident.DID.String())

     

       
52
       
 
       
	if err != nil {

     

       
53
       
-
       
		log.Printf("getting profile data for %s: %s", ident.DID.String(), err)

     

       
54
       
 
       
	}

     

       
55
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
56
       
 
       
	repos, err := db.GetRepos(

     

       
57
       
 
       
		s.db,

     

       
58
       
 
       
		0,

     

       
59
       
-
       
		db.FilterEq("did", ident.DID.String()),

     

       
60
       
 
       
	)

     

       
61
       
 
       
	if err != nil {

     

       
62
       
-
       
		log.Printf("getting repos for %s: %s", ident.DID.String(), err)

     

       
63
       
 
       
	}

     

       
64
       
 
       


     

       
0
       
 
       

     

       
65
       
 
       
	// filter out ones that are pinned

     

       
66
       
 
       
	pinnedRepos := []db.Repo{}

     

       
67
       
 
       
	for i, r := range repos {

     
···

       
76
       
 
       
		}

     

       
77
       
 
       
	}

     

       
78
       
 
       


     

       
79
       
-
       
	collaboratingRepos, err := db.CollaboratingIn(s.db, ident.DID.String())

     

       
80
       
 
       
	if err != nil {

     

       
81
       
-
       
		log.Printf("getting collaborating repos for %s: %s", ident.DID.String(), err)

     

       
82
       
 
       
	}

     

       
83
       
 
       


     

       
84
       
 
       
	pinnedCollaboratingRepos := []db.Repo{}

     
···

       
89
       
 
       
		}

     

       
90
       
 
       
	}

     

       
91
       
 
       


     

       
92
       
-
       
	timeline, err := db.MakeProfileTimeline(s.db, ident.DID.String())

     

       
93
       
 
       
	if err != nil {

     

       
94
       
-
       
		log.Printf("failed to create profile timeline for %s: %s", ident.DID.String(), err)

     

       
95
       
 
       
	}

     

       
96
       
 
       


     

       
97
       
-
       
	followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())

     

       
98
       
-
       
	if err != nil {

     

       
99
       
-
       
		log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)

     

       
100
       
 
       
	}

     

       
101
       
-
       


     

       
102
       
-
       
	loggedInUser := s.oauth.GetUser(r)

     

       
103
       
-
       
	followStatus := db.IsNotFollowing

     

       
104
       
-
       
	if loggedInUser != nil {

     

       
105
       
-
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
106
       
 
       
	}

     

       
107
       
 
       


     

       
108
       
 
       
	now := time.Now()

     

       
109
       
 
       
	startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)

     

       
110
       
 
       
	punchcard, err := db.MakePunchcard(

     

       
111
       
 
       
		s.db,

     

       
112
       
-
       
		db.FilterEq("did", ident.DID.String()),

     

       
113
       
 
       
		db.FilterGte("date", startOfYear.Format(time.DateOnly)),

     

       
114
       
 
       
		db.FilterLte("date", now.Format(time.DateOnly)),

     

       
115
       
 
       
	)

     

       
116
       
 
       
	if err != nil {

     

       
117
       
-
       
		log.Println("failed to get punchcard for did", "did", ident.DID.String(), "err", err)

     

       
118
       
 
       
	}

     

       
119
       
 
       


     

       
120
       
-
       
	s.pages.ProfilePage(w, pages.ProfilePageParams{

     

       
121
       
-
       
		LoggedInUser:       loggedInUser,

     

       
122
       
 
       
		Repos:              pinnedRepos,

     

       
123
       
 
       
		CollaboratingRepos: pinnedCollaboratingRepos,

     

       
124
       
-
       
		Card: pages.ProfileCard{

     

       
125
       
-
       
			UserDid:        ident.DID.String(),

     

       
126
       
-
       
			UserHandle:     ident.Handle.String(),

     

       
127
       
-
       
			Profile:        profile,

     

       
128
       
-
       
			FollowStatus:   followStatus,

     

       
129
       
-
       
			FollowersCount: followers,

     

       
130
       
-
       
			FollowingCount: following,

     

       
131
       
-
       
		},

     

       
132
       
-
       
		Punchcard:       punchcard,

     

       
133
       
-
       
		ProfileTimeline: timeline,

     

       
134
       
 
       
	})

     

       
135
       
 
       
}

     

       
136
       
 
       


     

       
137
       
 
       
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {

     

       
138
       
-
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
139
       
-
       
	if !ok {

     

       
140
       
-
       
		s.pages.Error404(w)

     

       
141
       
 
       
		return

     

       
142
       
 
       
	}

     

       
143
       
 
       


     

       
144
       
-
       
	profile, err := db.GetProfile(s.db, ident.DID.String())

     

       
145
       
-
       
	if err != nil {

     

       
146
       
-
       
		log.Printf("getting profile data for %s: %s", ident.DID.String(), err)

     

       
147
       
-
       
	}

     

       
148
       
-
       


     

       
149
       
 
       
	repos, err := db.GetRepos(

     

       
150
       
 
       
		s.db,

     

       
151
       
 
       
		0,

     

       
152
       
-
       
		db.FilterEq("did", ident.DID.String()),

     

       
153
       
 
       
	)

     

       
154
       
 
       
	if err != nil {

     

       
155
       
-
       
		log.Printf("getting repos for %s: %s", ident.DID.String(), err)

     

       
156
       
-
       
	}

     

       
157
       
-
       


     

       
158
       
-
       
	loggedInUser := s.oauth.GetUser(r)

     

       
159
       
-
       
	followStatus := db.IsNotFollowing

     

       
160
       
-
       
	if loggedInUser != nil {

     

       
161
       
-
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())

     

       
162
       
-
       
	}

     

       
163
       
-
       


     

       
164
       
-
       
	followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())

     

       
165
       
-
       
	if err != nil {

     

       
166
       
-
       
		log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)

     

       
167
       
 
       
	}

     

       
168
       
 
       


     

       
169
       
 
       
	s.pages.ReposPage(w, pages.ReposPageParams{

     

       
170
       
-
       
		LoggedInUser: loggedInUser,

     

       
171
       
 
       
		Repos:        repos,

     

       
172
       
-
       
		Card: pages.ProfileCard{

     

       
173
       
-
       
			UserDid:        ident.DID.String(),

     

       
174
       
-
       
			UserHandle:     ident.Handle.String(),

     

       
175
       
-
       
			Profile:        profile,

     

       
176
       
-
       
			FollowStatus:   followStatus,

     

       
177
       
-
       
			FollowersCount: followers,

     

       
178
       
-
       
			FollowingCount: following,

     

       
179
       
-
       
		},

     

       
180
       
 
       
	})

     

       
181
       
 
       
}

     

       
182
       
 
       


     
···

       
187
       
 
       
}

     

       
188
       
 
       


     

       
189
       
 
       
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) *FollowsPageParams {

     

       
190
       
-
       
	ident, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
191
       
-
       
	if !ok {

     

       
192
       
-
       
		s.pages.Error404(w)

     

       
193
       
 
       
		return nil

     

       
194
       
 
       
	}

     

       
195
       
-
       
	did := ident.DID.String()

     

       
196
       
 
       


     

       
197
       
-
       
	profile, err := db.GetProfile(s.db, did)

     

       
198
       
-
       
	if err != nil {

     

       
199
       
-
       
		log.Printf("getting profile data for %s: %s", did, err)

     

       
200
       
-
       
	}

     

       
201
       
 
       


     

       
202
       
-
       
	loggedInUser := s.oauth.GetUser(r)

     

       
203
       
-
       


     

       
204
       
-
       
	follows, err := fetchFollows(s.db, did)

     

       
205
       
 
       
	if err != nil {

     

       
206
       
-
       
		log.Printf("getting followers for %s: %s", did, err)

     

       
207
       
 
       
	}

     

       
208
       
 
       


     

       
209
       
 
       
	if len(follows) == 0 {

     
···

       
221
       
 
       
		return nil

     

       
222
       
 
       
	}

     

       
223
       
 
       


     

       
0
       
 
       

     

       
224
       
 
       
	var loggedInUserFollowing map[string]struct{}

     

       
225
       
 
       
	if loggedInUser != nil {

     

       
226
       
 
       
		following, err := db.GetFollowing(s.db, loggedInUser.Did)

     
···

       
265
       
 
       
		})

     

       
266
       
 
       
	}

     

       
267
       
 
       


     

       
268
       
-
       
	followStatus := db.IsNotFollowing

     

       
269
       
-
       
	if loggedInUser != nil {

     

       
270
       
-
       
		followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)

     

       
271
       
-
       
	}

     

       
272
       
-
       


     

       
273
       
-
       
	followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)

     

       
274
       
-
       
	if err != nil {

     

       
275
       
-
       
		log.Printf("getting follow stats followers for %s: %s", did, err)

     

       
276
       
-
       
	}

     

       
277
       
-
       


     

       
278
       
 
       
	return &FollowsPageParams{

     

       
279
       
 
       
		LoggedInUser: loggedInUser,

     

       
280
       
 
       
		Follows:      followCards,

     

       
281
       
-
       
		Card: pages.ProfileCard{

     

       
282
       
-
       
			UserDid:        did,

     

       
283
       
-
       
			UserHandle:     ident.Handle.String(),

     

       
284
       
-
       
			Profile:        profile,

     

       
285
       
-
       
			FollowStatus:   followStatus,

     

       
286
       
-
       
			FollowersCount: followersCount,

     

       
287
       
-
       
			FollowingCount: followingCount,

     

       
288
       
-
       
		},

     

       
289
       
 
       
	}

     

       
290
       
 
       
}

     

       
291