appview: prefer models.Repo over ResolvedRepo internally #812

···

       
115
       
115
       
 
       
			return

     

       
116
       
116
       
 
       
		}

     

       
117
       
117
       
 
       


     

       
118
       
118
       
-
       
		mergeCheckResponse := s.mergeCheck(r, f, pull, stack)

     

       
119
       
119
       
-
       
		branchDeleteStatus := s.branchDeleteStatus(r, f, pull)

     

       
118
       
118
       
+
       
		mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)

     

       
119
       
119
       
+
       
		branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)

     

       
120
       
120
       
 
       
		resubmitResult := pages.Unknown

     

       
121
       
121
       
 
       
		if user.Did == pull.OwnerDid {

     

       
122
       
122
       
-
       
			resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       
122
       
122
       
+
       
			resubmitResult = s.resubmitCheck(r, &f.Repo, 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
       
158
       
-
       
	mergeCheckResponse := s.mergeCheck(r, f, pull, stack)

     

       
159
       
159
       
-
       
	branchDeleteStatus := s.branchDeleteStatus(r, f, pull)

     

       
158
       
158
       
+
       
	mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)

     

       
159
       
159
       
+
       
	branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)

     

       
160
       
160
       
 
       
	resubmitResult := pages.Unknown

     

       
161
       
161
       
 
       
	if user != nil && user.Did == pull.OwnerDid {

     

       
162
       
162
       
-
       
		resubmitResult = s.resubmitCheck(r, f, pull, stack)

     

       
162
       
162
       
+
       
		resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)

     

       
163
       
163
       
 
       
	}

     

       
164
       
164
       
 
       


     

       
165
       
165
       
 
       
	m := make(map[string]models.Pipeline)

     
···

       
237
       
237
       
 
       
	})

     

       
238
       
238
       
 
       
}

     

       
239
       
239
       
 
       


     

       
240
       
240
       
-
       
func (s *Pulls) mergeCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {

     

       
240
       
240
       
+
       
func (s *Pulls) mergeCheck(r *http.Request, f *models.Repo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse {

     

       
241
       
241
       
 
       
	if pull.State == models.PullMerged {

     

       
242
       
242
       
 
       
		return types.MergeCheckResponse{}

     

       
243
       
243
       
 
       
	}

     
···

       
304
       
304
       
 
       
	return result

     

       
305
       
305
       
 
       
}

     

       
306
       
306
       
 
       


     

       
307
       
307
       
-
       
func (s *Pulls) branchDeleteStatus(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull) *models.BranchDeleteStatus {

     

       
307
       
307
       
+
       
func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *models.Pull) *models.BranchDeleteStatus {

     

       
308
       
308
       
 
       
	if pull.State != models.PullMerged {

     

       
309
       
309
       
 
       
		return nil

     

       
310
       
310
       
 
       
	}

     
···

       
315
       
315
       
 
       
	}

     

       
316
       
316
       
 
       


     

       
317
       
317
       
 
       
	var branch string

     

       
318
       
318
       
-
       
	var repo *models.Repo

     

       
319
       
318
       
 
       
	// check if the branch exists

     

       
320
       
319
       
 
       
	// NOTE: appview could cache branches/tags etc. for every repo by listening for gitRefUpdates

     

       
321
       
320
       
 
       
	if pull.IsBranchBased() {

     

       
322
       
321
       
 
       
		branch = pull.PullSource.Branch

     

       
323
       
323
       
-
       
		repo = &f.Repo

     

       
324
       
322
       
 
       
	} else if pull.IsForkBased() {

     

       
325
       
323
       
 
       
		branch = pull.PullSource.Branch

     

       
326
       
324
       
 
       
		repo = pull.PullSource.Repo

     
···

       
359
       
357
       
 
       
	}

     

       
360
       
358
       
 
       
}

     

       
361
       
359
       
 
       


     

       
362
       
362
       
-
       
func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {

     

       
360
       
360
       
+
       
func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.Pull, stack models.Stack) pages.ResubmitResult {

     

       
363
       
361
       
 
       
	if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil {

     

       
364
       
362
       
 
       
		return pages.Unknown

     

       
365
       
363
       
 
       
	}

     
···

       
379
       
377
       
 
       
		repoName = sourceRepo.Name

     

       
380
       
378
       
 
       
	} else {

     

       
381
       
379
       
 
       
		// pulls within the same repo

     

       
382
       
382
       
-
       
		knot = f.Knot

     

       
383
       
383
       
-
       
		ownerDid = f.Did

     

       
384
       
384
       
-
       
		repoName = f.Name

     

       
380
       
380
       
+
       
		knot = repo.Knot

     

       
381
       
381
       
+
       
		ownerDid = repo.Did

     

       
382
       
382
       
+
       
		repoName = repo.Name

     

       
385
       
383
       
 
       
	}

     

       
386
       
384
       
 
       


     

       
387
       
385
       
 
       
	scheme := "http"

     
···

       
393
       
391
       
 
       
		Host: host,

     

       
394
       
392
       
 
       
	}

     

       
