boltless.me
- reduce duplicated codes
- possibly remove/refactor
ResolvedRepoin future - allow accessing
db.Repoafter it is resolved
+19
-19
appview/issues/issues.go
+19
-19
appview/issues/issues.go
···
73
return
74
}
75
76
-
issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt, issueIdInt)
77
if err != nil {
78
log.Println("failed to get issue and comments", err)
79
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
127
return
128
}
129
130
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
131
if err != nil {
132
log.Println("failed to get issue", err)
133
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
171
return
172
}
173
174
-
err = db.CloseIssue(rp.db, f.RepoAt, issueIdInt)
175
if err != nil {
176
log.Println("failed to close issue", err)
177
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
203
return
204
}
205
206
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
207
if err != nil {
208
log.Println("failed to get issue", err)
209
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
220
isIssueOwner := user.Did == issue.OwnerDid
221
222
if isCollaborator || isIssueOwner {
223
-
err := db.ReopenIssue(rp.db, f.RepoAt, issueIdInt)
224
if err != nil {
225
log.Println("failed to reopen issue", err)
226
rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
264
265
err := db.NewIssueComment(rp.db, &db.Comment{
266
OwnerDid: user.Did,
267
-
RepoAt: f.RepoAt,
268
Issue: issueIdInt,
269
CommentId: commentId,
270
Body: body,
···
279
createdAt := time.Now().Format(time.RFC3339)
280
commentIdInt64 := int64(commentId)
281
ownerDid := user.Did
282
-
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt, issueIdInt)
283
if err != nil {
284
log.Println("failed to get issue at", err)
285
rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
286
return
287
}
288
289
-
atUri := f.RepoAt.String()
290
client, err := rp.oauth.AuthorizedClient(r)
291
if err != nil {
292
log.Println("failed to get authorized client", err)
···
343
return
344
}
345
346
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
347
if err != nil {
348
log.Println("failed to get issue", err)
349
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
350
return
351
}
352
353
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
354
if err != nil {
355
http.Error(w, "bad comment id", http.StatusBadRequest)
356
return
···
388
return
389
}
390
391
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
392
if err != nil {
393
log.Println("failed to get issue", err)
394
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
395
return
396
}
397
398
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
399
if err != nil {
400
http.Error(w, "bad comment id", http.StatusBadRequest)
401
return
···
506
return
507
}
508
509
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
510
if err != nil {
511
log.Println("failed to get issue", err)
512
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
521
return
522
}
523
524
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
525
if err != nil {
526
http.Error(w, "bad comment id", http.StatusBadRequest)
527
return
···
539
540
// optimistic deletion
541
deleted := time.Now()
542
-
err = db.DeleteComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
543
if err != nil {
544
log.Println("failed to delete comment")
545
rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
603
return
604
}
605
606
-
issues, err := db.GetIssues(rp.db, f.RepoAt, isOpen, page)
607
if err != nil {
608
log.Println("failed to get issues", err)
609
rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
650
}
651
652
issue := &db.Issue{
653
-
RepoAt: f.RepoAt,
654
Title: title,
655
Body: body,
656
OwnerDid: user.Did,
···
668
rp.pages.Notice(w, "issues", "Failed to create issue.")
669
return
670
}
671
-
atUri := f.RepoAt.String()
672
resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
673
Collection: tangled.RepoIssueNSID,
674
Repo: user.Did,
···
689
return
690
}
691
692
-
err = db.SetIssueAt(rp.db, f.RepoAt, issue.IssueId, resp.Uri)
693
if err != nil {
694
log.Println("failed to set issue at", err)
695
rp.pages.Notice(w, "issues", "Failed to create issue.")
···
73
return
74
}
75
76
+
issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt(), issueIdInt)
77
if err != nil {
78
log.Println("failed to get issue and comments", err)
79
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
127
return
128
}
129
130
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
131
if err != nil {
132
log.Println("failed to get issue", err)
133
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
171
return
172
}
173
174
+
err = db.CloseIssue(rp.db, f.RepoAt(), issueIdInt)
175
if err != nil {
176
log.Println("failed to close issue", err)
177
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
203
return
204
}
205
206
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
207
if err != nil {
208
log.Println("failed to get issue", err)
209
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
220
isIssueOwner := user.Did == issue.OwnerDid
221
222
if isCollaborator || isIssueOwner {
223
+
err := db.ReopenIssue(rp.db, f.RepoAt(), issueIdInt)
224
if err != nil {
225
log.Println("failed to reopen issue", err)
226
rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
264
265
err := db.NewIssueComment(rp.db, &db.Comment{
266
OwnerDid: user.Did,
267
+
RepoAt: f.RepoAt(),
268
Issue: issueIdInt,
269
CommentId: commentId,
270
Body: body,
···
279
createdAt := time.Now().Format(time.RFC3339)
280
commentIdInt64 := int64(commentId)
281
ownerDid := user.Did
282
+
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt)
283
if err != nil {
284
log.Println("failed to get issue at", err)
285
rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
286
return
287
}
288
289
+
atUri := f.RepoAt().String()
290
client, err := rp.oauth.AuthorizedClient(r)
291
if err != nil {
292
log.Println("failed to get authorized client", err)
···
343
return
344
}
345
346
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
347
if err != nil {
348
log.Println("failed to get issue", err)
349
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
350
return
351
}
352
353
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
354
if err != nil {
355
http.Error(w, "bad comment id", http.StatusBadRequest)
356
return
···
388
return
389
}
390
391
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
392
if err != nil {
393
log.Println("failed to get issue", err)
394
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
395
return
396
}
397
398
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
399
if err != nil {
400
http.Error(w, "bad comment id", http.StatusBadRequest)
401
return
···
506
return
507
}
508
509
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
510
if err != nil {
511
log.Println("failed to get issue", err)
512
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
521
return
522
}
523
524
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
525
if err != nil {
526
http.Error(w, "bad comment id", http.StatusBadRequest)
527
return
···
539
540
// optimistic deletion
541
deleted := time.Now()
542
+
err = db.DeleteComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
543
if err != nil {
544
log.Println("failed to delete comment")
545
rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
603
return
604
}
605
606
+
issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page)
607
if err != nil {
608
log.Println("failed to get issues", err)
609
rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
650
}
651
652
issue := &db.Issue{
653
+
RepoAt: f.RepoAt(),
654
Title: title,
655
Body: body,
656
OwnerDid: user.Did,
···
668
rp.pages.Notice(w, "issues", "Failed to create issue.")
669
return
670
}
671
+
atUri := f.RepoAt().String()
672
resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
673
Collection: tangled.RepoIssueNSID,
674
Repo: user.Did,
···
689
return
690
}
691
692
+
err = db.SetIssueAt(rp.db, f.RepoAt(), issue.IssueId, resp.Uri)
693
if err != nil {
694
log.Println("failed to set issue at", err)
695
rp.pages.Notice(w, "issues", "Failed to create issue.")
+3
-8
appview/middleware/middleware.go
+3
-8
appview/middleware/middleware.go
···
8
"slices"
9
"strconv"
10
"strings"
11
-
"time"
12
13
"github.com/bluesky-social/indigo/atproto/identity"
14
"github.com/go-chi/chi/v5"
···
214
return
215
}
216
217
-
ctx := context.WithValue(req.Context(), "knot", repo.Knot)
218
-
ctx = context.WithValue(ctx, "repoAt", repo.AtUri)
219
-
ctx = context.WithValue(ctx, "repoDescription", repo.Description)
220
-
ctx = context.WithValue(ctx, "repoSpindle", repo.Spindle)
221
-
ctx = context.WithValue(ctx, "repoAddedAt", repo.Created.Format(time.RFC3339))
222
next.ServeHTTP(w, req.WithContext(ctx))
223
})
224
}
···
243
return
244
}
245
246
-
pr, err := db.GetPull(mw.db, f.RepoAt, prIdInt)
247
if err != nil {
248
log.Println("failed to get pull and comments", err)
249
return
···
284
return
285
}
286
287
-
fullName := f.OwnerHandle() + "/" + f.RepoName
288
289
if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
290
if r.URL.Query().Get("go-get") == "1" {
···
8
"slices"
9
"strconv"
10
"strings"
11
12
"github.com/bluesky-social/indigo/atproto/identity"
13
"github.com/go-chi/chi/v5"
···
213
return
214
}
215
216
+
ctx := context.WithValue(req.Context(), "repo", repo)
217
next.ServeHTTP(w, req.WithContext(ctx))
218
})
219
}
···
238
return
239
}
240
241
+
pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)
242
if err != nil {
243
log.Println("failed to get pull and comments", err)
244
return
···
279
return
280
}
281
282
+
fullName := f.OwnerHandle() + "/" + f.Name
283
284
if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
285
if r.URL.Query().Get("go-get") == "1" {
+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
+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
-
142
func (f *ResolvedRepo) Collaborators(ctx context.Context) ([]pages.Collaborator, error) {
143
repoCollaborators, err := f.rr.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)
144
if err != nil {
···
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
108
func (f *ResolvedRepo) Collaborators(ctx context.Context) ([]pages.Collaborator, error) {
109
repoCollaborators, err := f.rr.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)
110
if err != nil {
···
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,
-1
appview/state/state.go
-1
appview/state/state.go
+1
-3
appview/db/star.go
+1
-3
appview/db/star.go