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.")
···
142
return
143
}
144
145
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
146
if err != nil {
147
log.Println("failed to get issue", err)
148
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
186
return
187
}
188
189
-
err = db.CloseIssue(rp.db, f.RepoAt, issueIdInt)
190
if err != nil {
191
log.Println("failed to close issue", err)
192
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
218
return
219
}
220
221
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
222
if err != nil {
223
log.Println("failed to get issue", err)
224
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
235
isIssueOwner := user.Did == issue.OwnerDid
236
237
if isCollaborator || isIssueOwner {
238
-
err := db.ReopenIssue(rp.db, f.RepoAt, issueIdInt)
239
if err != nil {
240
log.Println("failed to reopen issue", err)
241
rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
279
280
err := db.NewIssueComment(rp.db, &db.Comment{
281
OwnerDid: user.Did,
282
-
RepoAt: f.RepoAt,
283
Issue: issueIdInt,
284
CommentId: commentId,
285
Body: body,
···
294
createdAt := time.Now().Format(time.RFC3339)
295
commentIdInt64 := int64(commentId)
296
ownerDid := user.Did
297
-
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt, issueIdInt)
298
if err != nil {
299
log.Println("failed to get issue at", err)
300
rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
301
return
302
}
303
304
-
atUri := f.RepoAt.String()
305
client, err := rp.oauth.AuthorizedClient(r)
306
if err != nil {
307
log.Println("failed to get authorized client", err)
···
358
return
359
}
360
361
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
362
if err != nil {
363
log.Println("failed to get issue", err)
364
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
365
return
366
}
367
368
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
369
if err != nil {
370
http.Error(w, "bad comment id", http.StatusBadRequest)
371
return
···
417
return
418
}
419
420
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
421
if err != nil {
422
log.Println("failed to get issue", err)
423
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
424
return
425
}
426
427
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
428
if err != nil {
429
http.Error(w, "bad comment id", http.StatusBadRequest)
430
return
···
539
return
540
}
541
542
-
issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
543
if err != nil {
544
log.Println("failed to get issue", err)
545
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
554
return
555
}
556
557
-
comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
558
if err != nil {
559
http.Error(w, "bad comment id", http.StatusBadRequest)
560
return
···
572
573
// optimistic deletion
574
deleted := time.Now()
575
-
err = db.DeleteComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
576
if err != nil {
577
log.Println("failed to delete comment")
578
rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
641
return
642
}
643
644
-
issues, err := db.GetIssues(rp.db, f.RepoAt, isOpen, page)
645
if err != nil {
646
log.Println("failed to get issues", err)
647
rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
704
}
705
706
issue := &db.Issue{
707
-
RepoAt: f.RepoAt,
708
Title: title,
709
Body: body,
710
OwnerDid: user.Did,
···
722
rp.pages.Notice(w, "issues", "Failed to create issue.")
723
return
724
}
725
-
atUri := f.RepoAt.String()
726
resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
727
Collection: tangled.RepoIssueNSID,
728
Repo: user.Did,
···
743
return
744
}
745
746
-
err = db.SetIssueAt(rp.db, f.RepoAt, issue.IssueId, resp.Uri)
747
if err != nil {
748
log.Println("failed to set issue at", err)
749
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.")
···
142
return
143
}
144
145
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
146
if err != nil {
147
log.Println("failed to get issue", err)
148
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
186
return
187
}
188
189
+
err = db.CloseIssue(rp.db, f.RepoAt(), issueIdInt)
190
if err != nil {
191
log.Println("failed to close issue", err)
192
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
218
return
219
}
220
221
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
222
if err != nil {
223
log.Println("failed to get issue", err)
224
rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
235
isIssueOwner := user.Did == issue.OwnerDid
236
237
if isCollaborator || isIssueOwner {
238
+
err := db.ReopenIssue(rp.db, f.RepoAt(), issueIdInt)
239
if err != nil {
240
log.Println("failed to reopen issue", err)
241
rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
279
280
err := db.NewIssueComment(rp.db, &db.Comment{
281
OwnerDid: user.Did,
282
+
RepoAt: f.RepoAt(),
283
Issue: issueIdInt,
284
CommentId: commentId,
285
Body: body,
···
294
createdAt := time.Now().Format(time.RFC3339)
295
commentIdInt64 := int64(commentId)
296
ownerDid := user.Did
297
+
issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt)
298
if err != nil {
299
log.Println("failed to get issue at", err)
300
rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
301
return
302
}
303
304
+
atUri := f.RepoAt().String()
305
client, err := rp.oauth.AuthorizedClient(r)
306
if err != nil {
307
log.Println("failed to get authorized client", err)
···
358
return
359
}
360
361
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
362
if err != nil {
363
log.Println("failed to get issue", err)
364
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
365
return
366
}
367
368
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
369
if err != nil {
370
http.Error(w, "bad comment id", http.StatusBadRequest)
371
return
···
417
return
418
}
419
420
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
421
if err != nil {
422
log.Println("failed to get issue", err)
423
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
424
return
425
}
426
427
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
428
if err != nil {
429
http.Error(w, "bad comment id", http.StatusBadRequest)
430
return
···
539
return
540
}
541
542
+
issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
543
if err != nil {
544
log.Println("failed to get issue", err)
545
rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
554
return
555
}
556
557
+
comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
558
if err != nil {
559
http.Error(w, "bad comment id", http.StatusBadRequest)
560
return
···
572
573
// optimistic deletion
574
deleted := time.Now()
575
+
err = db.DeleteComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
576
if err != nil {
577
log.Println("failed to delete comment")
578
rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
641
return
642
}
643
644
+
issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page)
645
if err != nil {
646
log.Println("failed to get issues", err)
647
rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
704
}
705
706
issue := &db.Issue{
707
+
RepoAt: f.RepoAt(),
708
Title: title,
709
Body: body,
710
OwnerDid: user.Did,
···
722
rp.pages.Notice(w, "issues", "Failed to create issue.")
723
return
724
}
725
+
atUri := f.RepoAt().String()
726
resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
727
Collection: tangled.RepoIssueNSID,
728
Repo: user.Did,
···
743
return
744
}
745
746
+
err = db.SetIssueAt(rp.db, f.RepoAt(), issue.IssueId, resp.Uri)
747
if err != nil {
748
log.Println("failed to set issue at", err)
749
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"
···
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" {
···
8
"slices"
9
"strconv"
10
"strings"
11
12
"github.com/bluesky-social/indigo/atproto/identity"
13
"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 {
···
186
// this function is a bit weird since it now returns RepoInfo from an entirely different
187
// package. we should refactor this or get rid of RepoInfo entirely.
188
func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {
189
isStarred := false
190
if user != nil {
191
-
isStarred = db.GetStarStatus(f.rr.execer, user.Did, syntax.ATURI(f.RepoAt))
192
}
193
194
-
starCount, err := db.GetStarCount(f.rr.execer, f.RepoAt)
195
if err != nil {
196
-
log.Println("failed to get star count for ", f.RepoAt)
197
}
198
-
issueCount, err := db.GetIssueCount(f.rr.execer, f.RepoAt)
199
if err != nil {
200
-
log.Println("failed to get issue count for ", f.RepoAt)
201
}
202
-
pullCount, err := db.GetPullCount(f.rr.execer, f.RepoAt)
203
if err != nil {
204
-
log.Println("failed to get issue count for ", f.RepoAt)
205
}
206
-
source, err := db.GetRepoSource(f.rr.execer, f.RepoAt)
207
if errors.Is(err, sql.ErrNoRows) {
208
source = ""
209
} else if err != nil {
210
-
log.Println("failed to get repo source for ", f.RepoAt, err)
211
}
212
213
var sourceRepo *db.Repo
···
232
if err != nil {
233
log.Printf("failed to create unsigned client for %s: %v", knot, err)
234
} else {
235
-
result, err := us.Branches(f.OwnerDid(), f.RepoName)
236
if err != nil {
237
-
log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.RepoName, err)
238
}
239
240
if len(result.Branches) == 0 {
···
245
repoInfo := repoinfo.RepoInfo{
246
OwnerDid: f.OwnerDid(),
247
OwnerHandle: f.OwnerHandle(),
248
-
Name: f.RepoName,
249
-
RepoAt: f.RepoAt,
250
Description: f.Description,
251
Ref: f.Ref,
252
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 {
···
152
// this function is a bit weird since it now returns RepoInfo from an entirely different
153
// package. we should refactor this or get rid of RepoInfo entirely.
154
func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {
155
+
repoAt := f.RepoAt()
156
isStarred := false
157
if user != nil {
158
+
isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)
159
}
160
161
+
starCount, err := db.GetStarCount(f.rr.execer, repoAt)
162
if err != nil {
163
+
log.Println("failed to get star count for ", repoAt)
164
}
165
+
issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)
166
if err != nil {
167
+
log.Println("failed to get issue count for ", repoAt)
168
}
169
+
pullCount, err := db.GetPullCount(f.rr.execer, repoAt)
170
if err != nil {
171
+
log.Println("failed to get issue count for ", repoAt)
172
}
173
+
source, err := db.GetRepoSource(f.rr.execer, repoAt)
174
if errors.Is(err, sql.ErrNoRows) {
175
source = ""
176
} else if err != nil {
177
+
log.Println("failed to get repo source for ", repoAt, err)
178
}
179
180
var sourceRepo *db.Repo
···
199
if err != nil {
200
log.Printf("failed to create unsigned client for %s: %v", knot, err)
201
} else {
202
+
result, err := us.Branches(f.OwnerDid(), f.Name)
203
if err != nil {
204
+
log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.Name, err)
205
}
206
207
if len(result.Branches) == 0 {
···
212
repoInfo := repoinfo.RepoInfo{
213
OwnerDid: f.OwnerDid(),
214
OwnerHandle: f.OwnerHandle(),
215
+
Name: f.Name,
216
+
RepoAt: repoAt,
217
Description: f.Description,
218
Ref: f.Ref,
219
IsStarred: isStarred,
+7
-4
appview/db/repos.go
+7
-4
appview/db/repos.go
···
391
var description, spindle sql.NullString
392
393
row := e.QueryRow(`
394
-
select did, name, knot, created, at_uri, description, spindle
395
from repos
396
where did = ? and name = ?
397
`,
···
400
)
401
402
var createdAt string
403
-
if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.AtUri, &description, &spindle); err != nil {
404
return nil, err
405
}
406
createdAtTime, _ := time.Parse(time.RFC3339, createdAt)
···
421
var repo Repo
422
var nullableDescription sql.NullString
423
424
-
row := e.QueryRow(`select did, name, knot, created, at_uri, description from repos where at_uri = ?`, atUri)
425
426
var createdAt string
427
-
if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.AtUri, &nullableDescription); err != nil {
428
return nil, err
429
}
430
createdAtTime, _ := time.Parse(time.RFC3339, createdAt)
···
440
}
441
442
func AddRepo(e Execer, repo *Repo) error {
443
_, err := e.Exec(
444
`insert into repos
445
(did, name, knot, rkey, at_uri, description, source)
···
391
var description, spindle sql.NullString
392
393
row := e.QueryRow(`
394
+
select did, name, knot, created, at_uri, description, spindle, rkey
395
from repos
396
where did = ? and name = ?
397
`,
···
400
)
401
402
var createdAt string
403
+
if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.AtUri, &description, &spindle, &repo.Rkey); err != nil {
404
return nil, err
405
}
406
createdAtTime, _ := time.Parse(time.RFC3339, createdAt)
···
421
var repo Repo
422
var nullableDescription sql.NullString
423
424
+
row := e.QueryRow(`select did, name, knot, created, at_uri, rkey, description from repos where at_uri = ?`, atUri)
425
426
var createdAt string
427
+
if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.AtUri, &repo.Rkey, &nullableDescription); err != nil {
428
return nil, err
429
}
430
createdAtTime, _ := time.Parse(time.RFC3339, createdAt)
···
440
}
441
442
func AddRepo(e Execer, repo *Repo) error {
443
+
if repo.AtUri == "" {
444
+
repo.AtUri = repo.RepoAt().String()
445
+
}
446
_, err := e.Exec(
447
`insert into repos
448
(did, name, knot, rkey, at_uri, description, source)