395
       
393
       
 
       


     

       
396
       
396
       
-
       
	repo := fmt.Sprintf("%s/%s", ownerDid, repoName)

     

       
397
       
397
       
-
       
	branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, repo)

     

       
394
       
394
       
+
       
	didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)

     

       
395
       
395
       
+
       
	branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)

     

       
398
       
396
       
 
       
	if err != nil {

     

       
399
       
397
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
400
       
398
       
 
       
			log.Println("failed to call XRPC repo.branches", xrpcerr)

     
···

       
951
       
949
       
 
       
				s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")

     

       
952
       
950
       
 
       
				return

     

       
953
       
951
       
 
       
			}

     

       
954
       
954
       
-
       
			s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)

     

       
952
       
952
       
+
       
			s.handleBranchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, sourceBranch, isStacked)

     

       
955
       
953
       
 
       
		} else if isForkBased {

     

       
956
       
954
       
 
       
			if !caps.PullRequests.ForkSubmissions {

     

       
957
       
955
       
 
       
				s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")

     

       
958
       
956
       
 
       
				return

     

       
959
       
957
       
 
       
			}

     

       
960
       
960
       
-
       
			s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)

     

       
958
       
958
       
+
       
			s.handleForkBasedPull(w, r, &f.Repo, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)

     

       
961
       
959
       
 
       
		} else if isPatchBased {

     

       
962
       
960
       
 
       
			if !caps.PullRequests.PatchSubmissions {

     

       
963
       
961
       
 
       
				s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")

     

       
964
       
962
       
 
       
				return

     

       
965
       
963
       
 
       
			}

     

       
966
       
966
       
-
       
			s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)

     

       
964
       
964
       
+
       
			s.handlePatchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, patch, isStacked)

     

       
967
       
965
       
 
       
		}

     

       
968
       
966
       
 
       
		return

     

       
969
       
967
       
 
       
	}

     
···

       
972
       
970
       
 
       
func (s *Pulls) handleBranchBasedPull(

     

       
973
       
971
       
 
       
	w http.ResponseWriter,

     

       
974
       
972
       
 
       
	r *http.Request,

     

       
975
       
975
       
-
       
	f *reporesolver.ResolvedRepo,

     

       
973
       
973
       
+
       
	repo *models.Repo,

     

       
976
       
974
       
 
       
	user *oauth.User,

     

       
977
       
975
       
 
       
	title,

     

       
978
       
976
       
 
       
	body,

     
···

       
984
       
982
       
 
       
	if !s.config.Core.Dev {

     

       
985
       
983
       
 
       
		scheme = "https"

     

       
986
       
984
       
 
       
	}

     

       
987
       
987
       
-
       
	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       
985
       
985
       
+
       
	host := fmt.Sprintf("%s://%s", scheme, repo.Knot)

     

       
988
       
986
       
 
       
	xrpcc := &indigoxrpc.Client{

     

       
989
       
987
       
 
       
		Host: host,

     

       
990
       
988
       
 
       
	}

     

       
991
       
989
       
 
       


     

       
992
       
992
       
-
       
	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       
993
       
993
       
-
       
	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, targetBranch, sourceBranch)

     

       
990
       
990
       
+
       
	didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       
991
       
991
       
+
       
	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch)

     

       
994
       
