boltless.me
RepoInfo is mostly designed for rendering, don't use it for service
logic.
Signed-off-by: Seongmin Lee git@boltless.me
+2
-3
appview/issues/issues.go
+2
-3
appview/issues/issues.go
···
226
l := rp.logger.With("handler", "DeleteIssue")
227
noticeId := "issue-actions-error"
228
229
-
user := rp.oauth.GetUser(r)
230
-
231
f, err := rp.repoResolver.Resolve(r)
232
if err != nil {
233
l.Error("failed to get repo and knot", "err", err)
···
271
rp.notifier.DeleteIssue(r.Context(), issue)
272
273
// return to all issues page
274
-
rp.pages.HxRedirect(w, "/"+f.RepoInfo(user).FullName()+"/issues")
275
}
276
277
func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) {
···
226
l := rp.logger.With("handler", "DeleteIssue")
227
noticeId := "issue-actions-error"
228
229
f, err := rp.repoResolver.Resolve(r)
230
if err != nil {
231
l.Error("failed to get repo and knot", "err", err)
···
269
rp.notifier.DeleteIssue(r.Context(), issue)
270
271
// return to all issues page
272
+
ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
273
+
rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")
274
}
275
276
func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) {
+13
-20
appview/pipelines/pipelines.go
+13
-20
appview/pipelines/pipelines.go
···
78
return
79
}
80
81
-
repoInfo := f.RepoInfo(user)
82
-
83
ps, err := db.GetPipelineStatuses(
84
p.db,
85
-
db.FilterEq("repo_owner", repoInfo.OwnerDid),
86
-
db.FilterEq("repo_name", repoInfo.Name),
87
-
db.FilterEq("knot", repoInfo.Knot),
88
)
89
if err != nil {
90
l.Error("failed to query db", "err", err)
···
93
94
p.pages.Pipelines(w, pages.PipelinesParams{
95
LoggedInUser: user,
96
-
RepoInfo: repoInfo,
97
Pipelines: ps,
98
})
99
}
···
108
return
109
}
110
111
-
repoInfo := f.RepoInfo(user)
112
-
113
pipelineId := chi.URLParam(r, "pipeline")
114
if pipelineId == "" {
115
l.Error("empty pipeline ID")
···
124
125
ps, err := db.GetPipelineStatuses(
126
p.db,
127
-
db.FilterEq("repo_owner", repoInfo.OwnerDid),
128
-
db.FilterEq("repo_name", repoInfo.Name),
129
-
db.FilterEq("knot", repoInfo.Knot),
130
db.FilterEq("id", pipelineId),
131
)
132
if err != nil {
···
143
144
p.pages.Workflow(w, pages.WorkflowParams{
145
LoggedInUser: user,
146
-
RepoInfo: repoInfo,
147
Pipeline: singlePipeline,
148
Workflow: workflow,
149
})
···
174
ctx, cancel := context.WithCancel(r.Context())
175
defer cancel()
176
177
-
user := p.oauth.GetUser(r)
178
f, err := p.repoResolver.Resolve(r)
179
if err != nil {
180
l.Error("failed to get repo and knot", "err", err)
···
182
return
183
}
184
185
-
repoInfo := f.RepoInfo(user)
186
-
187
pipelineId := chi.URLParam(r, "pipeline")
188
workflow := chi.URLParam(r, "workflow")
189
if pipelineId == "" || workflow == "" {
···
193
194
ps, err := db.GetPipelineStatuses(
195
p.db,
196
-
db.FilterEq("repo_owner", repoInfo.OwnerDid),
197
-
db.FilterEq("repo_name", repoInfo.Name),
198
-
db.FilterEq("knot", repoInfo.Knot),
199
db.FilterEq("id", pipelineId),
200
)
201
if err != nil || len(ps) != 1 {
···
205
}
206
207
singlePipeline := ps[0]
208
-
spindle := repoInfo.Spindle
209
-
knot := repoInfo.Knot
210
rkey := singlePipeline.Rkey
211
212
if spindle == "" || knot == "" || rkey == "" {
···
78
return
79
}
80
81
ps, err := db.GetPipelineStatuses(
82
p.db,
83
+
db.FilterEq("repo_owner", f.Did),
84
+
db.FilterEq("repo_name", f.Name),
85
+
db.FilterEq("knot", f.Knot),
86
)
87
if err != nil {
88
l.Error("failed to query db", "err", err)
···
91
92
p.pages.Pipelines(w, pages.PipelinesParams{
93
LoggedInUser: user,
94
+
RepoInfo: f.RepoInfo(user),
95
Pipelines: ps,
96
})
97
}
···
106
return
107
}
108
109
pipelineId := chi.URLParam(r, "pipeline")
110
if pipelineId == "" {
111
l.Error("empty pipeline ID")
···
120
121
ps, err := db.GetPipelineStatuses(
122
p.db,
123
+
db.FilterEq("repo_owner", f.Did),
124
+
db.FilterEq("repo_name", f.Name),
125
+
db.FilterEq("knot", f.Knot),
126
db.FilterEq("id", pipelineId),
127
)
128
if err != nil {
···
139
140
p.pages.Workflow(w, pages.WorkflowParams{
141
LoggedInUser: user,
142
+
RepoInfo: f.RepoInfo(user),
143
Pipeline: singlePipeline,
144
Workflow: workflow,
145
})
···
170
ctx, cancel := context.WithCancel(r.Context())
171
defer cancel()
172
173
f, err := p.repoResolver.Resolve(r)
174
if err != nil {
175
l.Error("failed to get repo and knot", "err", err)
···
177
return
178
}
179
180
pipelineId := chi.URLParam(r, "pipeline")
181
workflow := chi.URLParam(r, "workflow")
182
if pipelineId == "" || workflow == "" {
···
186
187
ps, err := db.GetPipelineStatuses(
188
p.db,
189
+
db.FilterEq("repo_owner", f.Did),
190
+
db.FilterEq("repo_name", f.Name),
191
+
db.FilterEq("knot", f.Knot),
192
db.FilterEq("id", pipelineId),
193
)
194
if err != nil || len(ps) != 1 {
···
198
}
199
200
singlePipeline := ps[0]
201
+
spindle := f.Spindle
202
+
knot := f.Knot
203
rkey := singlePipeline.Rkey
204
205
if spindle == "" || knot == "" || rkey == "" {
+7
-10
appview/pulls/pulls.go
+7
-10
appview/pulls/pulls.go
···
162
resubmitResult = s.resubmitCheck(r, f, pull, stack)
163
}
164
165
-
repoInfo := f.RepoInfo(user)
166
-
167
m := make(map[string]models.Pipeline)
168
169
var shas []string
···
179
180
ps, err := db.GetPipelineStatuses(
181
s.db,
182
-
db.FilterEq("repo_owner", repoInfo.OwnerDid),
183
-
db.FilterEq("repo_name", repoInfo.Name),
184
-
db.FilterEq("knot", repoInfo.Knot),
185
db.FilterIn("sha", shas),
186
)
187
if err != nil {
···
222
223
s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{
224
LoggedInUser: user,
225
-
RepoInfo: repoInfo,
226
Pull: pull,
227
Stack: stack,
228
AbandonedPulls: abandonedPulls,
···
646
}
647
pulls = pulls[:n]
648
649
-
repoInfo := f.RepoInfo(user)
650
ps, err := db.GetPipelineStatuses(
651
s.db,
652
-
db.FilterEq("repo_owner", repoInfo.OwnerDid),
653
-
db.FilterEq("repo_name", repoInfo.Name),
654
-
db.FilterEq("knot", repoInfo.Knot),
655
db.FilterIn("sha", shas),
656
)
657
if err != nil {
···
162
resubmitResult = s.resubmitCheck(r, f, pull, stack)
163
}
164
165
m := make(map[string]models.Pipeline)
166
167
var shas []string
···
177
178
ps, err := db.GetPipelineStatuses(
179
s.db,
180
+
db.FilterEq("repo_owner", f.Did),
181
+
db.FilterEq("repo_name", f.Name),
182
+
db.FilterEq("knot", f.Knot),
183
db.FilterIn("sha", shas),
184
)
185
if err != nil {
···
220
221
s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{
222
LoggedInUser: user,
223
+
RepoInfo: f.RepoInfo(user),
224
Pull: pull,
225
Stack: stack,
226
AbandonedPulls: abandonedPulls,
···
644
}
645
pulls = pulls[:n]
646
647
ps, err := db.GetPipelineStatuses(
648
s.db,
649
+
db.FilterEq("repo_owner", f.Did),
650
+
db.FilterEq("repo_name", f.Name),
651
+
db.FilterEq("knot", f.Knot),
652
db.FilterIn("sha", shas),
653
)
654
if err != nil {
+2
-6
appview/repo/compare.go
+2
-6
appview/repo/compare.go
···
88
return
89
}
90
91
-
repoinfo := f.RepoInfo(user)
92
-
93
rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{
94
LoggedInUser: user,
95
-
RepoInfo: repoinfo,
96
Branches: branches,
97
Tags: tags.Tags,
98
Base: base,
···
198
diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)
199
}
200
201
-
repoinfo := f.RepoInfo(user)
202
-
203
rp.pages.RepoCompare(w, pages.RepoCompareParams{
204
LoggedInUser: user,
205
-
RepoInfo: repoinfo,
206
Branches: branches.Branches,
207
Tags: tags.Tags,
208
Base: base,
···
88
return
89
}
90
91
rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{
92
LoggedInUser: user,
93
+
RepoInfo: f.RepoInfo(user),
94
Branches: branches,
95
Tags: tags.Tags,
96
Base: base,
···
196
diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)
197
}
198
199
rp.pages.RepoCompare(w, pages.RepoCompareParams{
200
LoggedInUser: user,
201
+
RepoInfo: f.RepoInfo(user),
202
Branches: branches.Branches,
203
Tags: tags.Tags,
204
Base: base,
+3
-4
appview/repo/index.go
+3
-4
appview/repo/index.go
···
52
}
53
54
user := rp.oauth.GetUser(r)
55
-
repoInfo := f.RepoInfo(user)
56
57
// Build index response from multiple XRPC calls
58
result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
···
62
rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
63
LoggedInUser: user,
64
NeedsKnotUpgrade: true,
65
-
RepoInfo: repoInfo,
66
})
67
return
68
}
···
140
for _, c := range commitsTrunc {
141
shas = append(shas, c.Hash.String())
142
}
143
-
pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)
144
if err != nil {
145
l.Error("failed to fetch pipeline statuses", "err", err)
146
// non-fatal
···
148
149
rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
150
LoggedInUser: user,
151
-
RepoInfo: repoInfo,
152
TagMap: tagMap,
153
RepoIndexResponse: *result,
154
CommitsTrunc: commitsTrunc,
···
52
}
53
54
user := rp.oauth.GetUser(r)
55
56
// Build index response from multiple XRPC calls
57
result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
···
61
rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
62
LoggedInUser: user,
63
NeedsKnotUpgrade: true,
64
+
RepoInfo: f.RepoInfo(user),
65
})
66
return
67
}
···
139
for _, c := range commitsTrunc {
140
shas = append(shas, c.Hash.String())
141
}
142
+
pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
143
if err != nil {
144
l.Error("failed to fetch pipeline statuses", "err", err)
145
// non-fatal
···
147
148
rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
149
LoggedInUser: user,
150
+
RepoInfo: f.RepoInfo(user),
151
TagMap: tagMap,
152
RepoIndexResponse: *result,
153
CommitsTrunc: commitsTrunc,
+3
-6
appview/repo/log.go
+3
-6
appview/repo/log.go
···
121
l.Error("failed to GetVerifiedObjectCommits", "err", err)
122
}
123
124
-
repoInfo := f.RepoInfo(user)
125
-
126
var shas []string
127
for _, c := range xrpcResp.Commits {
128
shas = append(shas, c.Hash.String())
129
}
130
-
pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)
131
if err != nil {
132
l.Error("failed to getPipelineStatuses", "err", err)
133
// non-fatal
···
136
rp.pages.RepoLog(w, pages.RepoLogParams{
137
LoggedInUser: user,
138
TagMap: tagMap,
139
-
RepoInfo: repoInfo,
140
RepoLogResponse: xrpcResp,
141
EmailToDid: emailToDidMap,
142
VerifiedCommits: vc,
···
200
}
201
202
user := rp.oauth.GetUser(r)
203
-
repoInfo := f.RepoInfo(user)
204
-
pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})
205
if err != nil {
206
l.Error("failed to getPipelineStatuses", "err", err)
207
// non-fatal
···
121
l.Error("failed to GetVerifiedObjectCommits", "err", err)
122
}
123
124
var shas []string
125
for _, c := range xrpcResp.Commits {
126
shas = append(shas, c.Hash.String())
127
}
128
+
pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
129
if err != nil {
130
l.Error("failed to getPipelineStatuses", "err", err)
131
// non-fatal
···
134
rp.pages.RepoLog(w, pages.RepoLogParams{
135
LoggedInUser: user,
136
TagMap: tagMap,
137
+
RepoInfo: f.RepoInfo(user),
138
RepoLogResponse: xrpcResp,
139
EmailToDid: emailToDidMap,
140
VerifiedCommits: vc,
···
198
}
199
200
user := rp.oauth.GetUser(r)
201
+
pipelines, err := getPipelineStatuses(rp.db, &f.Repo, []string{result.Diff.Commit.This})
202
if err != nil {
203
l.Error("failed to getPipelineStatuses", "err", err)
204
// non-fatal
+2
-3
appview/repo/repo.go
+2
-3
appview/repo/repo.go
···
959
return
960
}
961
962
-
repoInfo := f.RepoInfo(user)
963
-
if repoInfo.Source == nil {
964
rp.pages.Notice(w, "repo", "This repository is not a fork.")
965
return
966
}
···
971
&tangled.RepoForkSync_Input{
972
Did: user.Did,
973
Name: f.Name,
974
-
Source: repoInfo.Source.RepoAt().String(),
975
Branch: ref,
976
},
977
)
+4
-5
appview/repo/repo_util.go
+4
-5
appview/repo/repo_util.go
···
9
10
"tangled.org/core/appview/db"
11
"tangled.org/core/appview/models"
12
-
"tangled.org/core/appview/pages/repoinfo"
13
"tangled.org/core/types"
14
15
"github.com/go-git/go-git/v5/plumbing/object"
···
107
// golang is so blessed that it requires 35 lines of imperative code for this
108
func getPipelineStatuses(
109
d *db.DB,
110
-
repoInfo repoinfo.RepoInfo,
111
shas []string,
112
) (map[string]models.Pipeline, error) {
113
m := make(map[string]models.Pipeline)
···
118
119
ps, err := db.GetPipelineStatuses(
120
d,
121
-
db.FilterEq("repo_owner", repoInfo.OwnerDid),
122
-
db.FilterEq("repo_name", repoInfo.Name),
123
-
db.FilterEq("knot", repoInfo.Knot),
124
db.FilterIn("sha", shas),
125
)
126
if err != nil {
···
9
10
"tangled.org/core/appview/db"
11
"tangled.org/core/appview/models"
12
"tangled.org/core/types"
13
14
"github.com/go-git/go-git/v5/plumbing/object"
···
106
// golang is so blessed that it requires 35 lines of imperative code for this
107
func getPipelineStatuses(
108
d *db.DB,
109
+
repo *models.Repo,
110
shas []string,
111
) (map[string]models.Pipeline, error) {
112
m := make(map[string]models.Pipeline)
···
117
118
ps, err := db.GetPipelineStatuses(
119
d,
120
+
db.FilterEq("repo_owner", repo.Did),
121
+
db.FilterEq("repo_name", repo.Name),
122
+
db.FilterEq("knot", repo.Knot),
123
db.FilterIn("sha", shas),
124
)
125
if err != nil {