ptr.pet
- rename existing ProfilePage to ProfileHomePage
Signed-off-by: dusk y.bera003.06@protonmail.com
+2
-2
appview/pages/pages.go
+2
-2
appview/pages/pages.go
···
401
return p.execute("repo/fork", w, params)
402
}
403
404
-
type ProfilePageParams struct {
405
LoggedInUser *oauth.User
406
Repos []db.Repo
407
CollaboratingRepos []db.Repo
···
420
Profile *db.Profile
421
}
422
423
-
func (p *Pages) ProfilePage(w io.Writer, params ProfilePageParams) error {
424
return p.execute("user/profile", w, params)
425
}
426
···
401
return p.execute("repo/fork", w, params)
402
}
403
404
+
type ProfileHomePageParams struct {
405
LoggedInUser *oauth.User
406
Repos []db.Repo
407
CollaboratingRepos []db.Repo
···
420
Profile *db.Profile
421
}
422
423
+
func (p *Pages) ProfileHomePage(w io.Writer, params ProfileHomePageParams) error {
424
return p.execute("user/profile", w, params)
425
}
426
+76
-99
appview/state/profile.go
+76
-99
appview/state/profile.go
···
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) {
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
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
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
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
var didsToResolve []string
···
113
}
114
}
115
116
-
followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())
117
-
if err != nil {
118
-
log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
119
-
}
120
-
121
-
loggedInUser := s.oauth.GetUser(r)
122
-
followStatus := db.IsNotFollowing
123
-
if loggedInUser != nil {
124
-
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
125
-
}
126
-
127
now := time.Now()
128
startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
129
punchcard, err := db.MakePunchcard(
130
s.db,
131
-
db.FilterEq("did", ident.DID.String()),
132
db.FilterGte("date", startOfYear.Format(time.DateOnly)),
133
db.FilterLte("date", now.Format(time.DateOnly)),
134
)
135
if err != nil {
136
-
log.Println("failed to get punchcard for did", "did", ident.DID.String(), "err", err)
137
}
138
139
-
s.pages.ProfilePage(w, pages.ProfilePageParams{
140
-
LoggedInUser: loggedInUser,
141
Repos: pinnedRepos,
142
CollaboratingRepos: pinnedCollaboratingRepos,
143
-
Card: pages.ProfileCard{
144
-
UserDid: ident.DID.String(),
145
-
UserHandle: ident.Handle.String(),
146
-
Profile: profile,
147
-
FollowStatus: followStatus,
148
-
FollowersCount: followers,
149
-
FollowingCount: following,
150
-
},
151
-
Punchcard: punchcard,
152
-
ProfileTimeline: timeline,
153
})
154
}
155
156
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
157
-
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
158
-
if !ok {
159
-
s.pages.Error404(w)
160
return
161
}
162
163
-
profile, err := db.GetProfile(s.db, ident.DID.String())
164
-
if err != nil {
165
-
log.Printf("getting profile data for %s: %s", ident.DID.String(), err)
166
-
}
167
-
168
repos, err := db.GetRepos(
169
s.db,
170
0,
171
-
db.FilterEq("did", ident.DID.String()),
172
)
173
if err != nil {
174
-
log.Printf("getting repos for %s: %s", ident.DID.String(), err)
175
-
}
176
-
177
-
loggedInUser := s.oauth.GetUser(r)
178
-
followStatus := db.IsNotFollowing
179
-
if loggedInUser != nil {
180
-
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
181
-
}
182
-
183
-
followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())
184
-
if err != nil {
185
-
log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
186
}
187
188
s.pages.ReposPage(w, pages.ReposPageParams{
189
-
LoggedInUser: loggedInUser,
190
Repos: repos,
191
-
Card: pages.ProfileCard{
192
-
UserDid: ident.DID.String(),
193
-
UserHandle: ident.Handle.String(),
194
-
Profile: profile,
195
-
FollowStatus: followStatus,
196
-
FollowersCount: followers,
197
-
FollowingCount: following,
198
-
},
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
-
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
210
-
if !ok {
211
-
s.pages.Error404(w)
212
return nil
213
}
214
-
did := ident.DID.String()
215
-
216
-
profile, err := db.GetProfile(s.db, did)
217
-
if err != nil {
218
-
log.Printf("getting profile data for %s: %s", did, err)
219
-
}
220
221
-
loggedInUser := s.oauth.GetUser(r)
222
223
-
follows, err := fetchFollows(s.db, did)
224
if err != nil {
225
-
log.Printf("getting followers for %s: %s", did, err)
226
}
227
228
if len(follows) == 0 {
···
240
return nil
241
}
242
243
var loggedInUserFollowing map[string]struct{}
244
if loggedInUser != nil {
245
following, err := db.GetFollowing(s.db, loggedInUser.Did)
···
284
})
285
}
286
287
-
followStatus := db.IsNotFollowing
288
-
if loggedInUser != nil {
289
-
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
290
-
}
291
-
292
-
followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)
293
-
if err != nil {
294
-
log.Printf("getting follow stats followers for %s: %s", did, err)
295
-
}
296
-
297
return &FollowsPageParams{
298
LoggedInUser: loggedInUser,
299
Follows: followCards,
300
-
Card: pages.ProfileCard{
301
-
UserDid: did,
302
-
UserHandle: ident.Handle.String(),
303
-
Profile: profile,
304
-
FollowStatus: followStatus,
305
-
FollowersCount: followersCount,
306
-
FollowingCount: followingCount,
307
-
},
308
}
309
}
310
···
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
+
followersCount, followingCount, 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: 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,
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
···
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,
176
})
177
}
178
179
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
180
+
pageWithProfile := s.profilePage(w, r)
181
+
if pageWithProfile == nil {
182
return
183
}
184
185
+
id := pageWithProfile.Id
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)
193
}
194
195
s.pages.ReposPage(w, pages.ReposPageParams{
196
+
LoggedInUser: pageWithProfile.LoggedInUser,
197
Repos: repos,
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 {
209
+
pageWithProfile := s.profilePage(w, r)
210
+
if pageWithProfile == nil {
211
return nil
212
}
213
214
+
id := pageWithProfile.Id
215
216
+
follows, err := fetchFollows(s.db, id.DID.String())
217
if err != nil {
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
281
return &FollowsPageParams{
282
LoggedInUser: loggedInUser,
283
Follows: followCards,
284
+
Card: pageWithProfile.Card,
285
}
286
}
287