992
       
 
       
	if err != nil {

     

       
995
       
993
       
 
       
		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
996
       
994
       
 
       
			log.Println("failed to call XRPC repo.compare", xrpcerr)

     
···

       
1027
       
1025
       
 
       
		Sha:    comparison.Rev2,

     

       
1028
       
1026
       
 
       
	}

     

       
1029
       
1027
       
 
       


     

       
1030
       
1030
       
-
       
	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       
1028
       
1028
       
+
       
	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       
1031
       
1029
       
 
       
}

     

       
1032
       
1030
       
 
       


     

       
1033
       
1033
       
-
       
func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {

     

       
1031
       
1031
       
+
       
func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {

     

       
1034
       
1032
       
 
       
	if err := s.validator.ValidatePatch(&patch); err != nil {

     

       
1035
       
1033
       
 
       
		s.logger.Error("patch validation failed", "err", err)

     

       
1036
       
1034
       
 
       
		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")

     

       
1037
       
1035
       
 
       
		return

     

       
1038
       
1036
       
 
       
	}

     

       
1039
       
1037
       
 
       


     

       
1040
       
1040
       
-
       
	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)

     

       
1038
       
1038
       
+
       
	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked)

     

       
1041
       
1039
       
 
       
}

     

       
1042
       
1040
       
 
       


     

       
1043
       
1043
       
-
       
func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {

     

       
1041
       
1041
       
+
       
func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {

     

       
1044
       
1042
       
 
       
	repoString := strings.SplitN(forkRepo, "/", 2)

     

       
1045
       
1043
       
 
       
	forkOwnerDid := repoString[0]

     

       
1046
       
1044
       
 
       
	repoName := repoString[1]

     
···

       
1142
       
1140
       
 
       
		Sha:    sourceRev,

     

       
1143
       
1141
       
 
       
	}

     

       
1144
       
1142
       
 
       


     

       
1145
       
1145
       
-
       
	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       
1143
       
1143
       
+
       
	s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked)

     

       
1146
       
1144
       
 
       
}

     

       
1147
       
1145
       
 
       


     

       
1148
       
1146
       
 
       
