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
}
32
}
33
34
-
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) {
35
didOrHandle := chi.URLParam(r, "user")
36
if didOrHandle == "" {
37
-
http.Error(w, "Bad request", http.StatusBadRequest)
38
-
return
39
}
40
41
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
42
if !ok {
43
-
s.pages.Error404(w)
44
-
return
45
}
46
47
-
profile, err := db.GetProfile(s.db, ident.DID.String())
48
if err != nil {
49
-
log.Printf("getting profile data for %s: %s", ident.DID.String(), err)
50
}
51
52
repos, err := db.GetRepos(
53
s.db,
54
0,
55
-
db.FilterEq("did", ident.DID.String()),
56
)
57
if err != nil {
58
-
log.Printf("getting repos for %s: %s", ident.DID.String(), err)
59
}
60
61
// filter out ones that are pinned
62
pinnedRepos := []db.Repo{}
63
for i, r := range repos {
···
72
}
73
}
74
75
-
collaboratingRepos, err := db.CollaboratingIn(s.db, ident.DID.String())
76
if err != nil {
77
-
log.Printf("getting collaborating repos for %s: %s", ident.DID.String(), err)
78
}
79
80
pinnedCollaboratingRepos := []db.Repo{}
···
85
}
86
}
87
88
-
timeline, err := db.MakeProfileTimeline(s.db, ident.DID.String())
89
if err != nil {
90
-
log.Printf("failed to create profile timeline for %s: %s", ident.DID.String(), err)
91
}
92
93
var didsToResolve []string
···
109
}
110
}
111
112
-
followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())
113
-
if err != nil {
114
-
log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
115
-
}
116
-
117
-
loggedInUser := s.oauth.GetUser(r)
118
-
followStatus := db.IsNotFollowing
119
-
if loggedInUser != nil {
120
-
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
121
-
}
122
-
123
now := time.Now()
124
startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
125
punchcard, err := db.MakePunchcard(
126
s.db,
127
-
db.FilterEq("did", ident.DID.String()),
128
db.FilterGte("date", startOfYear.Format(time.DateOnly)),
129
db.FilterLte("date", now.Format(time.DateOnly)),
130
)
131
if err != nil {
132
-
log.Println("failed to get punchcard for did", "did", ident.DID.String(), "err", err)
133
}
134
135
-
s.pages.ProfilePage(w, pages.ProfilePageParams{
136
-
LoggedInUser: loggedInUser,
137
Repos: pinnedRepos,
138
CollaboratingRepos: pinnedCollaboratingRepos,
139
-
Card: pages.ProfileCard{
140
-
UserDid: ident.DID.String(),
141
-
UserHandle: ident.Handle.String(),
142
-
Profile: profile,
143
-
FollowStatus: followStatus,
144
-
FollowersCount: followers,
145
-
FollowingCount: following,
146
-
},
147
-
Punchcard: punchcard,
148
-
ProfileTimeline: timeline,
149
})
150
}
151
152
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
153
-
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
154
-
if !ok {
155
-
s.pages.Error404(w)
156
return
157
}
158
159
-
profile, err := db.GetProfile(s.db, ident.DID.String())
160
-
if err != nil {
161
-
log.Printf("getting profile data for %s: %s", ident.DID.String(), err)
162
-
}
163
-
164
repos, err := db.GetRepos(
165
s.db,
166
0,
167
-
db.FilterEq("did", ident.DID.String()),
168
)
169
if err != nil {
170
-
log.Printf("getting repos for %s: %s", ident.DID.String(), err)
171
-
}
172
-
173
-
loggedInUser := s.oauth.GetUser(r)
174
-
followStatus := db.IsNotFollowing
175
-
if loggedInUser != nil {
176
-
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
177
-
}
178
-
179
-
followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String())
180
-
if err != nil {
181
-
log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
182
}
183
184
s.pages.ReposPage(w, pages.ReposPageParams{
185
-
LoggedInUser: loggedInUser,
186
Repos: repos,
187
-
Card: pages.ProfileCard{
188
-
UserDid: ident.DID.String(),
189
-
UserHandle: ident.Handle.String(),
190
-
Profile: profile,
191
-
FollowStatus: followStatus,
192
-
FollowersCount: followers,
193
-
FollowingCount: following,
194
-
},
195
})
196
}
197
···
202
}
203
204
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) *FollowsPageParams {
205
-
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
206
-
if !ok {
207
-
s.pages.Error404(w)
208
return nil
209
}
210
-
did := ident.DID.String()
211
-
212
-
profile, err := db.GetProfile(s.db, did)
213
-
if err != nil {
214
-
log.Printf("getting profile data for %s: %s", did, err)
215
-
}
216
217
-
loggedInUser := s.oauth.GetUser(r)
218
219
-
follows, err := fetchFollows(s.db, did)
220
if err != nil {
221
-
log.Printf("getting followers for %s: %s", did, err)
222
}
223
224
if len(follows) == 0 {
···
236
return nil
237
}
238
239
var loggedInUserFollowing map[string]struct{}
240
if loggedInUser != nil {
241
following, err := db.GetFollowing(s.db, loggedInUser.Did)
···
280
})
281
}
282
283
-
followStatus := db.IsNotFollowing
284
-
if loggedInUser != nil {
285
-
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
286
-
}
287
-
288
-
followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)
289
-
if err != nil {
290
-
log.Printf("getting follow stats followers for %s: %s", did, err)
291
-
}
292
-
293
return &FollowsPageParams{
294
LoggedInUser: loggedInUser,
295
Follows: followCards,
296
-
Card: pages.ProfileCard{
297
-
UserDid: did,
298
-
UserHandle: ident.Handle.String(),
299
-
Profile: profile,
300
-
FollowStatus: followStatus,
301
-
FollowersCount: followersCount,
302
-
FollowingCount: followingCount,
303
-
},
304
}
305
}
306
···
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
}
32
}
33
34
+
type ProfilePageParams struct {
35
+
Id identity.Identity
36
+
LoggedInUser *oauth.User
37
+
Card pages.ProfileCard
38
+
}
39
+
40
+
func (s *State) profilePage(w http.ResponseWriter, r *http.Request) *ProfilePageParams {
41
didOrHandle := chi.URLParam(r, "user")
42
if didOrHandle == "" {
43
+
http.Error(w, "bad request", http.StatusBadRequest)
44
+
return nil
45
}
46
47
ident, ok := r.Context().Value("resolvedId").(identity.Identity)
48
if !ok {
49
+
log.Printf("malformed middleware")
50
+
w.WriteHeader(http.StatusInternalServerError)
51
+
return nil
52
}
53
+
did := ident.DID.String()
54
55
+
profile, err := db.GetProfile(s.db, did)
56
if err != nil {
57
+
log.Printf("getting profile data for %s: %s", did, err)
58
}
59
60
+
followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did)
61
+
if err != nil {
62
+
log.Printf("getting follow stats for %s: %s", did, err)
63
+
}
64
+
65
+
loggedInUser := s.oauth.GetUser(r)
66
+
followStatus := db.IsNotFollowing
67
+
if loggedInUser != nil {
68
+
followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, did)
69
+
}
70
+
71
+
return &ProfilePageParams{
72
+
Id: ident,
73
+
LoggedInUser: loggedInUser,
74
+
Card: pages.ProfileCard{
75
+
UserDid: did,
76
+
UserHandle: ident.Handle.String(),
77
+
Profile: profile,
78
+
FollowStatus: followStatus,
79
+
FollowersCount: followersCount,
80
+
FollowingCount: followingCount,
81
+
},
82
+
}
83
+
}
84
+
85
+
func (s *State) profileHomePage(w http.ResponseWriter, r *http.Request) {
86
+
pageWithProfile := s.profilePage(w, r)
87
+
if pageWithProfile == nil {
88
+
return
89
+
}
90
+
91
+
id := pageWithProfile.Id
92
repos, err := db.GetRepos(
93
s.db,
94
0,
95
+
db.FilterEq("did", id.DID),
96
)
97
if err != nil {
98
+
log.Printf("getting repos for %s: %s", id.DID, err)
99
}
100
101
+
profile := pageWithProfile.Card.Profile
102
// filter out ones that are pinned
103
pinnedRepos := []db.Repo{}
104
for i, r := range repos {
···
113
}
114
}
115
116
+
collaboratingRepos, err := db.CollaboratingIn(s.db, id.DID.String())
117
if err != nil {
118
+
log.Printf("getting collaborating repos for %s: %s", id.DID, err)
119
}
120
121
pinnedCollaboratingRepos := []db.Repo{}
···
126
}
127
}
128
129
+
timeline, err := db.MakeProfileTimeline(s.db, id.DID.String())
130
if err != nil {
131
+
log.Printf("failed to create profile timeline for %s: %s", id.DID, err)
132
}
133
134
var didsToResolve []string
···
150
}
151
}
152
153
now := time.Now()
154
startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
155
punchcard, err := db.MakePunchcard(
156
s.db,
157
+
db.FilterEq("did", id.DID),
158
db.FilterGte("date", startOfYear.Format(time.DateOnly)),
159
db.FilterLte("date", now.Format(time.DateOnly)),
160
)
161
if err != nil {
162
+
log.Println("failed to get punchcard for did", "did", id.DID, "err", err)
163
}
164
165
+
s.pages.ProfileHomePage(w, pages.ProfileHomePageParams{
166
+
LoggedInUser: pageWithProfile.LoggedInUser,
167
Repos: pinnedRepos,
168
CollaboratingRepos: pinnedCollaboratingRepos,
169
+
Card: pageWithProfile.Card,
170
+
Punchcard: punchcard,
171
+
ProfileTimeline: timeline,
172
})
173
}
174
175
func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
176
+
pageWithProfile := s.profilePage(w, r)
177
+
if pageWithProfile == nil {
178
return
179
}
180
181
+
id := pageWithProfile.Id
182
repos, err := db.GetRepos(
183
s.db,
184
0,
185
+
db.FilterEq("did", id.DID),
186
)
187
if err != nil {
188
+
log.Printf("getting repos for %s: %s", id.DID, err)
189
}
190
191
s.pages.ReposPage(w, pages.ReposPageParams{
192
+
LoggedInUser: pageWithProfile.LoggedInUser,
193
Repos: repos,
194
+
Card: pageWithProfile.Card,
195
})
196
}
197
···
202
}
203
204
func (s *State) followPage(w http.ResponseWriter, r *http.Request, fetchFollows func(db.Execer, string) ([]db.Follow, error), extractDid func(db.Follow) string) *FollowsPageParams {
205
+
pageWithProfile := s.profilePage(w, r)
206
+
if pageWithProfile == nil {
207
return nil
208
}
209
210
+
id := pageWithProfile.Id
211
212
+
follows, err := fetchFollows(s.db, id.DID.String())
213
if err != nil {
214
+
log.Printf("getting followers for %s: %s", id.DID, err)
215
}
216
217
if len(follows) == 0 {
···
229
return nil
230
}
231
232
+
loggedInUser := pageWithProfile.LoggedInUser
233
var loggedInUserFollowing map[string]struct{}
234
if loggedInUser != nil {
235
following, err := db.GetFollowing(s.db, loggedInUser.Did)
···
274
})
275
}
276
277
return &FollowsPageParams{
278
LoggedInUser: loggedInUser,
279
Follows: followCards,
280
+
Card: pageWithProfile.Card,
281
}
282
}
283