tangled.org
+18
-18
appview/issues/issues.go
+18
-18
appview/issues/issues.go
···
72
return
73
}
74
75
-
issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt, issueIdInt)
76
if err != nil {
77
log.Println("failed to get issue and comments", err)
78
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
126
return
127
}
128
129
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
130
if err != nil {
131
log.Println("failed to get issue", err)
132
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
170
return
171
}
172
173
-
err = db.CloseIssue(rp.db, f.RepoAt, issueIdInt)
174
if err != nil {
175
log.Println("failed to close issue", err)
176
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
202
return
203
}
204
205
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
206
if err != nil {
207
log.Println("failed to get issue", err)
208
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
219
isIssueOwner := user.Did == issue.OwnerDid
220
221
if isCollaborator || isIssueOwner {
222
-
err := db.ReopenIssue(rp.db, f.RepoAt, issueIdInt)
223
if err != nil {
224
log.Println("failed to reopen issue", err)
225
rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
263
264
err := db.NewIssueComment(rp.db, &db.Comment{
265
OwnerDid: user.Did,
266
-
RepoAt: f.RepoAt,
267
Issue: issueIdInt,
268
CommentId: commentId,
269
Body: body,
···
278
createdAt := time.Now().Format(time.RFC3339)
279
commentIdInt64 := int64(commentId)
280
ownerDid := user.Did
281
-
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt, issueIdInt)
282
if err != nil {
283
log.Println("failed to get issue at", err)
284
rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
285
return
286
}
287
288
-
atUri := f.RepoAt.String()
289
client, err := rp.oauth.AuthorizedClient(r)
290
if err != nil {
291
log.Println("failed to get authorized client", err)
···
342
return
343
}
344
345
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
346
if err != nil {
347
log.Println("failed to get issue", err)
348
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
349
return
350
}
351
352
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
353
if err != nil {
354
http.Error(w, "bad comment id", http.StatusBadRequest)
355
return
···
387
return
388
}
389
390
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
391
if err != nil {
392
log.Println("failed to get issue", err)
393
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
394
return
395
}
396
397
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
398
if err != nil {
399
http.Error(w, "bad comment id", http.StatusBadRequest)
400
return
···
505
return
506
}
507
508
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
509
if err != nil {
510
log.Println("failed to get issue", err)
511
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
520
return
521
}
522
523
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
524
if err != nil {
525
http.Error(w, "bad comment id", http.StatusBadRequest)
526
return
···
538
539
// optimistic deletion
540
deleted := time.Now()
541
-
err = db.DeleteComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
542
if err != nil {
543
log.Println("failed to delete comment")
544
rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
602
return
603
}
604
605
-
issues, err := db.GetIssues(rp.db, f.RepoAt, isOpen, page)
606
if err != nil {
607
log.Println("failed to get issues", err)
608
rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
649
}
650
651
issue := &db.Issue{
652
-
RepoAt: f.RepoAt,
653
Rkey: tid.TID(),
654
Title: title,
655
Body: body,
···
668
rp.pages.Notice(w, "issues", "Failed to create issue.")
669
return
670
}
671
-
atUri := f.RepoAt.String()
672
_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
673
Collection: tangled.RepoIssueNSID,
674
Repo: user.Did,
···
72
return
73
}
74
75
+
issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt(), issueIdInt)
76
if err != nil {
77
log.Println("failed to get issue and comments", err)
78
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
126
return
127
}
128
129
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
130
if err != nil {
131
log.Println("failed to get issue", err)
132
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
170
return
171
}
172
173
+
err = db.CloseIssue(rp.db, f.RepoAt(), issueIdInt)
174
if err != nil {
175
log.Println("failed to close issue", err)
176
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
202
return
203
}
204
205
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
206
if err != nil {
207
log.Println("failed to get issue", err)
208
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
219
isIssueOwner := user.Did == issue.OwnerDid
220
221
if isCollaborator || isIssueOwner {
222
+
err := db.ReopenIssue(rp.db, f.RepoAt(), issueIdInt)
223
if err != nil {
224
log.Println("failed to reopen issue", err)
225
rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
263
264
err := db.NewIssueComment(rp.db, &db.Comment{
265
OwnerDid: user.Did,
266
+
RepoAt: f.RepoAt(),
267
Issue: issueIdInt,
268
CommentId: commentId,
269
Body: body,
···
278
createdAt := time.Now().Format(time.RFC3339)
279
commentIdInt64 := int64(commentId)
280
ownerDid := user.Did
281
+
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt)
282
if err != nil {
283
log.Println("failed to get issue at", err)
284
rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
285
return
286
}
287
288
+
atUri := f.RepoAt().String()
289
client, err := rp.oauth.AuthorizedClient(r)
290
if err != nil {
291
log.Println("failed to get authorized client", err)
···
342
return
343
}
344
345
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
346
if err != nil {
347
log.Println("failed to get issue", err)
348
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
349
return
350
}
351
352
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
353
if err != nil {
354
http.Error(w, "bad comment id", http.StatusBadRequest)
355
return
···
387
return
388
}
389
390
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
391
if err != nil {
392
log.Println("failed to get issue", err)
393
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
394
return
395
}
396
397
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
398
if err != nil {
399
http.Error(w, "bad comment id", http.StatusBadRequest)
400
return
···
505
return
506
}
507
508
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
509
if err != nil {
510
log.Println("failed to get issue", err)
511
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
520
return
521
}
522
523
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
524
if err != nil {
525
http.Error(w, "bad comment id", http.StatusBadRequest)
526
return
···
538
539
// optimistic deletion
540
deleted := time.Now()
541
+
err = db.DeleteComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
542
if err != nil {
543
log.Println("failed to delete comment")
544
rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
602
return
603
}
604
605
+
issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page)
606
if err != nil {
607
log.Println("failed to get issues", err)
608
rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
649
}
650
651
issue := &db.Issue{
652
+
RepoAt: f.RepoAt(),
653
Rkey: tid.TID(),
654
Title: title,
655
Body: body,
···
668
rp.pages.Notice(w, "issues", "Failed to create issue.")
669
return
670
}
671
+
atUri := f.RepoAt().String()
672
_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
673
Collection: tangled.RepoIssueNSID,
674
Repo: user.Did,
+3
-8
appview/middleware/middleware.go
+3
-8
appview/middleware/middleware.go
···
9
"slices"
10
"strconv"
11
"strings"
12
-
"time"
13
14
"github.com/bluesky-social/indigo/atproto/identity"
15
"github.com/go-chi/chi/v5"
···
222
return
223
}
224
225
-
ctx := context.WithValue(req.Context(), "knot", repo.Knot)
226
-
ctx = context.WithValue(ctx, "repoAt", repo.AtUri)
227
-
ctx = context.WithValue(ctx, "repoDescription", repo.Description)
228
-
ctx = context.WithValue(ctx, "repoSpindle", repo.Spindle)
229
-
ctx = context.WithValue(ctx, "repoAddedAt", repo.Created.Format(time.RFC3339))
230
next.ServeHTTP(w, req.WithContext(ctx))
231
})
232
}
···
251
return
252
}
253
254
-
pr, err := db.GetPull(mw.db, f.RepoAt, prIdInt)
255
if err != nil {
256
log.Println("failed to get pull and comments", err)
257
return
···
292
return
293
}
294
295
-
fullName := f.OwnerHandle() + "/" + f.RepoName
296
297
if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
298
if r.URL.Query().Get("go-get") == "1" {
···
9
"slices"
10
"strconv"
11
"strings"
12
13
"github.com/bluesky-social/indigo/atproto/identity"
14
"github.com/go-chi/chi/v5"
···
221
return
222
}
223
224
+
ctx := context.WithValue(req.Context(), "repo", repo)
225
next.ServeHTTP(w, req.WithContext(ctx))
226
})
227
}
···
246
return
247
}
248
249
+
pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)
250
if err != nil {
251
log.Println("failed to get pull and comments", err)
252
return
···
287
return
288
}
289
290
+
fullName := f.OwnerHandle() + "/" + f.Name
291
292
if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
293
if r.URL.Query().Get("go-get") == "1" {
+21
-21
appview/pulls/pulls.go
+21
-21
appview/pulls/pulls.go
···
246
patch = mergeable.CombinedPatch()
247
}
248
249
-
resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch)
250
if err != nil {
251
log.Println("failed to check for mergeability:", err)
252
return types.MergeCheckResponse{
···
307
// pulls within the same repo
308
knot = f.Knot
309
ownerDid = f.OwnerDid()
310
-
repoName = f.RepoName
311
}
312
313
us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
···
483
484
pulls, err := db.GetPulls(
485
s.db,
486
-
db.FilterEq("repo_at", f.RepoAt),
487
db.FilterEq("state", state),
488
)
489
if err != nil {
···
610
createdAt := time.Now().Format(time.RFC3339)
611
ownerDid := user.Did
612
613
-
pullAt, err := db.GetPullAt(s.db, f.RepoAt, pull.PullId)
614
if err != nil {
615
log.Println("failed to get pull at", err)
616
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
617
return
618
}
619
620
-
atUri := f.RepoAt.String()
621
client, err := s.oauth.AuthorizedClient(r)
622
if err != nil {
623
log.Println("failed to get authorized client", err)
···
646
647
comment := &db.PullComment{
648
OwnerDid: user.Did,
649
-
RepoAt: f.RepoAt.String(),
650
PullId: pull.PullId,
651
Body: body,
652
CommentAt: atResp.Uri,
···
692
return
693
}
694
695
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
696
if err != nil {
697
log.Println("failed to fetch branches", err)
698
return
···
816
return
817
}
818
819
-
comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch)
820
if err != nil {
821
log.Println("failed to compare", err)
822
s.pages.Notice(w, "pull", err.Error())
···
1007
Body: body,
1008
TargetBranch: targetBranch,
1009
OwnerDid: user.Did,
1010
-
RepoAt: f.RepoAt,
1011
Rkey: rkey,
1012
Submissions: []*db.PullSubmission{
1013
&initialSubmission,
···
1020
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1021
return
1022
}
1023
-
pullId, err := db.NextPullId(tx, f.RepoAt)
1024
if err != nil {
1025
log.Println("failed to get pull id", err)
1026
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
1035
Val: &tangled.RepoPull{
1036
Title: title,
1037
PullId: int64(pullId),
1038
-
TargetRepo: string(f.RepoAt),
1039
TargetBranch: targetBranch,
1040
Patch: patch,
1041
Source: recordPullSource,
···
1213
return
1214
}
1215
1216
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
1217
if err != nil {
1218
log.Println("failed to reach knotserver", err)
1219
return
···
1297
return
1298
}
1299
1300
-
targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)
1301
if err != nil {
1302
log.Println("failed to reach knotserver for target branches", err)
1303
return
···
1413
return
1414
}
1415
1416
-
comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch)
1417
if err != nil {
1418
log.Printf("compare request failed: %s", err)
1419
s.pages.Notice(w, "resubmit-error", err.Error())
···
1597
Val: &tangled.RepoPull{
1598
Title: pull.Title,
1599
PullId: int64(pull.PullId),
1600
-
TargetRepo: string(f.RepoAt),
1601
TargetBranch: pull.TargetBranch,
1602
Patch: patch, // new patch
1603
Source: recordPullSource,
···
1934
}
1935
1936
// Merge the pull request
1937
-
resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address)
1938
if err != nil {
1939
log.Printf("failed to merge pull request: %s", err)
1940
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
1956
defer tx.Rollback()
1957
1958
for _, p := range pullsToMerge {
1959
-
err := db.MergePull(tx, f.RepoAt, p.PullId)
1960
if err != nil {
1961
log.Printf("failed to update pull request status in database: %s", err)
1962
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
1972
return
1973
}
1974
1975
-
s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.RepoName, pull.PullId))
1976
}
1977
1978
func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {
···
2024
2025
for _, p := range pullsToClose {
2026
// Close the pull in the database
2027
-
err = db.ClosePull(tx, f.RepoAt, p.PullId)
2028
if err != nil {
2029
log.Println("failed to close pull", err)
2030
s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
2092
2093
for _, p := range pullsToReopen {
2094
// Close the pull in the database
2095
-
err = db.ReopenPull(tx, f.RepoAt, p.PullId)
2096
if err != nil {
2097
log.Println("failed to close pull", err)
2098
s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
2144
Body: body,
2145
TargetBranch: targetBranch,
2146
OwnerDid: user.Did,
2147
-
RepoAt: f.RepoAt,
2148
Rkey: rkey,
2149
Submissions: []*db.PullSubmission{
2150
&initialSubmission,
···
246
patch = mergeable.CombinedPatch()
247
}
248
249
+
resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch)
250
if err != nil {
251
log.Println("failed to check for mergeability:", err)
252
return types.MergeCheckResponse{
···
307
// pulls within the same repo
308
knot = f.Knot
309
ownerDid = f.OwnerDid()
310
+
repoName = f.Name
311
}
312
313
us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
···
483
484
pulls, err := db.GetPulls(
485
s.db,
486
+
db.FilterEq("repo_at", f.RepoAt()),
487
db.FilterEq("state", state),
488
)
489
if err != nil {
···
610
createdAt := time.Now().Format(time.RFC3339)
611
ownerDid := user.Did
612
613
+
pullAt, err := db.GetPullAt(s.db, f.RepoAt(), pull.PullId)
614
if err != nil {
615
log.Println("failed to get pull at", err)
616
s.pages.Notice(w, "pull-comment", "Failed to create comment.")
617
return
618
}
619
620
+
atUri := f.RepoAt().String()
621
client, err := s.oauth.AuthorizedClient(r)
622
if err != nil {
623
log.Println("failed to get authorized client", err)
···
646
647
comment := &db.PullComment{
648
OwnerDid: user.Did,
649
+
RepoAt: f.RepoAt().String(),
650
PullId: pull.PullId,
651
Body: body,
652
CommentAt: atResp.Uri,
···
692
return
693
}
694
695
+
result, err := us.Branches(f.OwnerDid(), f.Name)
696
if err != nil {
697
log.Println("failed to fetch branches", err)
698
return
···
816
return
817
}
818
819
+
comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, targetBranch, sourceBranch)
820
if err != nil {
821
log.Println("failed to compare", err)
822
s.pages.Notice(w, "pull", err.Error())
···
1007
Body: body,
1008
TargetBranch: targetBranch,
1009
OwnerDid: user.Did,
1010
+
RepoAt: f.RepoAt(),
1011
Rkey: rkey,
1012
Submissions: []*db.PullSubmission{
1013
&initialSubmission,
···
1020
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1021
return
1022
}
1023
+
pullId, err := db.NextPullId(tx, f.RepoAt())
1024
if err != nil {
1025
log.Println("failed to get pull id", err)
1026
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
1035
Val: &tangled.RepoPull{
1036
Title: title,
1037
PullId: int64(pullId),
1038
+
TargetRepo: string(f.RepoAt()),
1039
TargetBranch: targetBranch,
1040
Patch: patch,
1041
Source: recordPullSource,
···
1213
return
1214
}
1215
1216
+
result, err := us.Branches(f.OwnerDid(), f.Name)
1217
if err != nil {
1218
log.Println("failed to reach knotserver", err)
1219
return
···
1297
return
1298
}
1299
1300
+
targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.Name)
1301
if err != nil {
1302
log.Println("failed to reach knotserver for target branches", err)
1303
return
···
1413
return
1414
}
1415
1416
+
comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, pull.TargetBranch, pull.PullSource.Branch)
1417
if err != nil {
1418
log.Printf("compare request failed: %s", err)
1419
s.pages.Notice(w, "resubmit-error", err.Error())
···
1597
Val: &tangled.RepoPull{
1598
Title: pull.Title,
1599
PullId: int64(pull.PullId),
1600
+
TargetRepo: string(f.RepoAt()),
1601
TargetBranch: pull.TargetBranch,
1602
Patch: patch, // new patch
1603
Source: recordPullSource,
···
1934
}
1935
1936
// Merge the pull request
1937
+
resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address)
1938
if err != nil {
1939
log.Printf("failed to merge pull request: %s", err)
1940
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
1956
defer tx.Rollback()
1957
1958
for _, p := range pullsToMerge {
1959
+
err := db.MergePull(tx, f.RepoAt(), p.PullId)
1960
if err != nil {
1961
log.Printf("failed to update pull request status in database: %s", err)
1962
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
1972
return
1973
}
1974
1975
+
s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId))
1976
}
1977
1978
func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {
···
2024
2025
for _, p := range pullsToClose {
2026
// Close the pull in the database
2027
+
err = db.ClosePull(tx, f.RepoAt(), p.PullId)
2028
if err != nil {
2029
log.Println("failed to close pull", err)
2030
s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
2092
2093
for _, p := range pullsToReopen {
2094
// Close the pull in the database
2095
+
err = db.ReopenPull(tx, f.RepoAt(), p.PullId)
2096
if err != nil {
2097
log.Println("failed to close pull", err)
2098
s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
2144
Body: body,
2145
TargetBranch: targetBranch,
2146
OwnerDid: user.Did,
2147
+
RepoAt: f.RepoAt(),
2148
Rkey: rkey,
2149
Submissions: []*db.PullSubmission{
2150
&initialSubmission,
+6
-6
appview/repo/artifact.go
+6
-6
appview/repo/artifact.go
···
76
Artifact: uploadBlobResp.Blob,
77
CreatedAt: createdAt.Format(time.RFC3339),
78
Name: handler.Filename,
79
-
Repo: f.RepoAt.String(),
80
Tag: tag.Tag.Hash[:],
81
},
82
},
···
100
artifact := db.Artifact{
101
Did: user.Did,
102
Rkey: rkey,
103
-
RepoAt: f.RepoAt,
104
Tag: tag.Tag.Hash,
105
CreatedAt: createdAt,
106
BlobCid: cid.Cid(uploadBlobResp.Blob.Ref),
···
155
156
artifacts, err := db.GetArtifact(
157
rp.db,
158
-
db.FilterEq("repo_at", f.RepoAt),
159
db.FilterEq("tag", tag.Tag.Hash[:]),
160
db.FilterEq("name", filename),
161
)
···
197
198
artifacts, err := db.GetArtifact(
199
rp.db,
200
-
db.FilterEq("repo_at", f.RepoAt),
201
db.FilterEq("tag", tag[:]),
202
db.FilterEq("name", filename),
203
)
···
239
defer tx.Rollback()
240
241
err = db.DeleteArtifact(tx,
242
-
db.FilterEq("repo_at", f.RepoAt),
243
db.FilterEq("tag", artifact.Tag[:]),
244
db.FilterEq("name", filename),
245
)
···
270
return nil, err
271
}
272
273
-
result, err := us.Tags(f.OwnerDid(), f.RepoName)
274
if err != nil {
275
log.Println("failed to reach knotserver", err)
276
return nil, err
···
76
Artifact: uploadBlobResp.Blob,
77
CreatedAt: createdAt.Format(time.RFC3339),
78
Name: handler.Filename,
79
+
Repo: f.RepoAt().String(),
80
Tag: tag.Tag.Hash[:],
81
},
82
},
···
100
artifact := db.Artifact{
101
Did: user.Did,
102
Rkey: rkey,
103
+
RepoAt: f.RepoAt(),
104
Tag: tag.Tag.Hash,
105
CreatedAt: createdAt,
106
BlobCid: cid.Cid(uploadBlobResp.Blob.Ref),
···
155
156
artifacts, err := db.GetArtifact(
157
rp.db,
158
+
db.FilterEq("repo_at", f.RepoAt()),
159
db.FilterEq("tag", tag.Tag.Hash[:]),
160
db.FilterEq("name", filename),
161
)
···
197
198
artifacts, err := db.GetArtifact(
199
rp.db,
200
+
db.FilterEq("repo_at", f.RepoAt()),
201
db.FilterEq("tag", tag[:]),
202
db.FilterEq("name", filename),
203
)
···
239
defer tx.Rollback()
240
241
err = db.DeleteArtifact(tx,
242
+
db.FilterEq("repo_at", f.RepoAt()),
243
db.FilterEq("tag", artifact.Tag[:]),
244
db.FilterEq("name", filename),
245
)
···
270
return nil, err
271
}
272
273
+
result, err := us.Tags(f.OwnerDid(), f.Name)
274
if err != nil {
275
log.Println("failed to reach knotserver", err)
276
return nil, err
+5
-5
appview/repo/index.go
+5
-5
appview/repo/index.go
···
37
return
38
}
39
40
-
result, err := us.Index(f.OwnerDid(), f.RepoName, ref)
41
if err != nil {
42
rp.pages.Error503(w)
43
log.Println("failed to reach knotserver", err)
···
166
// first attempt to fetch from db
167
langs, err := db.GetRepoLanguages(
168
rp.db,
169
-
db.FilterEq("repo_at", f.RepoAt),
170
db.FilterEq("ref", f.Ref),
171
)
172
173
if err != nil || langs == nil {
174
// non-fatal, fetch langs from ks
175
-
ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.RepoName, f.Ref)
176
if err != nil {
177
return nil, err
178
}
···
182
183
for l, s := range ls.Languages {
184
langs = append(langs, db.RepoLanguage{
185
-
RepoAt: f.RepoAt,
186
Ref: f.Ref,
187
IsDefaultRef: isDefaultRef,
188
Language: l,
···
279
hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref)
280
281
var status types.AncestorCheckResponse
282
-
forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt), repoInfo.Name, f.Ref, hiddenRef)
283
if err != nil {
284
log.Printf("failed to check if fork is ahead/behind: %s", err)
285
return nil, err
···
37
return
38
}
39
40
+
result, err := us.Index(f.OwnerDid(), f.Name, ref)
41
if err != nil {
42
rp.pages.Error503(w)
43
log.Println("failed to reach knotserver", err)
···
166
// first attempt to fetch from db
167
langs, err := db.GetRepoLanguages(
168
rp.db,
169
+
db.FilterEq("repo_at", f.RepoAt()),
170
db.FilterEq("ref", f.Ref),
171
)
172
173
if err != nil || langs == nil {
174
// non-fatal, fetch langs from ks
175
+
ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, f.Ref)
176
if err != nil {
177
return nil, err
178
}
···
182
183
for l, s := range ls.Languages {
184
langs = append(langs, db.RepoLanguage{
185
+
RepoAt: f.RepoAt(),
186
Ref: f.Ref,
187
IsDefaultRef: isDefaultRef,
188
Language: l,
···
279
hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref)
280
281
var status types.AncestorCheckResponse
282
+
forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, f.Ref, hiddenRef)
283
if err != nil {
284
log.Printf("failed to check if fork is ahead/behind: %s", err)
285
return nil, err
+45
-46
appview/repo/repo.go
+45
-46
appview/repo/repo.go
···
95
} else {
96
uri = "https"
97
}
98
-
url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.RepoName, url.PathEscape(refParam))
99
100
http.Redirect(w, r, url, http.StatusFound)
101
}
···
123
return
124
}
125
126
-
repolog, err := us.Log(f.OwnerDid(), f.RepoName, ref, page)
127
if err != nil {
128
log.Println("failed to reach knotserver", err)
129
return
130
}
131
132
-
tagResult, err := us.Tags(f.OwnerDid(), f.RepoName)
133
if err != nil {
134
log.Println("failed to reach knotserver", err)
135
return
···
144
tagMap[hash] = append(tagMap[hash], tag.Name)
145
}
146
147
-
branchResult, err := us.Branches(f.OwnerDid(), f.RepoName)
148
if err != nil {
149
log.Println("failed to reach knotserver", err)
150
return
···
212
return
213
}
214
215
-
repoAt := f.RepoAt
216
rkey := repoAt.RecordKey().String()
217
if rkey == "" {
218
log.Println("invalid aturi for repo", err)
···
262
Record: &lexutil.LexiconTypeDecoder{
263
Val: &tangled.Repo{
264
Knot: f.Knot,
265
-
Name: f.RepoName,
266
Owner: user.Did,
267
-
CreatedAt: f.CreatedAt,
268
Description: &newDescription,
269
Spindle: &f.Spindle,
270
},
···
310
return
311
}
312
313
-
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref))
314
if err != nil {
315
log.Println("failed to reach knotserver", err)
316
return
···
375
if !rp.config.Core.Dev {
376
protocol = "https"
377
}
378
-
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, treePath))
379
if err != nil {
380
log.Println("failed to reach knotserver", err)
381
return
···
405
user := rp.oauth.GetUser(r)
406
407
var breadcrumbs [][]string
408
-
breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
409
if treePath != "" {
410
for idx, elem := range strings.Split(treePath, "/") {
411
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
436
return
437
}
438
439
-
result, err := us.Tags(f.OwnerDid(), f.RepoName)
440
if err != nil {
441
log.Println("failed to reach knotserver", err)
442
return
443
}
444
445
-
artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt))
446
if err != nil {
447
log.Println("failed grab artifacts", err)
448
return
···
493
return
494
}
495
496
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
497
if err != nil {
498
log.Println("failed to reach knotserver", err)
499
return
···
522
if !rp.config.Core.Dev {
523
protocol = "https"
524
}
525
-
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath))
526
if err != nil {
527
log.Println("failed to reach knotserver", err)
528
return
···
542
}
543
544
var breadcrumbs [][]string
545
-
breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
546
if filePath != "" {
547
for idx, elem := range strings.Split(filePath, "/") {
548
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
575
576
// fetch the actual binary content like in RepoBlobRaw
577
578
-
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath)
579
contentSrc = blobURL
580
if !rp.config.Core.Dev {
581
contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)
···
612
if !rp.config.Core.Dev {
613
protocol = "https"
614
}
615
-
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath)
616
resp, err := http.Get(blobURL)
617
if err != nil {
618
log.Println("failed to reach knotserver:", err)
···
668
return
669
}
670
671
-
repoAt := f.RepoAt
672
rkey := repoAt.RecordKey().String()
673
if rkey == "" {
674
fail("Failed to resolve repo. Try again later", err)
···
722
Record: &lexutil.LexiconTypeDecoder{
723
Val: &tangled.Repo{
724
Knot: f.Knot,
725
-
Name: f.RepoName,
726
Owner: user.Did,
727
-
CreatedAt: f.CreatedAt,
728
Description: &f.Description,
729
Spindle: spindlePtr,
730
},
···
805
Record: &lexutil.LexiconTypeDecoder{
806
Val: &tangled.RepoCollaborator{
807
Subject: collaboratorIdent.DID.String(),
808
-
Repo: string(f.RepoAt),
809
CreatedAt: createdAt.Format(time.RFC3339),
810
}},
811
})
···
830
return
831
}
832
833
-
ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.RepoName, collaboratorIdent.DID.String())
834
if err != nil {
835
fail("Knot was unreachable.", err)
836
return
···
864
Did: syntax.DID(currentUser.Did),
865
Rkey: rkey,
866
SubjectDid: collaboratorIdent.DID,
867
-
RepoAt: f.RepoAt,
868
Created: createdAt,
869
})
870
if err != nil {
···
902
log.Println("failed to get authorized client", err)
903
return
904
}
905
-
repoRkey := f.RepoAt.RecordKey().String()
906
_, err = xrpcClient.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{
907
Collection: tangled.RepoNSID,
908
Repo: user.Did,
909
-
Rkey: repoRkey,
910
})
911
if err != nil {
912
log.Printf("failed to delete record: %s", err)
913
rp.pages.Notice(w, "settings-delete", "Failed to delete repository from PDS.")
914
return
915
}
916
-
log.Println("removed repo record ", f.RepoAt.String())
917
918
secret, err := db.GetRegistrationKey(rp.db, f.Knot)
919
if err != nil {
···
927
return
928
}
929
930
-
ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.RepoName)
931
if err != nil {
932
log.Printf("failed to make request to %s: %s", f.Knot, err)
933
return
···
973
}
974
975
// remove repo from db
976
-
err = db.RemoveRepo(tx, f.OwnerDid(), f.RepoName)
977
if err != nil {
978
rp.pages.Notice(w, "settings-delete", "Failed to update appview")
979
return
···
1022
return
1023
}
1024
1025
-
ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.RepoName, branch)
1026
if err != nil {
1027
log.Printf("failed to make request to %s: %s", f.Knot, err)
1028
return
···
1090
r.Context(),
1091
spindleClient,
1092
&tangled.RepoAddSecret_Input{
1093
-
Repo: f.RepoAt.String(),
1094
Key: key,
1095
Value: value,
1096
},
···
1108
r.Context(),
1109
spindleClient,
1110
&tangled.RepoRemoveSecret_Input{
1111
-
Repo: f.RepoAt.String(),
1112
Key: key,
1113
},
1114
)
···
1170
// return
1171
// }
1172
1173
-
// result, err := us.Branches(f.OwnerDid(), f.RepoName)
1174
// if err != nil {
1175
// log.Println("failed to reach knotserver", err)
1176
// return
···
1192
// oauth.WithDev(rp.config.Core.Dev),
1193
// ); err != nil {
1194
// log.Println("failed to create spindle client", err)
1195
-
// } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil {
1196
// log.Println("failed to fetch secrets", err)
1197
// } else {
1198
// secrets = resp.Secrets
···
1221
return
1222
}
1223
1224
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
1225
if err != nil {
1226
log.Println("failed to reach knotserver", err)
1227
return
···
1275
oauth.WithDev(rp.config.Core.Dev),
1276
); err != nil {
1277
log.Println("failed to create spindle client", err)
1278
-
} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil {
1279
log.Println("failed to fetch secrets", err)
1280
} else {
1281
secrets = resp.Secrets
···
1343
} else {
1344
uri = "https"
1345
}
1346
-
forkName := fmt.Sprintf("%s", f.RepoName)
1347
-
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
1348
1349
_, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, f.Ref)
1350
if err != nil {
···
1394
return
1395
}
1396
1397
-
forkName := fmt.Sprintf("%s", f.RepoName)
1398
1399
// this check is *only* to see if the forked repo name already exists
1400
// in the user's account.
1401
-
existingRepo, err := db.GetRepo(rp.db, user.Did, f.RepoName)
1402
if err != nil {
1403
if errors.Is(err, sql.ErrNoRows) {
1404
// no existing repo with this name found, we can use the name as is
···
1429
} else {
1430
uri = "https"
1431
}
1432
-
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
1433
-
sourceAt := f.RepoAt.String()
1434
1435
rkey := tid.TID()
1436
repo := &db.Repo{
···
1550
return
1551
}
1552
1553
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
1554
if err != nil {
1555
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1556
log.Println("failed to reach knotserver", err)
···
1580
head = queryHead
1581
}
1582
1583
-
tags, err := us.Tags(f.OwnerDid(), f.RepoName)
1584
if err != nil {
1585
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1586
log.Println("failed to reach knotserver", err)
···
1642
return
1643
}
1644
1645
-
branches, err := us.Branches(f.OwnerDid(), f.RepoName)
1646
if err != nil {
1647
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1648
log.Println("failed to reach knotserver", err)
1649
return
1650
}
1651
1652
-
tags, err := us.Tags(f.OwnerDid(), f.RepoName)
1653
if err != nil {
1654
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1655
log.Println("failed to reach knotserver", err)
1656
return
1657
}
1658
1659
-
formatPatch, err := us.Compare(f.OwnerDid(), f.RepoName, base, head)
1660
if err != nil {
1661
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1662
log.Println("failed to compare", err)
···
95
} else {
96
uri = "https"
97
}
98
+
url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.Name, url.PathEscape(refParam))
99
100
http.Redirect(w, r, url, http.StatusFound)
101
}
···
123
return
124
}
125
126
+
repolog, err := us.Log(f.OwnerDid(), f.Name, ref, page)
127
if err != nil {
128
log.Println("failed to reach knotserver", err)
129
return
130
}
131
132
+
tagResult, err := us.Tags(f.OwnerDid(), f.Name)
133
if err != nil {
134
log.Println("failed to reach knotserver", err)
135
return
···
144
tagMap[hash] = append(tagMap[hash], tag.Name)
145
}
146
147
+
branchResult, err := us.Branches(f.OwnerDid(), f.Name)
148
if err != nil {
149
log.Println("failed to reach knotserver", err)
150
return
···
212
return
213
}
214
215
+
repoAt := f.RepoAt()
216
rkey := repoAt.RecordKey().String()
217
if rkey == "" {
218
log.Println("invalid aturi for repo", err)
···
262
Record: &lexutil.LexiconTypeDecoder{
263
Val: &tangled.Repo{
264
Knot: f.Knot,
265
+
Name: f.Name,
266
Owner: user.Did,
267
+
CreatedAt: f.Created.Format(time.RFC3339),
268
Description: &newDescription,
269
Spindle: &f.Spindle,
270
},
···
310
return
311
}
312
313
+
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref))
314
if err != nil {
315
log.Println("failed to reach knotserver", err)
316
return
···
375
if !rp.config.Core.Dev {
376
protocol = "https"
377
}
378
+
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, treePath))
379
if err != nil {
380
log.Println("failed to reach knotserver", err)
381
return
···
405
user := rp.oauth.GetUser(r)
406
407
var breadcrumbs [][]string
408
+
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
409
if treePath != "" {
410
for idx, elem := range strings.Split(treePath, "/") {
411
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
436
return
437
}
438
439
+
result, err := us.Tags(f.OwnerDid(), f.Name)
440
if err != nil {
441
log.Println("failed to reach knotserver", err)
442
return
443
}
444
445
+
artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))
446
if err != nil {
447
log.Println("failed grab artifacts", err)
448
return
···
493
return
494
}
495
496
+
result, err := us.Branches(f.OwnerDid(), f.Name)
497
if err != nil {
498
log.Println("failed to reach knotserver", err)
499
return
···
522
if !rp.config.Core.Dev {
523
protocol = "https"
524
}
525
+
resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath))
526
if err != nil {
527
log.Println("failed to reach knotserver", err)
528
return
···
542
}
543
544
var breadcrumbs [][]string
545
+
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
546
if filePath != "" {
547
for idx, elem := range strings.Split(filePath, "/") {
548
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
575
576
// fetch the actual binary content like in RepoBlobRaw
577
578
+
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Name, ref, filePath)
579
contentSrc = blobURL
580
if !rp.config.Core.Dev {
581
contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)
···
612
if !rp.config.Core.Dev {
613
protocol = "https"
614
}
615
+
blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath)
616
resp, err := http.Get(blobURL)
617
if err != nil {
618
log.Println("failed to reach knotserver:", err)
···
668
return
669
}
670
671
+
repoAt := f.RepoAt()
672
rkey := repoAt.RecordKey().String()
673
if rkey == "" {
674
fail("Failed to resolve repo. Try again later", err)
···
722
Record: &lexutil.LexiconTypeDecoder{
723
Val: &tangled.Repo{
724
Knot: f.Knot,
725
+
Name: f.Name,
726
Owner: user.Did,
727
+
CreatedAt: f.Created.Format(time.RFC3339),
728
Description: &f.Description,
729
Spindle: spindlePtr,
730
},
···
805
Record: &lexutil.LexiconTypeDecoder{
806
Val: &tangled.RepoCollaborator{
807
Subject: collaboratorIdent.DID.String(),
808
+
Repo: string(f.RepoAt()),
809
CreatedAt: createdAt.Format(time.RFC3339),
810
}},
811
})
···
830
return
831
}
832
833
+
ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.Name, collaboratorIdent.DID.String())
834
if err != nil {
835
fail("Knot was unreachable.", err)
836
return
···
864
Did: syntax.DID(currentUser.Did),
865
Rkey: rkey,
866
SubjectDid: collaboratorIdent.DID,
867
+
RepoAt: f.RepoAt(),
868
Created: createdAt,
869
})
870
if err != nil {
···
902
log.Println("failed to get authorized client", err)
903
return
904
}
905
_, err = xrpcClient.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{
906
Collection: tangled.RepoNSID,
907
Repo: user.Did,
908
+
Rkey: f.Rkey,
909
})
910
if err != nil {
911
log.Printf("failed to delete record: %s", err)
912
rp.pages.Notice(w, "settings-delete", "Failed to delete repository from PDS.")
913
return
914
}
915
+
log.Println("removed repo record ", f.RepoAt().String())
916
917
secret, err := db.GetRegistrationKey(rp.db, f.Knot)
918
if err != nil {
···
926
return
927
}
928
929
+
ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.Name)
930
if err != nil {
931
log.Printf("failed to make request to %s: %s", f.Knot, err)
932
return
···
972
}
973
974
// remove repo from db
975
+
err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)
976
if err != nil {
977
rp.pages.Notice(w, "settings-delete", "Failed to update appview")
978
return
···
1021
return
1022
}
1023
1024
+
ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.Name, branch)
1025
if err != nil {
1026
log.Printf("failed to make request to %s: %s", f.Knot, err)
1027
return
···
1089
r.Context(),
1090
spindleClient,
1091
&tangled.RepoAddSecret_Input{
1092
+
Repo: f.RepoAt().String(),
1093
Key: key,
1094
Value: value,
1095
},
···
1107
r.Context(),
1108
spindleClient,
1109
&tangled.RepoRemoveSecret_Input{
1110
+
Repo: f.RepoAt().String(),
1111
Key: key,
1112
},
1113
)
···
1169
// return
1170
// }
1171
1172
+
// result, err := us.Branches(f.OwnerDid(), f.Name)
1173
// if err != nil {
1174
// log.Println("failed to reach knotserver", err)
1175
// return
···
1191
// oauth.WithDev(rp.config.Core.Dev),
1192
// ); err != nil {
1193
// log.Println("failed to create spindle client", err)
1194
+
// } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {
1195
// log.Println("failed to fetch secrets", err)
1196
// } else {
1197
// secrets = resp.Secrets
···
1220
return
1221
}
1222
1223
+
result, err := us.Branches(f.OwnerDid(), f.Name)
1224
if err != nil {
1225
log.Println("failed to reach knotserver", err)
1226
return
···
1274
oauth.WithDev(rp.config.Core.Dev),
1275
); err != nil {
1276
log.Println("failed to create spindle client", err)
1277
+
} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {
1278
log.Println("failed to fetch secrets", err)
1279
} else {
1280
secrets = resp.Secrets
···
1342
} else {
1343
uri = "https"
1344
}
1345
+
forkName := fmt.Sprintf("%s", f.Name)
1346
+
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
1347
1348
_, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, f.Ref)
1349
if err != nil {
···
1393
return
1394
}
1395
1396
+
forkName := fmt.Sprintf("%s", f.Name)
1397
1398
// this check is *only* to see if the forked repo name already exists
1399
// in the user's account.
1400
+
existingRepo, err := db.GetRepo(rp.db, user.Did, f.Name)
1401
if err != nil {
1402
if errors.Is(err, sql.ErrNoRows) {
1403
// no existing repo with this name found, we can use the name as is
···
1428
} else {
1429
uri = "https"
1430
}
1431
+
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
1432
+
sourceAt := f.RepoAt().String()
1433
1434
rkey := tid.TID()
1435
repo := &db.Repo{
···
1549
return
1550
}
1551
1552
+
result, err := us.Branches(f.OwnerDid(), f.Name)
1553
if err != nil {
1554
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1555
log.Println("failed to reach knotserver", err)
···
1579
head = queryHead
1580
}
1581
1582
+
tags, err := us.Tags(f.OwnerDid(), f.Name)
1583
if err != nil {
1584
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1585
log.Println("failed to reach knotserver", err)
···
1641
return
1642
}
1643
1644
+
branches, err := us.Branches(f.OwnerDid(), f.Name)
1645
if err != nil {
1646
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1647
log.Println("failed to reach knotserver", err)
1648
return
1649
}
1650
1651
+
tags, err := us.Tags(f.OwnerDid(), f.Name)
1652
if err != nil {
1653
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1654
log.Println("failed to reach knotserver", err)
1655
return
1656
}
1657
1658
+
formatPatch, err := us.Compare(f.OwnerDid(), f.Name, base, head)
1659
if err != nil {
1660
rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
1661
log.Println("failed to compare", err)
+25
-58
appview/reporesolver/resolver.go
+25
-58
appview/reporesolver/resolver.go
···
12
"strings"
13
14
"github.com/bluesky-social/indigo/atproto/identity"
15
-
"github.com/bluesky-social/indigo/atproto/syntax"
16
securejoin "github.com/cyphar/filepath-securejoin"
17
"github.com/go-chi/chi/v5"
18
"tangled.sh/tangled.sh/core/appview/config"
···
26
)
27
28
type ResolvedRepo struct {
29
-
Knot string
30
OwnerId identity.Identity
31
-
RepoName string
32
-
RepoAt syntax.ATURI
33
-
Description string
34
-
Spindle string
35
-
CreatedAt string
36
Ref string
37
CurrentDir string
38
···
51
}
52
53
func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
54
-
repoName := chi.URLParam(r, "repo")
55
-
knot, ok := r.Context().Value("knot").(string)
56
if !ok {
57
-
log.Println("malformed middleware")
58
return nil, fmt.Errorf("malformed middleware")
59
}
60
id, ok := r.Context().Value("resolvedId").(identity.Identity)
···
63
return nil, fmt.Errorf("malformed middleware")
64
}
65
66
-
repoAt, ok := r.Context().Value("repoAt").(string)
67
-
if !ok {
68
-
log.Println("malformed middleware")
69
-
return nil, fmt.Errorf("malformed middleware")
70
-
}
71
-
72
-
parsedRepoAt, err := syntax.ParseATURI(repoAt)
73
-
if err != nil {
74
-
log.Println("malformed repo at-uri")
75
-
return nil, fmt.Errorf("malformed middleware")
76
-
}
77
-
78
ref := chi.URLParam(r, "ref")
79
80
if ref == "" {
81
-
us, err := knotclient.NewUnsignedClient(knot, rr.config.Core.Dev)
82
if err != nil {
83
return nil, err
84
}
85
86
-
defaultBranch, err := us.DefaultBranch(id.DID.String(), repoName)
87
if err != nil {
88
return nil, err
89
}
···
93
94
currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath(), ref))
95
96
-
// pass through values from the middleware
97
-
description, ok := r.Context().Value("repoDescription").(string)
98
-
addedAt, ok := r.Context().Value("repoAddedAt").(string)
99
-
spindle, ok := r.Context().Value("repoSpindle").(string)
100
-
101
return &ResolvedRepo{
102
-
Knot: knot,
103
-
OwnerId: id,
104
-
RepoName: repoName,
105
-
RepoAt: parsedRepoAt,
106
-
Description: description,
107
-
CreatedAt: addedAt,
108
-
Ref: ref,
109
-
CurrentDir: currentDir,
110
-
Spindle: spindle,
111
112
rr: rr,
113
}, nil
···
126
127
var p string
128
if handle != "" && !handle.IsInvalidHandle() {
129
-
p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.RepoName)
130
} else {
131
-
p, _ = securejoin.SecureJoin(f.OwnerDid(), f.RepoName)
132
}
133
134
-
return p
135
-
}
136
-
137
-
func (f *ResolvedRepo) DidSlashRepo() string {
138
-
p, _ := securejoin.SecureJoin(f.OwnerDid(), f.RepoName)
139
return p
140
}
141
···
187
// this function is a bit weird since it now returns RepoInfo from an entirely different
188
// package. we should refactor this or get rid of RepoInfo entirely.
189
func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {
190
isStarred := false
191
if user != nil {
192
-
isStarred = db.GetStarStatus(f.rr.execer, user.Did, syntax.ATURI(f.RepoAt))
193
}
194
195
-
starCount, err := db.GetStarCount(f.rr.execer, f.RepoAt)
196
if err != nil {
197
-
log.Println("failed to get star count for ", f.RepoAt)
198
}
199
-
issueCount, err := db.GetIssueCount(f.rr.execer, f.RepoAt)
200
if err != nil {
201
-
log.Println("failed to get issue count for ", f.RepoAt)
202
}
203
-
pullCount, err := db.GetPullCount(f.rr.execer, f.RepoAt)
204
if err != nil {
205
-
log.Println("failed to get issue count for ", f.RepoAt)
206
}
207
-
source, err := db.GetRepoSource(f.rr.execer, f.RepoAt)
208
if errors.Is(err, sql.ErrNoRows) {
209
source = ""
210
} else if err != nil {
211
-
log.Println("failed to get repo source for ", f.RepoAt, err)
212
}
213
214
var sourceRepo *db.Repo
···
233
if err != nil {
234
log.Printf("failed to create unsigned client for %s: %v", knot, err)
235
} else {
236
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
237
if err != nil {
238
-
log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.RepoName, err)
239
}
240
241
if len(result.Branches) == 0 {
···
246
repoInfo := repoinfo.RepoInfo{
247
OwnerDid: f.OwnerDid(),
248
OwnerHandle: f.OwnerHandle(),
249
-
Name: f.RepoName,
250
-
RepoAt: f.RepoAt,
251
Description: f.Description,
252
Ref: f.Ref,
253
IsStarred: isStarred,
···
12
"strings"
13
14
"github.com/bluesky-social/indigo/atproto/identity"
15
securejoin "github.com/cyphar/filepath-securejoin"
16
"github.com/go-chi/chi/v5"
17
"tangled.sh/tangled.sh/core/appview/config"
···
25
)
26
27
type ResolvedRepo struct {
28
+
db.Repo
29
OwnerId identity.Identity
30
Ref string
31
CurrentDir string
32
···
45
}
46
47
func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
48
+
repo, ok := r.Context().Value("repo").(*db.Repo)
49
if !ok {
50
+
log.Println("malformed middleware: `repo` not exist in context")
51
return nil, fmt.Errorf("malformed middleware")
52
}
53
id, ok := r.Context().Value("resolvedId").(identity.Identity)
···
56
return nil, fmt.Errorf("malformed middleware")
57
}
58
59
ref := chi.URLParam(r, "ref")
60
61
if ref == "" {
62
+
us, err := knotclient.NewUnsignedClient(repo.Knot, rr.config.Core.Dev)
63
if err != nil {
64
return nil, err
65
}
66
67
+
defaultBranch, err := us.DefaultBranch(id.DID.String(), repo.Name)
68
if err != nil {
69
return nil, err
70
}
···
74
75
currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath(), ref))
76
77
return &ResolvedRepo{
78
+
Repo: *repo,
79
+
OwnerId: id,
80
+
Ref: ref,
81
+
CurrentDir: currentDir,
82
83
rr: rr,
84
}, nil
···
97
98
var p string
99
if handle != "" && !handle.IsInvalidHandle() {
100
+
p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.Name)
101
} else {
102
+
p, _ = securejoin.SecureJoin(f.OwnerDid(), f.Name)
103
}
104
105
return p
106
}
107
···
153
// this function is a bit weird since it now returns RepoInfo from an entirely different
154
// package. we should refactor this or get rid of RepoInfo entirely.
155
func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {
156
+
repoAt := f.RepoAt()
157
isStarred := false
158
if user != nil {
159
+
isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)
160
}
161
162
+
starCount, err := db.GetStarCount(f.rr.execer, repoAt)
163
if err != nil {
164
+
log.Println("failed to get star count for ", repoAt)
165
}
166
+
issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)
167
if err != nil {
168
+
log.Println("failed to get issue count for ", repoAt)
169
}
170
+
pullCount, err := db.GetPullCount(f.rr.execer, repoAt)
171
if err != nil {
172
+
log.Println("failed to get issue count for ", repoAt)
173
}
174
+
source, err := db.GetRepoSource(f.rr.execer, repoAt)
175
if errors.Is(err, sql.ErrNoRows) {
176
source = ""
177
} else if err != nil {
178
+
log.Println("failed to get repo source for ", repoAt, err)
179
}
180
181
var sourceRepo *db.Repo
···
200
if err != nil {
201
log.Printf("failed to create unsigned client for %s: %v", knot, err)
202
} else {
203
+
result, err := us.Branches(f.OwnerDid(), f.Name)
204
if err != nil {
205
+
log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.Name, err)
206
}
207
208
if len(result.Branches) == 0 {
···
213
repoInfo := repoinfo.RepoInfo{
214
OwnerDid: f.OwnerDid(),
215
OwnerHandle: f.OwnerHandle(),
216
+
Name: f.Name,
217
+
RepoAt: repoAt,
218
Description: f.Description,
219
Ref: f.Ref,
220
IsStarred: isStarred,