boltless.me
- reduce duplicated codes
- possibly remove/refactor
ResolvedRepoin future - allow accessing
db.Repoafter it is resolved
+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" {
+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