func (s *Pulls) createPullRequest(

     

       
1149
       
1147
       
 
       
	w http.ResponseWriter,

     

       
1150
       
1148
       
 
       
	r *http.Request,

     

       
1151
       
1151
       
-
       
	f *reporesolver.ResolvedRepo,

     

       
1149
       
1149
       
+
       
	repo *models.Repo,

     

       
1152
       
1150
       
 
       
	user *oauth.User,

     

       
1153
       
1151
       
 
       
	title, body, targetBranch string,

     

       
1154
       
1152
       
 
       
	patch string,

     
···

       
1163
       
1161
       
 
       
		s.createStackedPullRequest(

     

       
1164
       
1162
       
 
       
			w,

     

       
1165
       
1163
       
 
       
			r,

     

       
1166
       
1166
       
-
       
			f,

     

       
1164
       
1164
       
+
       
			repo,

     

       
1167
       
1165
       
 
       
			user,

     

       
1168
       
1166
       
 
       
			targetBranch,

     

       
1169
       
1167
       
 
       
			patch,

     
···

       
1220
       
1218
       
 
       
		Body:         body,

     

       
1221
       
1219
       
 
       
		TargetBranch: targetBranch,

     

       
1222
       
1220
       
 
       
		OwnerDid:     user.Did,

     

       
1223
       
1223
       
-
       
		RepoAt:       f.RepoAt(),

     

       
1221
       
1221
       
+
       
		RepoAt:       repo.RepoAt(),

     

       
1224
       
1222
       
 
       
		Rkey:         rkey,

     

       
1225
       
1223
       
 
       
		Submissions: []*models.PullSubmission{

     

       
1226
       
1224
       
 
       
			&initialSubmission,

     
···

       
1233
       
1231
       
 
       
		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       
1234
       
1232
       
 
       
		return

     

       
1235
       
1233
       
 
       
	}

     

       
1236
       
1236
       
-
       
	pullId, err := db.NextPullId(tx, f.RepoAt())

     

       
1234
       
1234
       
+
       
	pullId, err := db.NextPullId(tx, repo.RepoAt())

     

       
1237
       
1235
       
 
       
	if err != nil {

     

       
1238
       
1236
       
 
       
		log.Println("failed to get pull id", err)

     

       
1239
       
1237
       
 
       
		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     
···

       
1248
       
1246
       
 
       
			Val: &tangled.RepoPull{

     

       
1249
       
1247
       
 
       
				Title: title,

     

       
1250
       
1248
       
 
       
				Target: &tangled.RepoPull_Target{

     

       
1251
       
1251
       
-
       
					Repo:   string(f.RepoAt()),

     

       
1249
       
1249
       
+
       
					Repo:   string(repo.RepoAt()),

     

       
1252
       
1250
       
 
       
					Branch: targetBranch,

     

       
1253
       
1251
       
 
       
				},

     

       
1254
       
1252
       
 
       
				Patch:     patch,

     
···

       
1271
       
1269
       
 
       


     

       
1272
       
1270
       
 
       
	s.notifier.NewPull(r.Context(), pull)

     

       
1273
       
1271
       
 
       


     

       
1274
       
1274
       
-
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       
1272
       
1272
       
+
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       
1275
       
1273
       
 
       
	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pullId))

     

       
1276
       
1274
       
 
       
}

     

       
1277
       
1275
       
 
       


     

       
1278
       
1276
       
 
       
func (s *Pulls) createStackedPullRequest(

     

       
1279
       
1277
       
 
       
	w http.ResponseWriter,

     

       
1280
       
1278
       
 
       
	r *http.Request,

     

       
1281
       
1281
       
-
       
	f *reporesolver.ResolvedRepo,

     

       
1279
       
1279
       
+
       
	repo *models.Repo,

     

       
1282
       
1280
       
 
       
	user *oauth.User,

     

       
1283
       
1281
       
 
       
	targetBranch string,

     

       
1284
       
1282
       
 
       
	patch string,

     
···

       
1310
       
1308
       
 
       


     

       
1311
       
1309
       
 
       
	// build a stack out of this patch

     

       
1312
       
1310
       
 
       
	stackId := uuid.New()

     

       
1313
       
1313
       
-
       
	stack, err := newStack(f, user, targetBranch, patch, pullSource, stackId.String())

     

       
1311
       
1311
       
+
       
	stack, err := newStack(repo, user, targetBranch, patch, pullSource, stackId.String())

     

       
1314
       
1312
       
 
       
	if err != nil {

     

       
1315
       
1313
       
 
       
		log.Println("failed to create stack", err)

     

       
1316
       
1314
       
 
       
		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))

     
···

       
1373
       
1371
       
 
       
		return

     

       
1374
       
1372
       
 
       
	}

     

       
1375
       
1373
       
 
       


     

       
1376
       
1376
       
-
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       
1374
       
1374
       
+
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       
1377
       
1375
       
 
       
	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", ownerSlashRepo))

     

       
1378
       
1376
       
 
       
}

     

       
1379
       
1377
       
 
       


     
···

       
1645
       
1643
       
 
       


     

       
1646
       
1644
       
 
       
	patch := r.FormValue("patch")

     

       
1647
       
1645
       
 
       


     

       
1648
       
1648
       
-
       
	s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")

     

       
1646
       
1646
       
+
       
	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, "", "")

     

       
1649
       
1647
       
 
       
}

     

       
1650
       
1648
       
 
       


     

       
1651
       
1649
       
 
       
func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {

     
···

       
1710
       
1708
       
 
       
	patch := comparison.FormatPatchRaw

     

       
1711
       
1709
       
 
       
	combined := comparison.CombinedPatchRaw

     

       
1712
       
1710
       
 
       


     

       
1713
       
1713
       
-
       
	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)

     

       
1711
       
1711
       
+
       
	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)

     

       
1714
       
1712
       
 
       
}

     

       
1715
       
1713
       
 
       


     

       
1716
       
1714
       
 
       
func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {

     
···

       
1807
       
1805
       
 
       
	patch := comparison.FormatPatchRaw

     

       
1808
       
1806
       
 
       
	combined := comparison.CombinedPatchRaw

     

       
1809
       
1807
       
 
       


     

       
1810
       
1810
       
-
       
	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)

     

       
1808
       
1808
       
+
       
	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)

     

       
1811
       
1809
       
 
       
}

     

       
1812
       
1810
       
 
       


     

       
1813
       
1811
       
 
       
