this repo has no description
tangled.org
1package state
2
3import (
4 "crypto/hmac"
5 "crypto/sha256"
6 "encoding/hex"
7 "fmt"
8 "log"
9 "net/http"
10 "slices"
11 "strings"
12 "time"
13
14 comatproto "github.com/bluesky-social/indigo/api/atproto"
15 "github.com/bluesky-social/indigo/atproto/identity"
16 "github.com/bluesky-social/indigo/atproto/syntax"
17 lexutil "github.com/bluesky-social/indigo/lex/util"
18 "github.com/go-chi/chi/v5"
19 "tangled.sh/tangled.sh/core/api/tangled"
20 "tangled.sh/tangled.sh/core/appview/db"
21 "tangled.sh/tangled.sh/core/appview/pages"
22)
23
24func (s *State) Profile(w http.ResponseWriter, r *http.Request) {
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
34func (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 {
64 // if this is a pinned repo, add it
65 if slices.Contains(profile.PinnedRepos[:], r.RepoAt()) {
66 pinnedRepos = append(pinnedRepos, r)
67 }
68
69 // if there are no saved pins, add the first 4 repos
70 if profile.IsPinnedReposEmpty() && i < 4 {
71 pinnedRepos = append(pinnedRepos, r)
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{}
81 for _, r := range collaboratingRepos {
82 // if this is a pinned repo, add it
83 if slices.Contains(profile.PinnedRepos[:], r.RepoAt()) {
84 pinnedCollaboratingRepos = append(pinnedCollaboratingRepos, r)
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
94 for _, r := range collaboratingRepos {
95 didsToResolve = append(didsToResolve, r.Did)
96 }
97 for _, byMonth := range timeline.ByMonth {
98 for _, pe := range byMonth.PullEvents.Items {
99 didsToResolve = append(didsToResolve, pe.Repo.Did)
100 }
101 for _, ie := range byMonth.IssueEvents.Items {
102 didsToResolve = append(didsToResolve, ie.Metadata.Repo.Did)
103 }
104 for _, re := range byMonth.RepoEvents {
105 didsToResolve = append(didsToResolve, re.Repo.Did)
106 if re.Source != nil {
107 didsToResolve = append(didsToResolve, re.Source.Did)
108 }
109 }
110 }
111
112 resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
113 didHandleMap := make(map[string]string)
114 for _, identity := range resolvedIds {
115 if !identity.Handle.IsInvalidHandle() {
116 didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())
117 } else {
118 didHandleMap[identity.DID.String()] = identity.DID.String()
119 }
120 }
121
122 followers, following, err := db.GetFollowerFollowing(s.db, ident.DID.String())
123 if err != nil {
124 log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
125 }
126
127 loggedInUser := s.oauth.GetUser(r)
128 followStatus := db.IsNotFollowing
129 if loggedInUser != nil {
130 followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
131 }
132
133 now := time.Now()
134 startOfYear := time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.UTC)
135 punchcard, err := db.MakePunchcard(
136 s.db,
137 db.FilterEq("did", ident.DID.String()),
138 db.FilterGte("date", startOfYear.Format(time.DateOnly)),
139 db.FilterLte("date", now.Format(time.DateOnly)),
140 )
141 if err != nil {
142 log.Println("failed to get punchcard for did", "did", ident.DID.String(), "err", err)
143 }
144
145 profileAvatarUri := s.GetAvatarUri(ident.Handle.String())
146 s.pages.ProfilePage(w, pages.ProfilePageParams{
147 LoggedInUser: loggedInUser,
148 Repos: pinnedRepos,
149 CollaboratingRepos: pinnedCollaboratingRepos,
150 DidHandleMap: didHandleMap,
151 Card: pages.ProfileCard{
152 UserDid: ident.DID.String(),
153 UserHandle: ident.Handle.String(),
154 AvatarUri: profileAvatarUri,
155 Profile: profile,
156 FollowStatus: followStatus,
157 Followers: followers,
158 Following: following,
159 },
160 Punchcard: punchcard,
161 ProfileTimeline: timeline,
162 })
163}
164
165func (s *State) reposPage(w http.ResponseWriter, r *http.Request) {
166 ident, ok := r.Context().Value("resolvedId").(identity.Identity)
167 if !ok {
168 s.pages.Error404(w)
169 return
170 }
171
172 profile, err := db.GetProfile(s.db, ident.DID.String())
173 if err != nil {
174 log.Printf("getting profile data for %s: %s", ident.DID.String(), err)
175 }
176
177 repos, err := db.GetRepos(
178 s.db,
179 0,
180 db.FilterEq("did", ident.DID.String()),
181 )
182 if err != nil {
183 log.Printf("getting repos for %s: %s", ident.DID.String(), err)
184 }
185
186 loggedInUser := s.oauth.GetUser(r)
187 followStatus := db.IsNotFollowing
188 if loggedInUser != nil {
189 followStatus = db.GetFollowStatus(s.db, loggedInUser.Did, ident.DID.String())
190 }
191
192 followers, following, err := db.GetFollowerFollowing(s.db, ident.DID.String())
193 if err != nil {
194 log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err)
195 }
196
197 profileAvatarUri := s.GetAvatarUri(ident.Handle.String())
198
199 s.pages.ReposPage(w, pages.ReposPageParams{
200 LoggedInUser: loggedInUser,
201 Repos: repos,
202 DidHandleMap: map[string]string{ident.DID.String(): ident.Handle.String()},
203 Card: pages.ProfileCard{
204 UserDid: ident.DID.String(),
205 UserHandle: ident.Handle.String(),
206 AvatarUri: profileAvatarUri,
207 Profile: profile,
208 FollowStatus: followStatus,
209 Followers: followers,
210 Following: following,
211 },
212 })
213}
214
215func (s *State) GetAvatarUri(handle string) string {
216 secret := s.config.Avatar.SharedSecret
217 h := hmac.New(sha256.New, []byte(secret))
218 h.Write([]byte(handle))
219 signature := hex.EncodeToString(h.Sum(nil))
220 return fmt.Sprintf("%s/%s/%s", s.config.Avatar.Host, signature, handle)
221}
222
223func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {
224 user := s.oauth.GetUser(r)
225
226 err := r.ParseForm()
227 if err != nil {
228 log.Println("invalid profile update form", err)
229 s.pages.Notice(w, "update-profile", "Invalid form.")
230 return
231 }
232
233 profile, err := db.GetProfile(s.db, user.Did)
234 if err != nil {
235 log.Printf("getting profile data for %s: %s", user.Did, err)
236 }
237
238 profile.Description = r.FormValue("description")
239 profile.IncludeBluesky = r.FormValue("includeBluesky") == "on"
240 profile.Location = r.FormValue("location")
241
242 var links [5]string
243 for i := range 5 {
244 iLink := r.FormValue(fmt.Sprintf("link%d", i))
245 links[i] = iLink
246 }
247 profile.Links = links
248
249 // Parse stats (exactly 2)
250 stat0 := r.FormValue("stat0")
251 stat1 := r.FormValue("stat1")
252
253 if stat0 != "" {
254 profile.Stats[0].Kind = db.VanityStatKind(stat0)
255 }
256
257 if stat1 != "" {
258 profile.Stats[1].Kind = db.VanityStatKind(stat1)
259 }
260
261 if err := db.ValidateProfile(s.db, profile); err != nil {
262 log.Println("invalid profile", err)
263 s.pages.Notice(w, "update-profile", err.Error())
264 return
265 }
266
267 s.updateProfile(profile, w, r)
268 return
269}
270
271func (s *State) UpdateProfilePins(w http.ResponseWriter, r *http.Request) {
272 user := s.oauth.GetUser(r)
273
274 err := r.ParseForm()
275 if err != nil {
276 log.Println("invalid profile update form", err)
277 s.pages.Notice(w, "update-profile", "Invalid form.")
278 return
279 }
280
281 profile, err := db.GetProfile(s.db, user.Did)
282 if err != nil {
283 log.Printf("getting profile data for %s: %s", user.Did, err)
284 }
285
286 i := 0
287 var pinnedRepos [6]syntax.ATURI
288 for key, values := range r.Form {
289 if i >= 6 {
290 log.Println("invalid pin update form", err)
291 s.pages.Notice(w, "update-profile", "Only 6 repositories can be pinned at a time.")
292 return
293 }
294 if strings.HasPrefix(key, "pinnedRepo") && len(values) > 0 && values[0] != "" && i < 6 {
295 aturi, err := syntax.ParseATURI(values[0])
296 if err != nil {
297 log.Println("invalid profile update form", err)
298 s.pages.Notice(w, "update-profile", "Invalid form.")
299 return
300 }
301 pinnedRepos[i] = aturi
302 i++
303 }
304 }
305 profile.PinnedRepos = pinnedRepos
306
307 s.updateProfile(profile, w, r)
308 return
309}
310
311func (s *State) updateProfile(profile *db.Profile, w http.ResponseWriter, r *http.Request) {
312 user := s.oauth.GetUser(r)
313 tx, err := s.db.BeginTx(r.Context(), nil)
314 if err != nil {
315 log.Println("failed to start transaction", err)
316 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
317 return
318 }
319
320 client, err := s.oauth.AuthorizedClient(r)
321 if err != nil {
322 log.Println("failed to get authorized client", err)
323 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
324 return
325 }
326
327 // yeah... lexgen dose not support syntax.ATURI in the record for some reason,
328 // nor does it support exact size arrays
329 var pinnedRepoStrings []string
330 for _, r := range profile.PinnedRepos {
331 pinnedRepoStrings = append(pinnedRepoStrings, r.String())
332 }
333
334 var vanityStats []string
335 for _, v := range profile.Stats {
336 vanityStats = append(vanityStats, string(v.Kind))
337 }
338
339 ex, _ := client.RepoGetRecord(r.Context(), "", tangled.ActorProfileNSID, user.Did, "self")
340 var cid *string
341 if ex != nil {
342 cid = ex.Cid
343 }
344
345 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
346 Collection: tangled.ActorProfileNSID,
347 Repo: user.Did,
348 Rkey: "self",
349 Record: &lexutil.LexiconTypeDecoder{
350 Val: &tangled.ActorProfile{
351 Bluesky: profile.IncludeBluesky,
352 Description: &profile.Description,
353 Links: profile.Links[:],
354 Location: &profile.Location,
355 PinnedRepositories: pinnedRepoStrings,
356 Stats: vanityStats[:],
357 }},
358 SwapRecord: cid,
359 })
360 if err != nil {
361 log.Println("failed to update profile", err)
362 s.pages.Notice(w, "update-profile", "Failed to update PDS, try again later.")
363 return
364 }
365
366 err = db.UpsertProfile(tx, profile)
367 if err != nil {
368 log.Println("failed to update profile", err)
369 s.pages.Notice(w, "update-profile", "Failed to update profile, try again later.")
370 return
371 }
372
373 s.notifier.UpdateProfile(r.Context(), profile)
374
375 s.pages.HxRedirect(w, "/"+user.Did)
376 return
377}
378
379func (s *State) EditBioFragment(w http.ResponseWriter, r *http.Request) {
380 user := s.oauth.GetUser(r)
381
382 profile, err := db.GetProfile(s.db, user.Did)
383 if err != nil {
384 log.Printf("getting profile data for %s: %s", user.Did, err)
385 }
386
387 s.pages.EditBioFragment(w, pages.EditBioParams{
388 LoggedInUser: user,
389 Profile: profile,
390 })
391}
392
393func (s *State) EditPinsFragment(w http.ResponseWriter, r *http.Request) {
394 user := s.oauth.GetUser(r)
395
396 profile, err := db.GetProfile(s.db, user.Did)
397 if err != nil {
398 log.Printf("getting profile data for %s: %s", user.Did, err)
399 }
400
401 repos, err := db.GetAllReposByDid(s.db, user.Did)
402 if err != nil {
403 log.Printf("getting repos for %s: %s", user.Did, err)
404 }
405
406 collaboratingRepos, err := db.CollaboratingIn(s.db, user.Did)
407 if err != nil {
408 log.Printf("getting collaborating repos for %s: %s", user.Did, err)
409 }
410
411 allRepos := []pages.PinnedRepo{}
412
413 for _, r := range repos {
414 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
415 allRepos = append(allRepos, pages.PinnedRepo{
416 IsPinned: isPinned,
417 Repo: r,
418 })
419 }
420 for _, r := range collaboratingRepos {
421 isPinned := slices.Contains(profile.PinnedRepos[:], r.RepoAt())
422 allRepos = append(allRepos, pages.PinnedRepo{
423 IsPinned: isPinned,
424 Repo: r,
425 })
426 }
427
428 var didsToResolve []string
429 for _, r := range allRepos {
430 didsToResolve = append(didsToResolve, r.Did)
431 }
432 resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
433 didHandleMap := make(map[string]string)
434 for _, identity := range resolvedIds {
435 if !identity.Handle.IsInvalidHandle() {
436 didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())
437 } else {
438 didHandleMap[identity.DID.String()] = identity.DID.String()
439 }
440 }
441
442 s.pages.EditPinsFragment(w, pages.EditPinsParams{
443 LoggedInUser: user,
444 Profile: profile,
445 AllRepos: allRepos,
446 DidHandleMap: didHandleMap,
447 })
448}