tangled.org
boltless.me
+9
-4
appview/issues/issues.go
+9
-4
appview/issues/issues.go
···
312
312
// notify about the issue closure
313
313
rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
314
314
315
-
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))
315
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
316
+
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
316
317
return
317
318
} else {
318
319
l.Error("user is not permitted to close issue")
···
362
363
// notify about the issue reopen
363
364
rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
364
365
365
-
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))
366
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
367
+
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
366
368
return
367
369
} else {
368
370
l.Error("user is not the owner of the repo")
···
466
468
}
467
469
rp.notifier.NewIssueComment(r.Context(), &comment, mentions)
468
470
469
-
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", f.OwnerSlashRepo(), issue.IssueId, commentId))
471
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
472
+
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))
470
473
}
471
474
472
475
func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) {
···
970
973
}
971
974
}
972
975
rp.notifier.NewIssue(r.Context(), issue, mentions)
973
-
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))
976
+
977
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
978
+
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
974
979
return
975
980
}
976
981
}
+2
-2
appview/middleware/middleware.go
+2
-2
appview/middleware/middleware.go
···
164
164
ok, err := mw.enforcer.E.Enforce(actor.Did, f.Knot, f.DidSlashRepo(), requiredPerm)
165
165
if err != nil || !ok {
166
166
// we need a logged in user
167
-
log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.OwnerSlashRepo())
167
+
log.Printf("%s does not have perms of a %s in repo %s", actor.Did, requiredPerm, f.DidSlashRepo())
168
168
http.Error(w, "Forbiden", http.StatusUnauthorized)
169
169
return
170
170
}
···
327
327
return
328
328
}
329
329
330
-
fullName := f.OwnerHandle() + "/" + f.Name
330
+
fullName := reporesolver.GetBaseRepoPath(r, &f.Repo)
331
331
332
332
if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
333
333
if r.URL.Query().Get("go-get") == "1" {
+2
-2
appview/pages/repoinfo/repoinfo.go
+2
-2
appview/pages/repoinfo/repoinfo.go
···
21
21
return path.Join(r.owner(), r.Name)
22
22
}
23
23
24
-
func (r RepoInfo) OwnerWithoutAt() string {
24
+
func (r RepoInfo) ownerWithoutAt() string {
25
25
if r.OwnerHandle != "" {
26
26
return r.OwnerHandle
27
27
} else {
···
30
30
}
31
31
32
32
func (r RepoInfo) FullNameWithoutAt() string {
33
-
return path.Join(r.OwnerWithoutAt(), r.Name)
33
+
return path.Join(r.ownerWithoutAt(), r.Name)
34
34
}
35
35
36
36
func (r RepoInfo) GetTabs() [][]string {
+24
-16
appview/pulls/pulls.go
+24
-16
appview/pulls/pulls.go
···
267
267
r.Context(),
268
268
&xrpcc,
269
269
&tangled.RepoMergeCheck_Input{
270
-
Did: f.OwnerDid(),
270
+
Did: f.Did,
271
271
Name: f.Name,
272
272
Branch: pull.TargetBranch,
273
273
Patch: patch,
···
381
381
} else {
382
382
// pulls within the same repo
383
383
knot = f.Knot
384
-
ownerDid = f.OwnerDid()
384
+
ownerDid = f.Did
385
385
repoName = f.Name
386
386
}
387
387
···
800
800
}
801
801
s.notifier.NewPullComment(r.Context(), comment, mentions)
802
802
803
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", f.OwnerSlashRepo(), pull.PullId, commentId))
803
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
804
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))
804
805
return
805
806
}
806
807
}
···
824
825
Host: host,
825
826
}
826
827
827
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
828
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
828
829
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
829
830
if err != nil {
830
831
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
···
989
990
Host: host,
990
991
}
991
992
992
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
993
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
993
994
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, targetBranch, sourceBranch)
994
995
if err != nil {
995
996
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
···
1271
1272
1272
1273
s.notifier.NewPull(r.Context(), pull)
1273
1274
1274
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId))
1275
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
1276
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pullId))
1275
1277
}
1276
1278
1277
1279
func (s *Pulls) createStackedPullRequest(
···
1372
1374
return
1373
1375
}
1374
1376
1375
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", f.OwnerSlashRepo()))
1377
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
1378
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", ownerSlashRepo))
1376
1379
}
1377
1380
1378
1381
func (s *Pulls) ValidatePatch(w http.ResponseWriter, r *http.Request) {
···
1431
1434
Host: host,
1432
1435
}
1433
1436
1434
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
1437
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1435
1438
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
1436
1439
if err != nil {
1437
1440
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
···
1552
1555
Host: targetHost,
1553
1556
}
1554
1557
1555
-
targetRepo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
1558
+
targetRepo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1556
1559
targetXrpcBytes, err := tangled.RepoBranches(r.Context(), targetXrpcc, "", 0, targetRepo)
1557
1560
if err != nil {
1558
1561
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
···
1683
1686
Host: host,
1684
1687
}
1685
1688
1686
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
1689
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
1687
1690
xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch)
1688
1691
if err != nil {
1689
1692
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
···
1920
1923
return
1921
1924
}
1922
1925
1923
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
1926
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
1927
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
1924
1928
}
1925
1929
1926
1930
func (s *Pulls) resubmitStackedPullHelper(
···
2113
2117
return
2114
2118
}
2115
2119
2116
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
2120
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2121
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2117
2122
}
2118
2123
2119
2124
func (s *Pulls) MergePull(w http.ResponseWriter, r *http.Request) {
···
2166
2171
2167
2172
authorName := ident.Handle.String()
2168
2173
mergeInput := &tangled.RepoMerge_Input{
2169
-
Did: f.OwnerDid(),
2174
+
Did: f.Did,
2170
2175
Name: f.Name,
2171
2176
Branch: pull.TargetBranch,
2172
2177
Patch: patch,
···
2231
2236
s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2232
2237
}
2233
2238
2234
-
s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId))
2239
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2240
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2235
2241
}
2236
2242
2237
2243
func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {
···
2303
2309
s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2304
2310
}
2305
2311
2306
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
2312
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2313
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2307
2314
}
2308
2315
2309
2316
func (s *Pulls) ReopenPull(w http.ResponseWriter, r *http.Request) {
···
2376
2383
s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2377
2384
}
2378
2385
2379
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
2386
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2387
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2380
2388
}
2381
2389
2382
2390
func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {
+1
-1
appview/repo/artifact.go
+1
-1
appview/repo/artifact.go
···
305
305
Host: host,
306
306
}
307
307
308
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
308
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
309
309
xrpcBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)
310
310
if err != nil {
311
311
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
+6
-4
appview/repo/blob.go
+6
-4
appview/repo/blob.go
···
54
54
xrpcc := &indigoxrpc.Client{
55
55
Host: host,
56
56
}
57
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name)
57
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)
58
58
resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)
59
59
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
60
60
l.Error("failed to call XRPC repo.blob", "err", xrpcerr)
···
62
62
return
63
63
}
64
64
65
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
66
+
65
67
// Use XRPC response directly instead of converting to internal types
66
68
var breadcrumbs [][]string
67
-
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})
69
+
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))})
68
70
if filePath != "" {
69
71
for idx, elem := range strings.Split(filePath, "/") {
70
72
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})
···
105
107
if !rp.config.Core.Dev {
106
108
scheme = "https"
107
109
}
108
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name)
110
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)
109
111
baseURL := &url.URL{
110
112
Scheme: scheme,
111
113
Host: f.Knot,
···
256
258
scheme = "https"
257
259
}
258
260
259
-
repoName := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
261
+
repoName := fmt.Sprintf("%s/%s", f.Did, f.Name)
260
262
baseURL := &url.URL{
261
263
Scheme: scheme,
262
264
Host: f.Knot,
+1
-1
appview/repo/branches.go
+1
-1
appview/repo/branches.go
···
29
29
xrpcc := &indigoxrpc.Client{
30
30
Host: host,
31
31
}
32
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
32
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
33
33
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
34
34
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
35
35
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
+2
-2
appview/repo/compare.go
+2
-2
appview/repo/compare.go
···
36
36
Host: host,
37
37
}
38
38
39
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
39
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
40
40
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
41
41
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
42
42
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
···
147
147
Host: host,
148
148
}
149
149
150
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
150
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
151
151
152
152
branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
153
153
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
+23
-17
appview/repo/feed.go
+23
-17
appview/repo/feed.go
···
11
11
"tangled.org/core/appview/db"
12
12
"tangled.org/core/appview/models"
13
13
"tangled.org/core/appview/pagination"
14
-
"tangled.org/core/appview/reporesolver"
15
14
15
+
"github.com/bluesky-social/indigo/atproto/identity"
16
16
"github.com/bluesky-social/indigo/atproto/syntax"
17
17
"github.com/gorilla/feeds"
18
18
)
19
19
20
-
func (rp *Repo) getRepoFeed(ctx context.Context, f *reporesolver.ResolvedRepo) (*feeds.Feed, error) {
20
+
func (rp *Repo) getRepoFeed(ctx context.Context, repo *models.Repo, ownerSlashRepo string) (*feeds.Feed, error) {
21
21
const feedLimitPerType = 100
22
22
23
-
pulls, err := db.GetPullsWithLimit(rp.db, feedLimitPerType, db.FilterEq("repo_at", f.RepoAt()))
23
+
pulls, err := db.GetPullsWithLimit(rp.db, feedLimitPerType, db.FilterEq("repo_at", repo.RepoAt()))
24
24
if err != nil {
25
25
return nil, err
26
26
}
···
28
28
issues, err := db.GetIssuesPaginated(
29
29
rp.db,
30
30
pagination.Page{Limit: feedLimitPerType},
31
-
db.FilterEq("repo_at", f.RepoAt()),
31
+
db.FilterEq("repo_at", repo.RepoAt()),
32
32
)
33
33
if err != nil {
34
34
return nil, err
35
35
}
36
36
37
37
feed := &feeds.Feed{
38
-
Title: fmt.Sprintf("activity feed for %s", f.OwnerSlashRepo()),
39
-
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, f.OwnerSlashRepo()), Type: "text/html", Rel: "alternate"},
38
+
Title: fmt.Sprintf("activity feed for @%s", ownerSlashRepo),
39
+
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, ownerSlashRepo), Type: "text/html", Rel: "alternate"},
40
40
Items: make([]*feeds.Item, 0),
41
41
Updated: time.UnixMilli(0),
42
42
}
43
43
44
44
for _, pull := range pulls {
45
-
items, err := rp.createPullItems(ctx, pull, f)
45
+
items, err := rp.createPullItems(ctx, pull, repo, ownerSlashRepo)
46
46
if err != nil {
47
47
return nil, err
48
48
}
···
50
50
}
51
51
52
52
for _, issue := range issues {
53
-
item, err := rp.createIssueItem(ctx, issue, f)
53
+
item, err := rp.createIssueItem(ctx, issue, repo, ownerSlashRepo)
54
54
if err != nil {
55
55
return nil, err
56
56
}
···
71
71
return feed, nil
72
72
}
73
73
74
-
func (rp *Repo) createPullItems(ctx context.Context, pull *models.Pull, f *reporesolver.ResolvedRepo) ([]*feeds.Item, error) {
74
+
func (rp *Repo) createPullItems(ctx context.Context, pull *models.Pull, repo *models.Repo, ownerSlashRepo string) ([]*feeds.Item, error) {
75
75
owner, err := rp.idResolver.ResolveIdent(ctx, pull.OwnerDid)
76
76
if err != nil {
77
77
return nil, err
···
80
80
var items []*feeds.Item
81
81
82
82
state := rp.getPullState(pull)
83
-
description := rp.buildPullDescription(owner.Handle, state, pull, f.OwnerSlashRepo())
83
+
description := rp.buildPullDescription(owner.Handle, state, pull, ownerSlashRepo)
84
84
85
85
mainItem := &feeds.Item{
86
86
Title: fmt.Sprintf("[PR #%d] %s", pull.PullId, pull.Title),
87
87
Description: description,
88
-
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId)},
88
+
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId)},
89
89
Created: pull.Created,
90
90
Author: &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},
91
91
}
···
98
98
99
99
roundItem := &feeds.Item{
100
100
Title: fmt.Sprintf("[PR #%d] %s (round #%d)", pull.PullId, pull.Title, round.RoundNumber),
101
-
Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in %s", owner.Handle, round.RoundNumber, pull.PullId, f.OwnerSlashRepo()),
102
-
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId, round.RoundNumber)},
101
+
Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in @%s", owner.Handle, round.RoundNumber, pull.PullId, ownerSlashRepo),
102
+
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId, round.RoundNumber)},
103
103
Created: round.Created,
104
104
Author: &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},
105
105
}
···
109
109
return items, nil
110
110
}
111
111
112
-
func (rp *Repo) createIssueItem(ctx context.Context, issue models.Issue, f *reporesolver.ResolvedRepo) (*feeds.Item, error) {
112
+
func (rp *Repo) createIssueItem(ctx context.Context, issue models.Issue, repo *models.Repo, ownerSlashRepo string) (*feeds.Item, error) {
113
113
owner, err := rp.idResolver.ResolveIdent(ctx, issue.Did)
114
114
if err != nil {
115
115
return nil, err
···
122
122
123
123
return &feeds.Item{
124
124
Title: fmt.Sprintf("[Issue #%d] %s", issue.IssueId, issue.Title),
125
-
Description: fmt.Sprintf("@%s %s issue #%d in %s", owner.Handle, state, issue.IssueId, f.OwnerSlashRepo()),
126
-
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), issue.IssueId)},
125
+
Description: fmt.Sprintf("@%s %s issue #%d in @%s", owner.Handle, state, issue.IssueId, ownerSlashRepo),
126
+
Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, ownerSlashRepo, issue.IssueId)},
127
127
Created: issue.Created,
128
128
Author: &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},
129
129
}, nil
···
152
152
log.Println("failed to fully resolve repo:", err)
153
153
return
154
154
}
155
+
repoOwnerId, ok := r.Context().Value("resolvedId").(identity.Identity)
156
+
if !ok || repoOwnerId.Handle.IsInvalidHandle() {
157
+
log.Println("failed to get resolved repo owner id")
158
+
return
159
+
}
160
+
ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name
155
161
156
-
feed, err := rp.getRepoFeed(r.Context(), f)
162
+
feed, err := rp.getRepoFeed(r.Context(), &f.Repo, ownerSlashRepo)
157
163
if err != nil {
158
164
log.Println("failed to get repo feed:", err)
159
165
rp.pages.Error500(w)
+2
-2
appview/repo/index.go
+2
-2
appview/repo/index.go
···
179
179
180
180
if err != nil || langs == nil {
181
181
// non-fatal, fetch langs from ks via XRPC
182
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
182
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
183
183
ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo)
184
184
if err != nil {
185
185
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
···
256
256
257
257
// buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel
258
258
func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, f *reporesolver.ResolvedRepo, ref string) (*types.RepoIndexResponse, error) {
259
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
259
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
260
260
261
261
// first get branches to determine the ref if not specified
262
262
branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo)
+2
-2
appview/repo/log.go
+2
-2
appview/repo/log.go
···
57
57
cursor = strconv.Itoa(offset)
58
58
}
59
59
60
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
60
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
61
61
xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)
62
62
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
63
63
l.Error("failed to call XRPC repo.log", "err", xrpcerr)
···
174
174
Host: host,
175
175
}
176
176
177
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
177
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
178
178
xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)
179
179
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
180
180
l.Error("failed to call XRPC repo.diff", "err", xrpcerr)
+5
-5
appview/repo/repo.go
+5
-5
appview/repo/repo.go
···
864
864
r.Context(),
865
865
client,
866
866
&tangled.RepoDelete_Input{
867
-
Did: f.OwnerDid(),
867
+
Did: f.Did,
868
868
Name: f.Name,
869
869
Rkey: f.Rkey,
870
870
},
···
902
902
l.Info("removed collaborators")
903
903
904
904
// remove repo RBAC
905
-
err = rp.enforcer.RemoveRepo(f.OwnerDid(), f.Knot, f.DidSlashRepo())
905
+
err = rp.enforcer.RemoveRepo(f.Did, f.Knot, f.DidSlashRepo())
906
906
if err != nil {
907
907
rp.pages.Notice(w, noticeId, "Failed to update RBAC rules")
908
908
return
909
909
}
910
910
911
911
// remove repo from db
912
-
err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)
912
+
err = db.RemoveRepo(tx, f.Did, f.Name)
913
913
if err != nil {
914
914
rp.pages.Notice(w, noticeId, "Failed to update appview")
915
915
return
···
930
930
return
931
931
}
932
932
933
-
rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.OwnerDid()))
933
+
rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.Did))
934
934
}
935
935
936
936
func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) {
···
1058
1058
uri = "http"
1059
1059
}
1060
1060
1061
-
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
1061
+
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Repo.Name)
1062
1062
l = l.With("cloneUrl", forkSourceUrl)
1063
1063
1064
1064
sourceAt := f.RepoAt().String()
+2
-2
appview/repo/settings.go
+2
-2
appview/repo/settings.go
···
194
194
Host: host,
195
195
}
196
196
197
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
197
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
198
198
xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
199
199
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
200
200
l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
···
292
292
user := rp.oauth.GetUser(r)
293
293
294
294
// all spindles that the repo owner is a member of
295
-
spindles, err := rp.enforcer.GetSpindlesForUser(f.OwnerDid())
295
+
spindles, err := rp.enforcer.GetSpindlesForUser(f.Did)
296
296
if err != nil {
297
297
l.Error("failed to fetch spindles", "err", err)
298
298
return
+4
-3
appview/repo/tree.go
+4
-3
appview/repo/tree.go
···
39
39
xrpcc := &indigoxrpc.Client{
40
40
Host: host,
41
41
}
42
-
repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)
42
+
repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
43
43
xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)
44
44
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
45
45
l.Error("failed to call XRPC repo.tree", "err", xrpcerr)
···
79
79
result.ReadmeFileName = xrpcResp.Readme.Filename
80
80
result.Readme = xrpcResp.Readme.Contents
81
81
}
82
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
82
83
// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,
83
84
// so we can safely redirect to the "parent" (which is the same file).
84
85
if len(result.Files) == 0 && result.Parent == treePath {
85
-
redirectTo := fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), url.PathEscape(ref), result.Parent)
86
+
redirectTo := fmt.Sprintf("/%s/blob/%s/%s", ownerSlashRepo, url.PathEscape(ref), result.Parent)
86
87
http.Redirect(w, r, redirectTo, http.StatusFound)
87
88
return
88
89
}
89
90
user := rp.oauth.GetUser(r)
90
91
var breadcrumbs [][]string
91
-
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})
92
+
breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", ownerSlashRepo, url.PathEscape(ref))})
92
93
if treePath != "" {
93
94
for idx, elem := range strings.Split(treePath, "/") {
94
95
breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})
+15
-25
appview/reporesolver/resolver.go
+15
-25
appview/reporesolver/resolver.go
···
12
12
"strings"
13
13
14
14
"github.com/bluesky-social/indigo/atproto/identity"
15
-
securejoin "github.com/cyphar/filepath-securejoin"
16
15
"github.com/go-chi/chi/v5"
17
16
"tangled.org/core/appview/config"
18
17
"tangled.org/core/appview/db"
···
44
43
return &RepoResolver{config: config, enforcer: enforcer, idResolver: resolver, execer: execer}
45
44
}
46
45
46
+
// NOTE: this... should not even be here. the entire package will be removed in future refactor
47
+
func GetBaseRepoPath(r *http.Request, repo *models.Repo) string {
48
+
var (
49
+
user = chi.URLParam(r, "user")
50
+
name = chi.URLParam(r, "repo")
51
+
)
52
+
if user == "" || name == "" {
53
+
return repo.DidSlashRepo()
54
+
}
55
+
return path.Join(user, name)
56
+
}
57
+
47
58
func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
48
59
repo, ok := r.Context().Value("repo").(*models.Repo)
49
60
if !ok {
···
67
78
68
79
rr: rr,
69
80
}, nil
70
-
}
71
-
72
-
func (f *ResolvedRepo) OwnerDid() string {
73
-
return f.OwnerId.DID.String()
74
-
}
75
-
76
-
func (f *ResolvedRepo) OwnerHandle() string {
77
-
return f.OwnerId.Handle.String()
78
-
}
79
-
80
-
func (f *ResolvedRepo) OwnerSlashRepo() string {
81
-
handle := f.OwnerId.Handle
82
-
83
-
var p string
84
-
if handle != "" && !handle.IsInvalidHandle() {
85
-
p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.Name)
86
-
} else {
87
-
p, _ = securejoin.SecureJoin(f.OwnerDid(), f.Name)
88
-
}
89
-
90
-
return p
91
81
}
92
82
93
83
func (f *ResolvedRepo) Collaborators(ctx context.Context) ([]pages.Collaborator, error) {
···
168
158
knot := f.Knot
169
159
170
160
repoInfo := repoinfo.RepoInfo{
171
-
OwnerDid: f.OwnerDid(),
172
-
OwnerHandle: f.OwnerHandle(),
161
+
OwnerDid: f.OwnerId.DID.String(),
162
+
OwnerHandle: f.OwnerId.Handle.String(),
173
163
Name: f.Name,
174
-
Rkey: f.Repo.Rkey,
164
+
Rkey: f.Rkey,
175
165
RepoAt: repoAt,
176
166
Description: f.Description,
177
167
Website: f.Website,