func (s *Pulls) resubmitPullHelper(

     

       
1814
       
1812
       
 
       
	w http.ResponseWriter,

     

       
1815
       
1813
       
 
       
	r *http.Request,

     

       
1816
       
1816
       
-
       
	f *reporesolver.ResolvedRepo,

     

       
1814
       
1814
       
+
       
	repo *models.Repo,

     

       
1817
       
1815
       
 
       
	user *oauth.User,

     

       
1818
       
1816
       
 
       
	pull *models.Pull,

     

       
1819
       
1817
       
 
       
	patch string,

     
···

       
1822
       
1820
       
 
       
) {

     

       
1823
       
1821
       
 
       
	if pull.IsStacked() {

     

       
1824
       
1822
       
 
       
		log.Println("resubmitting stacked PR")

     

       
1825
       
1825
       
-
       
		s.resubmitStackedPullHelper(w, r, f, user, pull, patch, pull.StackId)

     

       
1823
       
1823
       
+
       
		s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)

     

       
1826
       
1824
       
 
       
		return

     

       
1827
       
1825
       
 
       
	}

     

       
1828
       
1826
       
 
       


     
···

       
1902
       
1900
       
 
       
			Val: &tangled.RepoPull{

     

       
1903
       
1901
       
 
       
				Title: pull.Title,

     

       
1904
       
1902
       
 
       
				Target: &tangled.RepoPull_Target{

     

       
1905
       
1905
       
-
       
					Repo:   string(f.RepoAt()),

     

       
1903
       
1903
       
+
       
					Repo:   string(repo.RepoAt()),

     

       
1906
       
1904
       
 
       
					Branch: pull.TargetBranch,

     

       
1907
       
1905
       
 
       
				},

     

       
1908
       
1906
       
 
       
				Patch:     patch, // new patch

     
···

       
1923
       
1921
       
 
       
		return

     

       
1924
       
1922
       
 
       
	}

     

       
1925
       
1923
       
 
       


     

       
1926
       
1926
       
-
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       
1924
       
1924
       
+
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       
1927
       
1925
       
 
       
	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       
1928
       
1926
       
 
       
}

     

       
1929
       
1927
       
 
       


     

       
1930
       
1928
       
 
       
func (s *Pulls) resubmitStackedPullHelper(

     

       
1931
       
1929
       
 
       
	w http.ResponseWriter,

     

       
1932
       
1930
       
 
       
	r *http.Request,

     

       
1933
       
1933
       
-
       
	f *reporesolver.ResolvedRepo,

     

       
1931
       
1931
       
+
       
	repo *models.Repo,

     

       
1934
       
1932
       
 
       
	user *oauth.User,

     

       
1935
       
1933
       
 
       
	pull *models.Pull,

     

       
1936
       
1934
       
 
       
	patch string,

     
···

       
1939
       
1937
       
 
       
	targetBranch := pull.TargetBranch

     

       
1940
       
1938
       
 
       


     

       
1941
       
1939
       
 
       
	origStack, _ := r.Context().Value("stack").(models.Stack)

     

       
1942
       
1942
       
-
       
	newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)

     

       
1940
       
1940
       
+
       
	newStack, err := newStack(repo, user, targetBranch, patch, pull.PullSource, stackId)

     

       
1943
       
1941
       
 
       
	if err != nil {

     

       
1944
       
1942
       
 
       
		log.Println("failed to create resubmitted stack", err)

     

       
1945
       
1943
       
 
       
		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     
···

       
2117
       
2115
       
 
       
		return

     

       
2118
       
2116
       
 
       
	}

     

       
2119
       
2117
       
 
       


     

       
2120
       
2120
       
-
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)

     

       
2118
       
2118
       
+
       
	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo)

     

       
2121
       
2119
       
 
       
	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       
2122
       
2120
       
 
       
}

     

       
2123
       
2121
       
 
       


     
···

       
2387
       
2385
       
 
       
	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))

     

       
2388
       
2386
       
 
       
}

     

       
2389
       
2387
       
 
       


     

       
2390
       
2390
       
-
       
func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       
2388
       
2388
       
+
       
