···
1018
-
patch := r.FormValue("patch")
1019
-
var sourceRev string
1020
-
var recordPullSource *tangled.RepoPull_Source
1022
-
var ownerDid, repoName, knotName string
1023
-
var isSameRepo bool = pull.IsSameRepoBranch()
1024
-
sourceBranch := pull.PullSource.Branch
1025
-
targetBranch := pull.TargetBranch
1026
-
recordPullSource = &tangled.RepoPull_Source{
1027
-
Branch: sourceBranch,
1018
+
if pull.IsPatchBased() {
1019
+
s.resubmitPatch(w, r)
1021
+
} else if pull.IsBranchBased() {
1022
+
s.resubmitBranch(w, r)
1024
+
} else if pull.IsForkBased() {
1025
+
s.resubmitFork(w, r)
1030
-
isPushAllowed := f.RepoInfo(s, user).Roles.IsPushAllowed()
1031
-
if isSameRepo && isPushAllowed {
1032
-
ownerDid = f.OwnerDid()
1033
-
repoName = f.RepoName
1035
-
} else if !isSameRepo {
1036
-
sourceRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
1038
-
log.Println("failed to get source repo", err)
1039
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1042
-
ownerDid = sourceRepo.Did
1043
-
repoName = sourceRepo.Name
1044
-
knotName = sourceRepo.Knot
1031
+
func (s *State) resubmitPatch(w http.ResponseWriter, r *http.Request) {
1032
+
user := s.auth.GetUser(r)
1034
+
pull, ok := r.Context().Value("pull").(*db.Pull)
1036
+
log.Println("failed to get pull")
1037
+
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
1041
+
f, err := fullyResolvedRepo(r)
1043
+
log.Println("failed to get repo and knot", err)
1047
+
if user.Did != pull.OwnerDid {
1048
+
log.Println("unauthorized user")
1049
+
w.WriteHeader(http.StatusUnauthorized)
1053
+
patch := r.FormValue("patch")
1056
+
s.pages.Notice(w, "resubmit-error", "Patch is empty.")
1060
+
if patch == pull.LatestPatch() {
1061
+
s.pages.Notice(w, "resubmit-error", "Patch is identical to previous submission.")
1047
-
if sourceBranch != "" && knotName != "" {
1048
-
// extract patch by performing compare
1049
-
ksClient, err := NewUnsignedClient(knotName, s.config.Dev)
1051
-
log.Printf("failed to create client for %s: %s", knotName, err)
1052
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1065
+
if !isPatchValid(patch) {
1066
+
s.pages.Notice(w, "resubmit-error", "Invalid patch format. Please provide a valid diff.")
1057
-
secret, err := db.GetRegistrationKey(s.db, knotName)
1059
-
log.Printf("failed to get registration key for %s: %s", knotName, err)
1060
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1063
-
// update the hidden tracking branch to latest
1064
-
signedClient, err := NewSignedClient(knotName, secret, s.config.Dev)
1066
-
log.Printf("failed to create signed client for %s: %s", knotName, err)
1067
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1070
-
resp, err := signedClient.NewHiddenRef(ownerDid, repoName, sourceBranch, targetBranch)
1071
-
if err != nil || resp.StatusCode != http.StatusNoContent {
1072
-
log.Printf("failed to update tracking branch: %s", err)
1073
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1070
+
tx, err := s.db.BeginTx(r.Context(), nil)
1072
+
log.Println("failed to start tx")
1073
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1076
+
defer tx.Rollback()
1078
-
var compareResp *http.Response
1080
-
hiddenRef := url.QueryEscape(fmt.Sprintf("hidden/%s/%s", sourceBranch, targetBranch))
1081
-
compareResp, err = ksClient.Compare(ownerDid, repoName, hiddenRef, sourceBranch)
1083
-
compareResp, err = ksClient.Compare(ownerDid, repoName, targetBranch, sourceBranch)
1086
-
log.Printf("failed to compare branches: %s", err)
1087
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1090
-
defer compareResp.Body.Close()
1078
+
err = db.ResubmitPull(tx, pull, patch, "")
1080
+
log.Println("failed to resubmit pull request", err)
1081
+
s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull request. Try again later.")
1084
+
client, _ := s.auth.AuthorizedClient(r)
1092
-
switch compareResp.StatusCode {
1095
-
s.pages.Notice(w, "pull", "Branch based pull requests are not supported on this knot.")
1086
+
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Did, pull.Rkey)
1088
+
// failed to get record
1089
+
s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
1099
-
respBody, err := io.ReadAll(compareResp.Body)
1101
-
log.Println("failed to compare across branches")
1102
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1105
-
defer compareResp.Body.Close()
1093
+
_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1094
+
Collection: tangled.RepoPullNSID,
1097
+
SwapRecord: ex.Cid,
1098
+
Record: &lexutil.LexiconTypeDecoder{
1099
+
Val: &tangled.RepoPull{
1100
+
Title: pull.Title,
1101
+
PullId: int64(pull.PullId),
1102
+
TargetRepo: string(f.RepoAt),
1103
+
TargetBranch: pull.TargetBranch,
1104
+
Patch: patch, // new patch
1109
+
log.Println("failed to update record", err)
1110
+
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1107
-
var diffTreeResponse types.RepoDiffTreeResponse
1108
-
err = json.Unmarshal(respBody, &diffTreeResponse)
1110
-
log.Println("failed to unmarshal diff tree response", err)
1111
-
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1114
+
if err = tx.Commit(); err != nil {
1115
+
log.Println("failed to commit transaction", err)
1116
+
s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")
1115
-
sourceRev = diffTreeResponse.DiffTree.Rev2
1116
-
patch = diffTreeResponse.DiffTree.Patch
1120
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
1120
-
s.pages.Notice(w, "resubmit-error", "Patch is empty.")
1124
+
func (s *State) resubmitBranch(w http.ResponseWriter, r *http.Request) {
1125
+
user := s.auth.GetUser(r)
1124
-
if patch == pull.LatestPatch() {
1125
-
s.pages.Notice(w, "resubmit-error", "Patch is identical to previous submission.")
1127
+
pull, ok := r.Context().Value("pull").(*db.Pull)
1129
+
log.Println("failed to get pull")
1130
+
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
1129
-
if sourceRev == pull.Submissions[pull.LastRoundNumber()].SourceRev {
1130
-
s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.")
1134
+
f, err := fullyResolvedRepo(r)
1136
+
log.Println("failed to get repo and knot", err)
1134
-
if !isPatchValid(patch) {
1135
-
s.pages.Notice(w, "resubmit-error", "Invalid patch format. Please provide a valid diff.")
1140
+
if user.Did != pull.OwnerDid {
1141
+
log.Println("unauthorized user")
1142
+
w.WriteHeader(http.StatusUnauthorized)
1139
-
tx, err := s.db.BeginTx(r.Context(), nil)
1141
-
log.Println("failed to start tx")
1142
-
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1145
-
defer tx.Rollback()
1146
+
if !f.RepoInfo(s, user).Roles.IsPushAllowed() {
1147
+
log.Println("unauthorized user")
1148
+
w.WriteHeader(http.StatusUnauthorized)
1147
-
err = db.ResubmitPull(tx, pull, patch, sourceRev)
1149
-
log.Println("failed to create pull request", err)
1150
-
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1153
-
client, _ := s.auth.AuthorizedClient(r)
1152
+
ksClient, err := NewUnsignedClient(f.Knot, s.config.Dev)
1154
+
log.Printf("failed to create client for %s: %s", f.Knot, err)
1155
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1155
-
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Did, pull.Rkey)
1157
-
// failed to get record
1158
-
s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
1159
+
compareResp, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch)
1161
+
log.Printf("failed to compare branches: %s", err)
1162
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1165
+
defer compareResp.Body.Close()
1162
-
_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1163
-
Collection: tangled.RepoPullNSID,
1166
-
SwapRecord: ex.Cid,
1167
-
Record: &lexutil.LexiconTypeDecoder{
1168
-
Val: &tangled.RepoPull{
1169
-
Title: pull.Title,
1170
-
PullId: int64(pull.PullId),
1171
-
TargetRepo: string(f.RepoAt),
1172
-
TargetBranch: pull.TargetBranch,
1173
-
Patch: patch, // new patch
1174
-
Source: recordPullSource,
1167
+
switch compareResp.StatusCode {
1170
+
s.pages.Notice(w, "pull", "Branch based pull requests are not supported on this knot.")
1174
+
respBody, err := io.ReadAll(compareResp.Body)
1176
+
log.Println("failed to compare across branches")
1177
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1180
+
defer compareResp.Body.Close()
1182
+
var diffTreeResponse types.RepoDiffTreeResponse
1183
+
err = json.Unmarshal(respBody, &diffTreeResponse)
1185
+
log.Println("failed to unmarshal diff tree response", err)
1186
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1190
+
sourceRev := diffTreeResponse.DiffTree.Rev2
1191
+
patch := diffTreeResponse.DiffTree.Patch
1194
+
s.pages.Notice(w, "resubmit-error", "Patch is empty.")
1198
+
if patch == pull.LatestPatch() {
1199
+
s.pages.Notice(w, "resubmit-error", "Patch is identical to previous submission.")
1203
+
if !isPatchValid(patch) {
1204
+
s.pages.Notice(w, "resubmit-error", "Invalid patch format. Please provide a valid diff.")
1208
+
if sourceRev == pull.Submissions[pull.LastRoundNumber()].SourceRev {
1209
+
s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.")
1213
+
tx, err := s.db.BeginTx(r.Context(), nil)
1215
+
log.Println("failed to start tx")
1216
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1219
+
defer tx.Rollback()
1221
+
err = db.ResubmitPull(tx, pull, patch, sourceRev)
1223
+
log.Println("failed to create pull request", err)
1224
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1227
+
client, _ := s.auth.AuthorizedClient(r)
1229
+
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Did, pull.Rkey)
1231
+
// failed to get record
1232
+
s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
1236
+
recordPullSource := &tangled.RepoPull_Source{
1237
+
Branch: pull.PullSource.Branch,
1239
+
_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1240
+
Collection: tangled.RepoPullNSID,
1243
+
SwapRecord: ex.Cid,
1244
+
Record: &lexutil.LexiconTypeDecoder{
1245
+
Val: &tangled.RepoPull{
1246
+
Title: pull.Title,
1247
+
PullId: int64(pull.PullId),
1248
+
TargetRepo: string(f.RepoAt),
1249
+
TargetBranch: pull.TargetBranch,
1250
+
Patch: patch, // new patch
1251
+
Source: recordPullSource,
1179
-
log.Println("failed to update record", err)
1180
-
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1256
+
log.Println("failed to update record", err)
1257
+
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1261
+
if err = tx.Commit(); err != nil {
1262
+
log.Println("failed to commit transaction", err)
1263
+
s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")
1267
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
1271
+
func (s *State) resubmitFork(w http.ResponseWriter, r *http.Request) {
1272
+
user := s.auth.GetUser(r)
1274
+
pull, ok := r.Context().Value("pull").(*db.Pull)
1276
+
log.Println("failed to get pull")
1277
+
s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
1281
+
f, err := fullyResolvedRepo(r)
1283
+
log.Println("failed to get repo and knot", err)
1287
+
if user.Did != pull.OwnerDid {
1288
+
log.Println("unauthorized user")
1289
+
w.WriteHeader(http.StatusUnauthorized)
1293
+
forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
1295
+
log.Println("failed to get source repo", err)
1296
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1300
+
// extract patch by performing compare
1301
+
ksClient, err := NewUnsignedClient(forkRepo.Knot, s.config.Dev)
1303
+
log.Printf("failed to create client for %s: %s", forkRepo.Knot, err)
1304
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1308
+
secret, err := db.GetRegistrationKey(s.db, forkRepo.Knot)
1310
+
log.Printf("failed to get registration key for %s: %s", forkRepo.Knot, err)
1311
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1314
+
// update the hidden tracking branch to latest
1315
+
signedClient, err := NewSignedClient(forkRepo.Knot, secret, s.config.Dev)
1317
+
log.Printf("failed to create signed client for %s: %s", forkRepo.Knot, err)
1318
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1321
+
resp, err := signedClient.NewHiddenRef(forkRepo.Did, forkRepo.Name, pull.PullSource.Branch, pull.TargetBranch)
1322
+
if err != nil || resp.StatusCode != http.StatusNoContent {
1323
+
log.Printf("failed to update tracking branch: %s", err)
1324
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1328
+
hiddenRef := url.QueryEscape(fmt.Sprintf("hidden/%s/%s", pull.PullSource.Branch, pull.TargetBranch))
1329
+
compareResp, err := ksClient.Compare(forkRepo.Did, forkRepo.Name, hiddenRef, pull.PullSource.Branch)
1331
+
log.Printf("failed to compare branches: %s", err)
1332
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1335
+
defer compareResp.Body.Close()
1337
+
switch compareResp.StatusCode {
1340
+
s.pages.Notice(w, "pull", "Branch based pull requests are not supported on this knot.")
1344
+
respBody, err := io.ReadAll(compareResp.Body)
1346
+
log.Println("failed to compare across branches")
1347
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1350
+
defer compareResp.Body.Close()
1184
-
if err = tx.Commit(); err != nil {
1185
-
log.Println("failed to commit transaction", err)
1186
-
s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")
1352
+
var diffTreeResponse types.RepoDiffTreeResponse
1353
+
err = json.Unmarshal(respBody, &diffTreeResponse)
1355
+
log.Println("failed to unmarshal diff tree response", err)
1356
+
s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
1360
+
sourceRev := diffTreeResponse.DiffTree.Rev2
1361
+
patch := diffTreeResponse.DiffTree.Patch
1190
-
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
1364
+
s.pages.Notice(w, "resubmit-error", "Patch is empty.")
1368
+
if patch == pull.LatestPatch() {
1369
+
s.pages.Notice(w, "resubmit-error", "Patch is identical to previous submission.")
1373
+
if !isPatchValid(patch) {
1374
+
s.pages.Notice(w, "resubmit-error", "Invalid patch format. Please provide a valid diff.")
1378
+
if sourceRev == pull.Submissions[pull.LastRoundNumber()].SourceRev {
1379
+
s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.")
1383
+
tx, err := s.db.BeginTx(r.Context(), nil)
1385
+
log.Println("failed to start tx")
1386
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1389
+
defer tx.Rollback()
1391
+
err = db.ResubmitPull(tx, pull, patch, sourceRev)
1393
+
log.Println("failed to create pull request", err)
1394
+
s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
1397
+
client, _ := s.auth.AuthorizedClient(r)
1399
+
ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoPullNSID, user.Did, pull.Rkey)
1401
+
// failed to get record
1402
+
s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")
1406
+
repoAt := pull.PullSource.RepoAt.String()
1407
+
recordPullSource := &tangled.RepoPull_Source{
1408
+
Branch: pull.PullSource.Branch,
1411
+
_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
1412
+
Collection: tangled.RepoPullNSID,
1415
+
SwapRecord: ex.Cid,
1416
+
Record: &lexutil.LexiconTypeDecoder{
1417
+
Val: &tangled.RepoPull{
1418
+
Title: pull.Title,
1419
+
PullId: int64(pull.PullId),
1420
+
TargetRepo: string(f.RepoAt),
1421
+
TargetBranch: pull.TargetBranch,
1422
+
Patch: patch, // new patch
1423
+
Source: recordPullSource,
1428
+
log.Println("failed to update record", err)
1429
+
s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
1433
+
if err = tx.Commit(); err != nil {
1434
+
log.Println("failed to commit transaction", err)
1435
+
s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")
1439
+
s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))
func (s *State) MergePull(w http.ResponseWriter, r *http.Request) {
julien.rbrt.fr
oppi.li