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