func newStack(repo *models.Repo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       
2391
       
2389
       
 
       
	formatPatches, err := patchutil.ExtractPatches(patch)

     

       
2392
       
2390
       
 
       
	if err != nil {

     

       
2393
       
2391
       
 
       
		return nil, fmt.Errorf("Failed to extract patches: %v", err)

     
···

       
2422
       
2420
       
 
       
			Body:         body,

     

       
2423
       
2421
       
 
       
			TargetBranch: targetBranch,

     

       
2424
       
2422
       
 
       
			OwnerDid:     user.Did,

     

       
2425
       
2425
       
-
       
			RepoAt:       f.RepoAt(),

     

       
2423
       
2423
       
+
       
			RepoAt:       repo.RepoAt(),

     

       
2426
       
2424
       
 
       
			Rkey:         rkey,

     

       
2427
       
2425
       
 
       
			Submissions: []*models.PullSubmission{

     

       
2428
       
2426
       
 
       
				&initialSubmission,

     

···

       
14
       
14
       
 
       
	"tangled.org/core/appview/db"

     

       
15
       
15
       
 
       
	"tangled.org/core/appview/models"

     

       
16
       
16
       
 
       
	"tangled.org/core/appview/pages"

     

       
17
       
17
       
-
       
	"tangled.org/core/appview/reporesolver"

     

       
18
       
17
       
 
       
	"tangled.org/core/appview/xrpcclient"

     

       
19
       
18
       
 
       
	"tangled.org/core/tid"

     

       
20
       
19
       
 
       
	"tangled.org/core/types"

     
···

       
39
       
38
       
 
       
		return

     

       
40
       
39
       
 
       
	}

     

       
41
       
40
       
 
       


     

       
42
       
42
       
-
       
	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       
41
       
41
       
+
       
	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)

     

       
43
       
42
       
 
       
	if err != nil {

     

       
44
       
43
       
 
       
		log.Println("failed to resolve tag", err)

     

       
45
       
44
       
 
       
		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

     
···

       
147
       
146
       
 
       
	tagParam := chi.URLParam(r, "tag")

     

       
148
       
147
       
 
       
	filename := chi.URLParam(r, "file")

     

       
149
       
148
       
 
       


     

       
150
       
150
       
-
       
	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       
149
       
149
       
+
       
	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)

     

       
151
       
150
       
 
       
	if err != nil {

     

       
152
       
151
       
 
       
		log.Println("failed to resolve tag", err)

     

       
153
       
152
       
 
       
		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

     
···

       
290
       
289
       
 
       
	w.Write([]byte{})

     

       
291
       
290
       
 
       
}

     

       
292
       
291
       
 
       


     

       
293
       
293
       
-
       
func (rp *Repo) resolveTag(ctx context.Context, f *reporesolver.ResolvedRepo, tagParam string) (*types.TagReference, error) {

     

       
292
       
292
       
+
       
func (rp *Repo) resolveTag(ctx context.Context, f *models.Repo, tagParam string) (*types.TagReference, error) {

     

       
294
       
293
       
 
       
	tagParam, err := url.QueryUnescape(tagParam)

     

       
295
       
294
       
 
       
	if err != nil {

     

       
296
       
295
       
 
       
		return nil, err

     

···

       
74
       
74
       
 
       
	}

     

       
75
       
75
       
 
       


     

       
76
       
76
       
 
       
	// Create the blob view

     

       
77
       
77
       
-
       
	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())

     

       
77
       
77
       
+
       
	blobView := NewBlobView(resp, rp.config, &f.Repo, ref, filePath, r.URL.Query())

     

       
78
       
78
       
 
       


     

       
79
       
79
       
 
       
	user := rp.oauth.GetUser(r)

     

       
80
       
80
       
 
       


     
···

       
178
       
178
       
 
       
}

     

       
179
       
179
       
 
       


     

       
180
       
180
       
 
       
// NewBlobView creates a BlobView from the XRPC response

     

       
181
       
181
       
-
       
func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, f *reporesolver.ResolvedRepo, ref, filePath string, queryParams url.Values) models.BlobView {

     

       
181
       
181
       
+
       
func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, repo *models.Repo, ref, filePath string, queryParams url.Values) models.BlobView {

     

       
182
       
182
       
 
       
	view := models.BlobView{

     

       
183
       
183
       
 
       
		Contents: "",

     

       
184
       
184
       
 
       
		Lines:    0,

     
···

       
200
       
200
       
 
       


     

       
201
       
201
       
 
       
	// Determine if binary

     

       
202
       
202
       
 
       
	if resp.IsBinary != nil && *resp.IsBinary {

     

       
203
       
203
       
-
       
		view.ContentSrc = generateBlobURL(config, f, ref, filePath)

     

       
203
       
203
       
+
       
		view.ContentSrc = generateBlobURL(config, repo, ref, filePath)

     

       
204
       
204
       
 
       
		ext := strings.ToLower(filepath.Ext(resp.Path))

     

       
205
       
205
       
 
       


     

       
206
       
206
       
 
       
		switch ext {

     
···

       
252
       
252
       
 
       
	return view

     

       
253
       
253
       
 
       
}

     

       
254
       
254
       
 
       


     

       
255
       
255
       
-
       
func generateBlobURL(config *config.Config, f *reporesolver.ResolvedRepo, ref, filePath string) string {

     

       
255
       
255
       
+
       
func generateBlobURL(config *config.Config, repo *models.Repo, ref, filePath string) string {

     

       
256
       
256
       
 
       
	scheme := "http"

     

       
257
       
257
       
 
       
	if !config.Core.Dev {

     

       
258
       
258
       
 
       
		scheme = "https"

     

       
259
       
259
       
 
       
	}

     

       
260
       
260
       
 
       


     

       
261
       
261
       
-
       
	repoName := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       
261
       
261
       
+
       
	repoName := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       
262
       
262
       
 
       
	baseURL := &url.URL{

     

       
263
       
263
       
 
       
		Scheme: scheme,

     

       
264
       
264
       
-
       
		Host:   f.Knot,

     

       
264
       
264
       
+
       
		Host:   repo.Knot,

     

       
265
       
265
       
 
       
		Path:   "/xrpc/sh.tangled.repo.blob",

     

       
266
       
266
       
 
       
	}

     

       
267
       
267
       
 
       
	query := baseURL.Query()

     

···

       
54
       
54
       
 
       
	user := rp.oauth.GetUser(r)

     

       
55
       
55
       
 
       


     

       
56
       
56
       
 
       
	// Build index response from multiple XRPC calls

     

       
57
       
57
       
-
       
	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     

       
57
       
57
       
+
       
	result, err := rp.buildIndexResponse(r.Context(), xrpcc, &f.Repo, ref)

     

       
58
       
58
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
59
       
59
       
 
       
		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {

     

       
60
       
60
       
 
       
			l.Error("failed to call XRPC repo.index", "err", err)

     
···

       
129
       
129
       
 
       
	}

     

       
130
       
130
       
 
       


     

       
131
       
131
       
 
       
	// TODO: a bit dirty

     

       
132
       
132
       
-
       
	languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")

     

       
132
       
132
       
+
       
	languageInfo, err := rp.getLanguageInfo(r.Context(), l, &f.Repo, xrpcc, result.Ref, ref == "")

     

       
133
       
133
       
 
       
	if err != nil {

     

       
134
       
134
       
 
       
		l.Warn("failed to compute language percentages", "err", err)

     

       
135
       
135
       
 
       
		// non-fatal

     
···

       
164
       
164
       
 
       
func (rp *Repo) getLanguageInfo(

     

       
165
       
165
       
 
       
	ctx context.Context,

     

       
166
       
166
       
 
       
	l *slog.Logger,

     

       
167
       
167
       
-
       
	f *reporesolver.ResolvedRepo,

     

       
167
       
167
       
+
       
	repo *models.Repo,

     

       
168
       
168
       
 
       
	xrpcc *indigoxrpc.Client,

     

       
169
       
169
       
 
       
	currentRef string,

     

       
170
       
170
       
 
       
	isDefaultRef bool,

     
···

       
172
       
172
       
 
       
	// first attempt to fetch from db

     

       
173
       
173
       
 
       
	langs, err := db.GetRepoLanguages(

     

       
174
       
174
       
 
       
		rp.db,

     

       
175
       
175
       
-
       
		db.FilterEq("repo_at", f.RepoAt()),

     

       
175
       
175
       
+
       
		db.FilterEq("repo_at", repo.RepoAt()),

     

       
176
       
176
       
 
       
		db.FilterEq("ref", currentRef),

     

       
177
       
177
       
 
       
	)

     

       
178
       
178
       
 
       


     

       
179
       
179
       
 
       
	if err != nil || langs == nil {

     

       
180
       
180
       
 
       
		// non-fatal, fetch langs from ks via XRPC

     

       
181
       
181
       
-
       
		repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       
182
       
182
       
-
       
		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo)

     

       
181
       
181
       
+
       
		didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       
182
       
182
       
+
       
		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo)

     

       
183
       
183
       
 
       
		if err != nil {

     

       
184
       
184
       
 
       
			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
185
       
185
       
 
       
				l.Error("failed to call XRPC repo.languages", "err", xrpcerr)

     
···

       
194
       
194
       
 
       


     

       
195
       
195
       
 
       
		for _, lang := range ls.Languages {

     

       
196
       
196
       
 
       
			langs = append(langs, models.RepoLanguage{

     

       
197
       
197
       
-
       
				RepoAt:       f.RepoAt(),

     

       
197
       
197
       
+
       
				RepoAt:       repo.RepoAt(),

     

       
198
       
198
       
 
       
				Ref:          currentRef,

     

       
199
       
199
       
 
       
				IsDefaultRef: isDefaultRef,

     

       
200
       
200
       
 
       
				Language:     lang.Name,

     
···

       
209
       
209
       
 
       
		defer tx.Rollback()

     

       
210
       
210
       
 
       


     

       
211
       
211
       
 
       
		// update appview's cache

     

       
212
       
212
       
-
       
		err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs)

     

       
212
       
212
       
+
       
		err = db.UpdateRepoLanguages(tx, repo.RepoAt(), currentRef, langs)

     

       
213
       
213
       
 
       
		if err != nil {

     

       
214
       
214
       
 
       
			// non-fatal

     

       
215
       
215
       
 
       
			l.Error("failed to cache lang results", "err", err)

     
···

       
254
       
254
       
 
       
}

     

       
255
       
255
       
 
       


     

       
256
       
256
       
 
       
// buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel

     

       
257
       
257
       
-
       
func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, f *reporesolver.ResolvedRepo, ref string) (*types.RepoIndexResponse, error) {

     

       
258
       
258
       
-
       
	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)

     

       
257
       
257
       
+
       
func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {

     

       
258
       
258
       
+
       
	didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)

     

       
259
       
259
       
 
       


     

       
260
       
260
       
 
       
	// first get branches to determine the ref if not specified

     

       
261
       
261
       
-
       
	branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo)

     

       
261
       
261
       
+
       
	branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)

     

       
262
       
262
       
 
       
	if err != nil {

     

       
263
       
263
       
 
       
		return nil, fmt.Errorf("failed to call repoBranches: %w", err)

     

       
264
       
264
       
 
       
	}

     
···

       
302
       
302
       
 
       
	wg.Add(1)

     

       
303
       
303
       
 
       
	go func() {

     

       
304
       
304
       
 
       
		defer wg.Done()

     

       
305
       
305
       
-
       
		tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)

     

       
305
       
305
       
+
       
		tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)

     

       
306
       
306
       
 
       
		if err != nil {

     

       
307
       
307
       
 
       
			errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))

     

       
308
       
308
       
 
       
			return

     
···

       
317
       
317
       
 
       
	wg.Add(1)

     

       
318
       
318
       
 
       
	go func() {

     

       
319
       
319
       
 
       
		defer wg.Done()

     

       
320
       
320
       
-
       
		resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repo)

     

       
320
       
320
       
+
       
		resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)

     

       
321
       
321
       
 
       
		if err != nil {

     

       
322
       
322
       
 
       
			errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))

     

       
323
       
323
       
 
       
			return

     
···

       
329
       
329
       
 
       
	wg.Add(1)

     

       
330
       
330
       
 
       
	go func() {

     

       
331
       
331
       
 
       
		defer wg.Done()

     

       
332
       
332
       
-
       
		logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repo)

     

       
332
       
332
       
+
       
		logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)

     

       
333
       
333
       
 
       
		if err != nil {

     

       
334
       
334
       
 
       
			errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))

     

       
335
       
335
       
 
       
			return