forked from
tangled.org/core
Mirror of @tangled.org/core. Running on a Raspberry Pi Zero 2 (Please be gentle).
appview: remove `ResolvedRepo` for eternity
Signed-off-by: Seongmin Lee <git@boltless.me>
authored by
Seongmin Lee
and committed by
Tangled
31f4fe7e
fe0d3a95
+63
-69
+8
-8
appview/issues/issues.go
+8
-8
appview/issues/issues.go
···
103
103
104
104
labelDefs, err := db.GetLabelDefinitions(
105
105
rp.db,
106
-
db.FilterIn("at_uri", f.Repo.Labels),
106
+
db.FilterIn("at_uri", f.Labels),
107
107
db.FilterContains("scope", tangled.RepoIssueNSID),
108
108
)
109
109
if err != nil {
···
264
264
rp.notifier.DeleteIssue(r.Context(), issue)
265
265
266
266
// return to all issues page
267
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
267
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
268
268
rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")
269
269
}
270
270
···
306
306
// notify about the issue closure
307
307
rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
308
308
309
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
309
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
310
310
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
311
311
return
312
312
} else {
···
353
353
// notify about the issue reopen
354
354
rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
355
355
356
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
356
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
357
357
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
358
358
return
359
359
} else {
···
458
458
}
459
459
rp.notifier.NewIssueComment(r.Context(), &comment, mentions)
460
460
461
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
461
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
462
462
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))
463
463
}
464
464
···
827
827
828
828
labelDefs, err := db.GetLabelDefinitions(
829
829
rp.db,
830
-
db.FilterIn("at_uri", f.Repo.Labels),
830
+
db.FilterIn("at_uri", f.Labels),
831
831
db.FilterContains("scope", tangled.RepoIssueNSID),
832
832
)
833
833
if err != nil {
···
878
878
Open: true,
879
879
Did: user.Did,
880
880
Created: time.Now(),
881
-
Repo: &f.Repo,
881
+
Repo: f,
882
882
}
883
883
884
884
if err := rp.validator.ValidateIssue(issue); err != nil {
···
957
957
}
958
958
rp.notifier.NewIssue(r.Context(), issue, mentions)
959
959
960
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
960
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
961
961
rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
962
962
return
963
963
}
+3
-3
appview/issues/opengraph.go
+3
-3
appview/issues/opengraph.go
···
232
232
233
233
// Get owner handle for avatar
234
234
var ownerHandle string
235
-
owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Repo.Did)
235
+
owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)
236
236
if err != nil {
237
-
ownerHandle = f.Repo.Did
237
+
ownerHandle = f.Did
238
238
} else {
239
239
ownerHandle = "@" + owner.Handle.String()
240
240
}
241
241
242
-
card, err := rp.drawIssueSummaryCard(issue, &f.Repo, commentCount, ownerHandle)
242
+
card, err := rp.drawIssueSummaryCard(issue, f, commentCount, ownerHandle)
243
243
if err != nil {
244
244
log.Println("failed to draw issue summary card", err)
245
245
http.Error(w, "failed to draw issue summary card", http.StatusInternalServerError)
+1
-1
appview/middleware/middleware.go
+1
-1
appview/middleware/middleware.go
+1
-1
appview/pulls/opengraph.go
+1
-1
appview/pulls/opengraph.go
···
293
293
filesChanged = niceDiff.Stat.FilesChanged
294
294
}
295
295
296
-
card, err := s.drawPullSummaryCard(pull, &f.Repo, commentCount, diffStats, filesChanged)
296
+
card, err := s.drawPullSummaryCard(pull, f, commentCount, diffStats, filesChanged)
297
297
if err != nil {
298
298
log.Println("failed to draw pull summary card", err)
299
299
http.Error(w, "failed to draw pull summary card", http.StatusInternalServerError)
+18
-18
appview/pulls/pulls.go
+18
-18
appview/pulls/pulls.go
···
115
115
return
116
116
}
117
117
118
-
mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)
119
-
branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)
118
+
mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
119
+
branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
120
120
resubmitResult := pages.Unknown
121
121
if user.Did == pull.OwnerDid {
122
-
resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)
122
+
resubmitResult = s.resubmitCheck(r, f, pull, stack)
123
123
}
124
124
125
125
s.pages.PullActionsFragment(w, pages.PullActionsParams{
···
155
155
stack, _ := r.Context().Value("stack").(models.Stack)
156
156
abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)
157
157
158
-
mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)
159
-
branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)
158
+
mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
159
+
branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
160
160
resubmitResult := pages.Unknown
161
161
if user != nil && user.Did == pull.OwnerDid {
162
-
resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)
162
+
resubmitResult = s.resubmitCheck(r, f, pull, stack)
163
163
}
164
164
165
165
m := make(map[string]models.Pipeline)
···
205
205
206
206
labelDefs, err := db.GetLabelDefinitions(
207
207
s.db,
208
-
db.FilterIn("at_uri", f.Repo.Labels),
208
+
db.FilterIn("at_uri", f.Labels),
209
209
db.FilterContains("scope", tangled.RepoPullNSID),
210
210
)
211
211
if err != nil {
···
651
651
652
652
labelDefs, err := db.GetLabelDefinitions(
653
653
s.db,
654
-
db.FilterIn("at_uri", f.Repo.Labels),
654
+
db.FilterIn("at_uri", f.Labels),
655
655
db.FilterContains("scope", tangled.RepoPullNSID),
656
656
)
657
657
if err != nil {
···
787
787
}
788
788
s.notifier.NewPullComment(r.Context(), comment, mentions)
789
789
790
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
790
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
791
791
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))
792
792
return
793
793
}
···
940
940
s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")
941
941
return
942
942
}
943
-
s.handleBranchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, sourceBranch, isStacked)
943
+
s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)
944
944
} else if isForkBased {
945
945
if !caps.PullRequests.ForkSubmissions {
946
946
s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")
947
947
return
948
948
}
949
-
s.handleForkBasedPull(w, r, &f.Repo, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
949
+
s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
950
950
} else if isPatchBased {
951
951
if !caps.PullRequests.PatchSubmissions {
952
952
s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")
953
953
return
954
954
}
955
-
s.handlePatchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, patch, isStacked)
955
+
s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)
956
956
}
957
957
return
958
958
}
···
1619
1619
1620
1620
patch := r.FormValue("patch")
1621
1621
1622
-
s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, "", "")
1622
+
s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")
1623
1623
}
1624
1624
1625
1625
func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
···
1684
1684
patch := comparison.FormatPatchRaw
1685
1685
combined := comparison.CombinedPatchRaw
1686
1686
1687
-
s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)
1687
+
s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
1688
1688
}
1689
1689
1690
1690
func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
···
1781
1781
patch := comparison.FormatPatchRaw
1782
1782
combined := comparison.CombinedPatchRaw
1783
1783
1784
-
s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)
1784
+
s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
1785
1785
}
1786
1786
1787
1787
func (s *Pulls) resubmitPullHelper(
···
2210
2210
s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2211
2211
}
2212
2212
2213
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2213
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
2214
2214
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2215
2215
}
2216
2216
···
2283
2283
s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2284
2284
}
2285
2285
2286
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2286
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
2287
2287
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2288
2288
}
2289
2289
···
2357
2357
s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
2358
2358
}
2359
2359
2360
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
2360
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
2361
2361
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
2362
2362
}
2363
2363
+2
-2
appview/repo/artifact.go
+2
-2
appview/repo/artifact.go
···
38
38
return
39
39
}
40
40
41
-
tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)
41
+
tag, err := rp.resolveTag(r.Context(), f, tagParam)
42
42
if err != nil {
43
43
log.Println("failed to resolve tag", err)
44
44
rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")
···
146
146
tagParam := chi.URLParam(r, "tag")
147
147
filename := chi.URLParam(r, "file")
148
148
149
-
tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)
149
+
tag, err := rp.resolveTag(r.Context(), f, tagParam)
150
150
if err != nil {
151
151
log.Println("failed to resolve tag", err)
152
152
rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")
+4
-4
appview/repo/blob.go
+4
-4
appview/repo/blob.go
···
54
54
xrpcc := &indigoxrpc.Client{
55
55
Host: host,
56
56
}
57
-
repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)
57
+
repo := fmt.Sprintf("%s/%s", f.Did, f.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)
65
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
66
66
67
67
// Use XRPC response directly instead of converting to internal types
68
68
var breadcrumbs [][]string
···
74
74
}
75
75
76
76
// Create the blob view
77
-
blobView := NewBlobView(resp, rp.config, &f.Repo, ref, filePath, r.URL.Query())
77
+
blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())
78
78
79
79
user := rp.oauth.GetUser(r)
80
80
···
107
107
if !rp.config.Core.Dev {
108
108
scheme = "https"
109
109
}
110
-
repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)
110
+
repo := f.DidSlashRepo()
111
111
baseURL := &url.URL{
112
112
Scheme: scheme,
113
113
Host: f.Knot,
+1
-1
appview/repo/feed.go
+1
-1
appview/repo/feed.go
···
159
159
}
160
160
ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name
161
161
162
-
feed, err := rp.getRepoFeed(r.Context(), &f.Repo, ownerSlashRepo)
162
+
feed, err := rp.getRepoFeed(r.Context(), f, ownerSlashRepo)
163
163
if err != nil {
164
164
log.Println("failed to get repo feed:", err)
165
165
rp.pages.Error500(w)
+3
-3
appview/repo/index.go
+3
-3
appview/repo/index.go
···
53
53
user := rp.oauth.GetUser(r)
54
54
55
55
// Build index response from multiple XRPC calls
56
-
result, err := rp.buildIndexResponse(r.Context(), xrpcc, &f.Repo, ref)
56
+
result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
57
57
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
58
58
if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {
59
59
l.Error("failed to call XRPC repo.index", "err", err)
···
128
128
}
129
129
130
130
// TODO: a bit dirty
131
-
languageInfo, err := rp.getLanguageInfo(r.Context(), l, &f.Repo, xrpcc, result.Ref, ref == "")
131
+
languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")
132
132
if err != nil {
133
133
l.Warn("failed to compute language percentages", "err", err)
134
134
// non-fatal
···
138
138
for _, c := range commitsTrunc {
139
139
shas = append(shas, c.Hash.String())
140
140
}
141
-
pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
141
+
pipelines, err := getPipelineStatuses(rp.db, f, shas)
142
142
if err != nil {
143
143
l.Error("failed to fetch pipeline statuses", "err", err)
144
144
// non-fatal
+2
-2
appview/repo/log.go
+2
-2
appview/repo/log.go
···
125
125
for _, c := range xrpcResp.Commits {
126
126
shas = append(shas, c.Hash.String())
127
127
}
128
-
pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
128
+
pipelines, err := getPipelineStatuses(rp.db, f, shas)
129
129
if err != nil {
130
130
l.Error("failed to getPipelineStatuses", "err", err)
131
131
// non-fatal
···
198
198
}
199
199
200
200
user := rp.oauth.GetUser(r)
201
-
pipelines, err := getPipelineStatuses(rp.db, &f.Repo, []string{result.Diff.Commit.This})
201
+
pipelines, err := getPipelineStatuses(rp.db, f, []string{result.Diff.Commit.This})
202
202
if err != nil {
203
203
l.Error("failed to getPipelineStatuses", "err", err)
204
204
// non-fatal
+1
-1
appview/repo/opengraph.go
+1
-1
appview/repo/opengraph.go
···
374
374
})
375
375
}
376
376
377
-
card, err := rp.drawRepoSummaryCard(&f.Repo, languageStats)
377
+
card, err := rp.drawRepoSummaryCard(f, languageStats)
378
378
if err != nil {
379
379
log.Println("failed to draw repo summary card", err)
380
380
http.Error(w, "failed to draw repo summary card", http.StatusInternalServerError)
+11
-11
appview/repo/repo.go
+11
-11
appview/repo/repo.go
···
118
118
}
119
119
}
120
120
121
-
newRepo := f.Repo
121
+
newRepo := *f
122
122
newRepo.Spindle = newSpindle
123
123
record := newRepo.AsRecord()
124
124
···
257
257
l.Info("wrote label record to PDS")
258
258
259
259
// update the repo to subscribe to this label
260
-
newRepo := f.Repo
260
+
newRepo := *f
261
261
newRepo.Labels = append(newRepo.Labels, aturi)
262
262
repoRecord := newRepo.AsRecord()
263
263
···
369
369
}
370
370
371
371
// update repo record to remove the label reference
372
-
newRepo := f.Repo
372
+
newRepo := *f
373
373
var updated []string
374
374
removedAt := label.AtUri().String()
375
375
for _, l := range newRepo.Labels {
···
462
462
return
463
463
}
464
464
465
-
newRepo := f.Repo
465
+
newRepo := *f
466
466
newRepo.Labels = append(newRepo.Labels, labelAts...)
467
467
468
468
// dedup
···
477
477
return
478
478
}
479
479
480
-
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)
480
+
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)
481
481
if err != nil {
482
482
fail("Failed to update labels, no record found on PDS.", err)
483
483
return
···
549
549
}
550
550
551
551
// update repo record to remove the label reference
552
-
newRepo := f.Repo
552
+
newRepo := *f
553
553
var updated []string
554
554
for _, l := range newRepo.Labels {
555
555
if !slices.Contains(labelAts, l) {
···
565
565
return
566
566
}
567
567
568
-
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)
568
+
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)
569
569
if err != nil {
570
570
fail("Failed to update labels, no record found on PDS.", err)
571
571
return
···
612
612
613
613
labelDefs, err := db.GetLabelDefinitions(
614
614
rp.db,
615
-
db.FilterIn("at_uri", f.Repo.Labels),
615
+
db.FilterIn("at_uri", f.Labels),
616
616
db.FilterContains("scope", subject.Collection().String()),
617
617
)
618
618
if err != nil {
···
660
660
661
661
labelDefs, err := db.GetLabelDefinitions(
662
662
rp.db,
663
-
db.FilterIn("at_uri", f.Repo.Labels),
663
+
db.FilterIn("at_uri", f.Labels),
664
664
db.FilterContains("scope", subject.Collection().String()),
665
665
)
666
666
if err != nil {
···
1057
1057
uri = "http"
1058
1058
}
1059
1059
1060
-
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Repo.Name)
1060
+
forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Name)
1061
1061
l = l.With("cloneUrl", forkSourceUrl)
1062
1062
1063
1063
sourceAt := f.RepoAt().String()
···
1070
1070
Knot: targetKnot,
1071
1071
Rkey: rkey,
1072
1072
Source: sourceAt,
1073
-
Description: f.Repo.Description,
1073
+
Description: f.Description,
1074
1074
Created: time.Now(),
1075
1075
Labels: rp.config.Label.DefaultLabelDefs,
1076
1076
}
+4
-4
appview/repo/settings.go
+4
-4
appview/repo/settings.go
···
217
217
return
218
218
}
219
219
220
-
labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))
220
+
labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Labels))
221
221
if err != nil {
222
222
l.Error("failed to fetch labels", "err", err)
223
223
rp.pages.Error503(w)
···
238
238
labels = labels[:n]
239
239
240
240
subscribedLabels := make(map[string]struct{})
241
-
for _, l := range f.Repo.Labels {
241
+
for _, l := range f.Labels {
242
242
subscribedLabels[l] = struct{}{}
243
243
}
244
244
···
299
299
collaborators = append(collaborators, c)
300
300
}
301
301
return collaborators, nil
302
-
}(&f.Repo)
302
+
}(f)
303
303
if err != nil {
304
304
l.Error("failed to get collaborators", "err", err)
305
305
}
···
416
416
}
417
417
l.Debug("got", "topicsStr", topicStr, "topics", topics)
418
418
419
-
newRepo := f.Repo
419
+
newRepo := *f
420
420
newRepo.Description = description
421
421
newRepo.Website = website
422
422
newRepo.Topics = topics
+1
-1
appview/repo/tree.go
+1
-1
appview/repo/tree.go
···
80
80
result.ReadmeFileName = xrpcResp.Readme.Filename
81
81
result.Readme = xrpcResp.Readme.Contents
82
82
}
83
-
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
83
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
84
84
// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,
85
85
// so we can safely redirect to the "parent" (which is the same file).
86
86
if len(result.Files) == 0 && result.Parent == treePath {
+3
-9
appview/reporesolver/resolver.go
+3
-9
appview/reporesolver/resolver.go
···
18
18
"tangled.org/core/rbac"
19
19
)
20
20
21
-
type ResolvedRepo struct {
22
-
models.Repo
23
-
}
24
-
25
21
type RepoResolver struct {
26
22
config *config.Config
27
23
enforcer *rbac.Enforcer
···
41
45
}
42
46
43
47
// TODO: move this out of `RepoResolver` struct
44
-
func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
48
+
func (rr *RepoResolver) Resolve(r *http.Request) (*models.Repo, error) {
45
49
repo, ok := r.Context().Value("repo").(*models.Repo)
46
50
if !ok {
47
51
log.Println("malformed middleware: `repo` not exist in context")
48
52
return nil, fmt.Errorf("malformed middleware")
49
53
}
50
54
51
-
return &ResolvedRepo{
52
-
Repo: *repo,
53
-
}, nil
55
+
return repo, nil
54
56
}
55
57
56
58
// 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`
57
59
// 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`
58
-
// 3. [ ] remove `ResolvedRepo`
60
+
// 3. [x] remove `ResolvedRepo`
59
61
// 4. [ ] replace reporesolver to reposervice
60
62
func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {
61
63
ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)