···

       
119
       
119
       
 
       


     

       
120
       
120
       
 
       
	rp.pages.RepoSingleIssue(w, pages.RepoSingleIssueParams{

     

       
121
       
121
       
 
       
		LoggedInUser:         user,

     

       
122
       
122
       
-
       
		RepoInfo:             f.RepoInfo(user),

     

       
122
       
122
       
+
       
		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),

     

       
123
       
123
       
 
       
		Issue:                issue,

     

       
124
       
124
       
 
       
		CommentList:          issue.CommentList(),

     

       
125
       
125
       
 
       
		OrderedReactionKinds: models.OrderedReactionKinds,

     
···

       
132
       
132
       
 
       
func (rp *Issues) EditIssue(w http.ResponseWriter, r *http.Request) {

     

       
133
       
133
       
 
       
	l := rp.logger.With("handler", "EditIssue")

     

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

     

       
135
       
135
       
-
       
	f, err := rp.repoResolver.Resolve(r)

     

       
136
       
136
       
-
       
	if err != nil {

     

       
137
       
137
       
-
       
		l.Error("failed to get repo and knot", "err", err)

     

       
138
       
138
       
-
       
		return

     

       
139
       
139
       
-
       
	}

     

       
140
       
135
       
 
       


     

       
141
       
136
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
142
       
137
       
 
       
	if !ok {

     
···

       
149
       
144
       
 
       
	case http.MethodGet:

     

       
150
       
145
       
 
       
		rp.pages.EditIssueFragment(w, pages.EditIssueParams{

     

       
151
       
146
       
 
       
			LoggedInUser: user,

     

       
152
       
152
       
-
       
			RepoInfo:     f.RepoInfo(user),

     

       
147
       
147
       
+
       
			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
153
       
148
       
 
       
			Issue:        issue,

     

       
154
       
149
       
 
       
		})

     

       
155
       
150
       
 
       
	case http.MethodPost:

     
···

       
470
       
465
       
 
       
func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) {

     

       
471
       
466
       
 
       
	l := rp.logger.With("handler", "IssueComment")

     

       
472
       
467
       
 
       
	user := rp.oauth.GetUser(r)

     

       
473
       
473
       
-
       
	f, err := rp.repoResolver.Resolve(r)

     

       
474
       
474
       
-
       
	if err != nil {

     

       
475
       
475
       
-
       
		l.Error("failed to get repo and knot", "err", err)

     

       
476
       
476
       
-
       
		return

     

       
477
       
477
       
-
       
	}

     

       
478
       
468
       
 
       


     

       
479
       
469
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
480
       
470
       
 
       
	if !ok {

     
···

       
502
       
492
       
 
       


     

       
503
       
493
       
 
       
	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       
504
       
494
       
 
       
		LoggedInUser: user,

     

       
505
       
505
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
495
       
495
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
506
       
496
       
 
       
		Issue:        issue,

     

       
507
       
497
       
 
       
		Comment:      &comment,

     

       
508
       
498
       
 
       
	})

     
···

       
511
       
501
       
 
       
func (rp *Issues) EditIssueComment(w http.ResponseWriter, r *http.Request) {

     

       
512
       
502
       
 
       
	l := rp.logger.With("handler", "EditIssueComment")

     

       
513
       
503
       
 
       
	user := rp.oauth.GetUser(r)

     

       
514
       
514
       
-
       
	f, err := rp.repoResolver.Resolve(r)

     

       
515
       
515
       
-
       
	if err != nil {

     

       
516
       
516
       
-
       
		l.Error("failed to get repo and knot", "err", err)

     

       
517
       
517
       
-
       
		return

     

       
518
       
518
       
-
       
	}

     

       
519
       
504
       
 
       


     

       
520
       
505
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
521
       
506
       
 
       
	if !ok {

     
···

       
551
       
536
       
 
       
	case http.MethodGet:

     

       
552
       
537
       
 
       
		rp.pages.EditIssueCommentFragment(w, pages.EditIssueCommentParams{

     

       
553
       
538
       
 
       
			LoggedInUser: user,

     

       
554
       
554
       
-
       
			RepoInfo:     f.RepoInfo(user),

     

       
539
       
539
       
+
       
			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
555
       
540
       
 
       
			Issue:        issue,

     

       
556
       
541
       
 
       
			Comment:      &comment,

     

       
557
       
542
       
 
       
		})

     
···

       
605
       
590
       
 
       
		// return new comment body with htmx

     

       
606
       
591
       
 
       
		rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       
607
       
592
       
 
       
			LoggedInUser: user,

     

       
608
       
608
       
-
       
			RepoInfo:     f.RepoInfo(user),

     

       
593
       
593
       
+
       
			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
609
       
594
       
 
       
			Issue:        issue,

     

       
610
       
595
       
 
       
			Comment:      &newComment,

     

       
611
       
596
       
 
       
		})

     
···

       
615
       
600
       
 
       
func (rp *Issues) ReplyIssueCommentPlaceholder(w http.ResponseWriter, r *http.Request) {

     

       
616
       
601
       
 
       
	l := rp.logger.With("handler", "ReplyIssueCommentPlaceholder")

     

       
617
       
602
       
 
       
	user := rp.oauth.GetUser(r)

     

       
618
       
618
       
-
       
	f, err := rp.repoResolver.Resolve(r)

     

       
619
       
619
       
-
       
	if err != nil {

     

       
620
       
620
       
-
       
		l.Error("failed to get repo and knot", "err", err)

     

       
621
       
621
       
-
       
		return

     

       
622
       
622
       
-
       
	}

     

       
623
       
603
       
 
       


     

       
624
       
604
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
625
       
605
       
 
       
	if !ok {

     
···

       
647
       
627
       
 
       


     

       
648
       
628
       
 
       
	rp.pages.ReplyIssueCommentPlaceholderFragment(w, pages.ReplyIssueCommentPlaceholderParams{

     

       
649
       
629
       
 
       
		LoggedInUser: user,

     

       
650
       
650
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
630
       
630
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
651
       
631
       
 
       
		Issue:        issue,

     

       
652
       
632
       
 
       
		Comment:      &comment,

     

       
653
       
633
       
 
       
	})

     
···

       
656
       
636
       
 
       
func (rp *Issues) ReplyIssueComment(w http.ResponseWriter, r *http.Request) {

     

       
657
       
637
       
 
       
	l := rp.logger.With("handler", "ReplyIssueComment")

     

       
658
       
638
       
 
       
	user := rp.oauth.GetUser(r)

     

       
659
       
659
       
-
       
	f, err := rp.repoResolver.Resolve(r)

     

       
660
       
660
       
-
       
	if err != nil {

     

       
661
       
661
       
-
       
		l.Error("failed to get repo and knot", "err", err)

     

       
662
       
662
       
-
       
		return

     

       
663
       
663
       
-
       
	}

     

       
664
       
639
       
 
       


     

       
665
       
640
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
666
       
641
       
 
       
	if !ok {

     
···

       
688
       
663
       
 
       


     

       
689
       
664
       
 
       
	rp.pages.ReplyIssueCommentFragment(w, pages.ReplyIssueCommentParams{

     

       
690
       
665
       
 
       
		LoggedInUser: user,

     

       
691
       
691
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
666
       
666
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
692
       
667
       
 
       
		Issue:        issue,

     

       
693
       
668
       
 
       
		Comment:      &comment,

     

       
694
       
669
       
 
       
	})

     
···

       
697
       
672
       
 
       
func (rp *Issues) DeleteIssueComment(w http.ResponseWriter, r *http.Request) {

     

       
698
       
673
       
 
       
	l := rp.logger.With("handler", "DeleteIssueComment")

     

       
699
       
674
       
 
       
	user := rp.oauth.GetUser(r)

     

       
700
       
700
       
-
       
	f, err := rp.repoResolver.Resolve(r)

     

       
701
       
701
       
-
       
	if err != nil {

     

       
702
       
702
       
-
       
		l.Error("failed to get repo and knot", "err", err)

     

       
703
       
703
       
-
       
		return

     

       
704
       
704
       
-
       
	}

     

       
705
       
675
       
 
       


     

       
706
       
676
       
 
       
	issue, ok := r.Context().Value("issue").(*models.Issue)

     

       
707
       
677
       
 
       
	if !ok {

     
···

       
772
       
742
       
 
       
	// htmx fragment of comment after deletion

     

       
773
       
743
       
 
       
	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{

     

       
774
       
744
       
 
       
		LoggedInUser: user,

     

       
775
       
775
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
745
       
745
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
776
       
746
       
 
       
		Issue:        issue,

     

       
777
       
747
       
 
       
		Comment:      &comment,

     

       
778
       
748
       
 
       
	})

     
···

       
873
       
843
       
 
       


     

       
874
       
844
       
 
       
	rp.pages.RepoIssues(w, pages.RepoIssuesParams{

     

       
875
       
845
       
 
       
		LoggedInUser:    rp.oauth.GetUser(r),

     

       
876
       
876
       
-
       
		RepoInfo:        f.RepoInfo(user),

     

       
846
       
846
       
+
       
		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       
877
       
847
       
 
       
		Issues:          issues,

     

       
878
       
848
       
 
       
		IssueCount:      totalIssues,

     

       
879
       
849
       
 
       
		LabelDefs:       defs,

     
···

       
897
       
867
       
 
       
	case http.MethodGet:

     

       
898
       
868
       
 
       
		rp.pages.RepoNewIssue(w, pages.RepoNewIssueParams{

     

       
899
       
869
       
 
       
			LoggedInUser: user,

     

       
900
       
900
       
-
       
			RepoInfo:     f.RepoInfo(user),

     

       
870
       
870
       
+
       
			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
901
       
871
       
 
       
		})

     

       
902
       
872
       
 
       
	case http.MethodPost:

     

       
903
       
873
       
 
       
		issue := &models.Issue{

     

···

       
92
       
92
       
 
       


     

       
93
       
93
       
 
       
	p.pages.Pipelines(w, pages.PipelinesParams{

     

       
94
       
94
       
 
       
		LoggedInUser: user,

     

       
95
       
95
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
95
       
95
       
+
       
		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),

     

       
96
       
96
       
 
       
		Pipelines:    ps,

     

       
97
       
97
       
 
       
	})

     

       
98
       
98
       
 
       
}

     
···

       
141
       
141
       
 
       


     

       
142
       
142
       
 
       
	p.pages.Workflow(w, pages.WorkflowParams{

     

       
143
       
143
       
 
       
		LoggedInUser: user,

     

       
144
       
144
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
144
       
144
       
+
       
		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),

     

       
145
       
145
       
 
       
		Pipeline:     singlePipeline,

     

       
146
       
146
       
 
       
		Workflow:     workflow,

     

       
147
       
147
       
 
       
	})

     

···

       
124
       
124
       
 
       


     

       
125
       
125
       
 
       
		s.pages.PullActionsFragment(w, pages.PullActionsParams{

     

       
126
       
126
       
 
       
			LoggedInUser:       user,

     

       
127
       
127
       
-
       
			RepoInfo:           f.RepoInfo(user),

     

       
127
       
127
       
+
       
			RepoInfo:           s.repoResolver.GetRepoInfo(r, user),

     

       
128
       
128
       
 
       
			Pull:               pull,

     

       
129
       
129
       
 
       
			RoundNumber:        roundNumber,

     

       
130
       
130
       
 
       
			MergeCheck:         mergeCheckResponse,

     
···

       
221
       
221
       
 
       


     

       
222
       
222
       
 
       
	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       
223
       
223
       
 
       
		LoggedInUser:       user,

     

       
224
       
224
       
-
       
		RepoInfo:           f.RepoInfo(user),

     

       
224
       
224
       
+
       
		RepoInfo:           s.repoResolver.GetRepoInfo(r, user),

     

       
225
       
225
       
 
       
		Pull:               pull,

     

       
226
       
226
       
 
       
		Stack:              stack,

     

       
227
       
227
       
 
       
		AbandonedPulls:     abandonedPulls,

     
···

       
421
       
421
       
 
       


     

       
422
       
422
       
 
       
func (s *Pulls) RepoPullPatch(w http.ResponseWriter, r *http.Request) {

     

       
423
       
423
       
 
       
	user := s.oauth.GetUser(r)

     

       
424
       
424
       
-
       
	f, err := s.repoResolver.Resolve(r)

     

       
425
       
425
       
-
       
	if err != nil {

     

       
426
       
426
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
427
       
427
       
-
       
		return

     

       
428
       
428
       
-
       
	}

     

       
429
       
424
       
 
       


     

       
430
       
425
       
 
       
	var diffOpts types.DiffOpts

     

       
431
       
426
       
 
       
	if d := r.URL.Query().Get("diff"); d == "split" {

     
···

       
454
       
449
       
 
       


     

       
455
       
450
       
 
       
	s.pages.RepoPullPatchPage(w, pages.RepoPullPatchParams{

     

       
456
       
451
       
 
       
		LoggedInUser: user,

     

       
457
       
457
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
452
       
452
       
+
       
		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       
458
       
453
       
 
       
		Pull:         pull,

     

       
459
       
454
       
 
       
		Stack:        stack,

     

       
460
       
455
       
 
       
		Round:        roundIdInt,

     
···

       
468
       
463
       
 
       
func (s *Pulls) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {

     

       
469
       
464
       
 
       
	user := s.oauth.GetUser(r)

     

       
470
       
465
       
 
       


     

       
471
       
471
       
-
       
	f, err := s.repoResolver.Resolve(r)

     

       
472
       
472
       
-
       
	if err != nil {

     

       
473
       
473
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
474
       
474
       
-
       
		return

     

       
475
       
475
       
-
       
	}

     

       
476
       
476
       
-
       


     

       
477
       
466
       
 
       
	var diffOpts types.DiffOpts

     

       
478
       
467
       
 
       
	if d := r.URL.Query().Get("diff"); d == "split" {

     

       
479
       
468
       
 
       
		diffOpts.Split = true

     
···

       
518
       
507
       
 
       


     

       
519
       
508
       
 
       
	s.pages.RepoPullInterdiffPage(w, pages.RepoPullInterdiffParams{

     

       
520
       
509
       
 
       
		LoggedInUser: s.oauth.GetUser(r),

     

       
521
       
521
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
510
       
510
       
+
       
		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       
522
       
511
       
 
       
		Pull:         pull,

     

       
523
       
512
       
 
       
		Round:        roundIdInt,

     

       
524
       
513
       
 
       
		Interdiff:    interdiff,

     
···

       
678
       
667
       
 
       


     

       
679
       
668
       
 
       
	s.pages.RepoPulls(w, pages.RepoPullsParams{

     

       
680
       
669
       
 
       
		LoggedInUser: s.oauth.GetUser(r),

     

       
681
       
681
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
670
       
670
       
+
       
		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       
682
       
671
       
 
       
		Pulls:        pulls,

     

       
683
       
672
       
 
       
		LabelDefs:    defs,

     

       
684
       
673
       
 
       
		FilteringBy:  state,

     
···

       
716
       
705
       
 
       
	case http.MethodGet:

     

       
717
       
706
       
 
       
		s.pages.PullNewCommentFragment(w, pages.PullNewCommentParams{

     

       
718
       
707
       
 
       
			LoggedInUser: user,

     

       
719
       
719
       
-
       
			RepoInfo:     f.RepoInfo(user),

     

       
708
       
708
       
+
       
			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       
720
       
709
       
 
       
			Pull:         pull,

     

       
721
       
710
       
 
       
			RoundNumber:  roundNumber,

     

       
722
       
711
       
 
       
		})

     
···

       
850
       
839
       
 
       


     

       
851
       
840
       
 
       
		s.pages.RepoNewPull(w, pages.RepoNewPullParams{

     

       
852
       
841
       
 
       
			LoggedInUser: user,

     

       
853
       
853
       
-
       
			RepoInfo:     f.RepoInfo(user),

     

       
842
       
842
       
+
       
			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),

     

       
854
       
843
       
 
       
			Branches:     result.Branches,

     

       
855
       
844
       
 
       
			Strategy:     strategy,

     

       
856
       
845
       
 
       
			SourceBranch: sourceBranch,

     
···

       
1405
       
1394
       
 
       


     

       
1406
       
1395
       
 
       
func (s *Pulls) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {

     

       
1407
       
1396
       
 
       
	user := s.oauth.GetUser(r)

     

       
1408
       
1408
       
-
       
	f, err := s.repoResolver.Resolve(r)

     

       
1409
       
1409
       
-
       
	if err != nil {

     

       
1410
       
1410
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
1411
       
1411
       
-
       
		return

     

       
1412
       
1412
       
-
       
	}

     

       
1413
       
1397
       
 
       


     

       
1414
       
1398
       
 
       
	s.pages.PullPatchUploadFragment(w, pages.PullPatchUploadParams{

     

       
1415
       
1415
       
-
       
		RepoInfo: f.RepoInfo(user),

     

       
1399
       
1399
       
+
       
		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       
1416
       
1400
       
 
       
	})

     

       
1417
       
1401
       
 
       
}

     

       
1418
       
1402
       
 
       


     
···

       
1466
       
1450
       
 
       
	}

     

       
1467
       
1451
       
 
       


     

       
1468
       
1452
       
 
       
	s.pages.PullCompareBranchesFragment(w, pages.PullCompareBranchesParams{

     

       
1469
       
1469
       
-
       
		RepoInfo: f.RepoInfo(user),

     

       
1453
       
1453
       
+
       
		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       
1470
       
1454
       
 
       
		Branches: withoutDefault,

     

       
1471
       
1455
       
 
       
	})

     

       
1472
       
1456
       
 
       
}

     

       
1473
       
1457
       
 
       


     

       
1474
       
1458
       
 
       
func (s *Pulls) CompareForksFragment(w http.ResponseWriter, r *http.Request) {

     

       
1475
       
1459
       
 
       
	user := s.oauth.GetUser(r)

     

       
1476
       
1476
       
-
       
	f, err := s.repoResolver.Resolve(r)

     

       
1477
       
1477
       
-
       
	if err != nil {

     

       
1478
       
1478
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
1479
       
1479
       
-
       
		return

     

       
1480
       
1480
       
-
       
	}

     

       
1481
       
1460
       
 
       


     

       
1482
       
1461
       
 
       
	forks, err := db.GetForksByDid(s.db, user.Did)

     

       
1483
       
1462
       
 
       
	if err != nil {

     
···

       
1486
       
1465
       
 
       
	}

     

       
1487
       
1466
       
 
       


     

       
1488
       
1467
       
 
       
	s.pages.PullCompareForkFragment(w, pages.PullCompareForkParams{

     

       
1489
       
1489
       
-
       
		RepoInfo: f.RepoInfo(user),

     

       
1468
       
1468
       
+
       
		RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       
1490
       
1469
       
 
       
		Forks:    forks,

     

       
1491
       
1470
       
 
       
		Selected: r.URL.Query().Get("fork"),

     

       
1492
       
1471
       
 
       
	})

     
···

       
1579
       
1558
       
 
       
	})

     

       
1580
       
1559
       
 
       


     

       
1581
       
1560
       
 
       
	s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{

     

       
1582
       
1582
       
-
       
		RepoInfo:       f.RepoInfo(user),

     

       
1561
       
1561
       
+
       
		RepoInfo:       s.repoResolver.GetRepoInfo(r, user),

     

       
1583
       
1562
       
 
       
		SourceBranches: sourceBranches.Branches,

     

       
1584
       
1563
       
 
       
		TargetBranches: targetBranches.Branches,

     

       
1585
       
1564
       
 
       
	})

     
···

       
1587
       
1566
       
 
       


     

       
1588
       
1567
       
 
       
func (s *Pulls) ResubmitPull(w http.ResponseWriter, r *http.Request) {

     

       
1589
       
1568
       
 
       
	user := s.oauth.GetUser(r)

     

       
1590
       
1590
       
-
       
	f, err := s.repoResolver.Resolve(r)

     

       
1591
       
1591
       
-
       
	if err != nil {

     

       
1592
       
1592
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
1593
       
1593
       
-
       
		return

     

       
1594
       
1594
       
-
       
	}

     

       
1595
       
1569
       
 
       


     

       
1596
       
1570
       
 
       
	pull, ok := r.Context().Value("pull").(*models.Pull)

     

       
1597
       
1571
       
 
       
	if !ok {

     
···

       
1603
       
1577
       
 
       
	switch r.Method {

     

       
1604
       
1578
       
 
       
	case http.MethodGet:

     

       
1605
       
1579
       
 
       
		s.pages.PullResubmitFragment(w, pages.PullResubmitParams{

     

       
1606
       
1606
       
-
       
			RepoInfo: f.RepoInfo(user),

     

       
1580
       
1580
       
+
       
			RepoInfo: s.repoResolver.GetRepoInfo(r, user),

     

       
1607
       
1581
       
 
       
			Pull:     pull,

     

       
1608
       
1582
       
 
       
		})

     

       
1609
       
1583
       
 
       
		return

     

···

       
130
       
130
       
 
       


     

       
131
       
131
       
 
       
	rp.pages.RepoArtifactFragment(w, pages.RepoArtifactParams{

     

       
132
       
132
       
 
       
		LoggedInUser: user,

     

       
133
       
133
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
133
       
133
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
134
       
134
       
 
       
		Artifact:     artifact,

     

       
135
       
135
       
 
       
	})

     

       
136
       
136
       
 
       
}

     

···

       
80
       
80
       
 
       


     

       
81
       
81
       
 
       
	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       
82
       
82
       
 
       
		LoggedInUser:    user,

     

       
83
       
83
       
-
       
		RepoInfo:        f.RepoInfo(user),

     

       
83
       
83
       
+
       
		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       
84
       
84
       
 
       
		BreadCrumbs:     breadcrumbs,

     

       
85
       
85
       
 
       
		BlobView:        blobView,

     

       
86
       
86
       
 
       
		RepoBlob_Output: resp,

     

···

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

     

       
47
       
47
       
 
       
	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       
48
       
48
       
 
       
		LoggedInUser:         user,

     

       
49
       
49
       
-
       
		RepoInfo:             f.RepoInfo(user),

     

       
49
       
49
       
+
       
		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),

     

       
50
       
50
       
 
       
		RepoBranchesResponse: result,

     

       
51
       
51
       
 
       
	})

     

       
52
       
52
       
 
       
}

     

···

       
90
       
90
       
 
       


     

       
91
       
91
       
 
       
	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{

     

       
92
       
92
       
 
       
		LoggedInUser: user,

     

       
93
       
93
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
93
       
93
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
94
       
94
       
 
       
		Branches:     branches,

     

       
95
       
95
       
 
       
		Tags:         tags.Tags,

     

       
96
       
96
       
 
       
		Base:         base,

     
···

       
202
       
202
       
 
       


     

       
203
       
203
       
 
       
	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       
204
       
204
       
 
       
		LoggedInUser: user,

     

       
205
       
205
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
205
       
205
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
206
       
206
       
 
       
		Branches:     branches.Branches,

     

       
207
       
207
       
 
       
		Tags:         tags.Tags,

     

       
208
       
208
       
 
       
		Base:         base,

     

···

       
60
       
60
       
 
       
			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       
61
       
61
       
 
       
				LoggedInUser:     user,

     

       
62
       
62
       
 
       
				NeedsKnotUpgrade: true,

     

       
63
       
63
       
-
       
				RepoInfo:         f.RepoInfo(user),

     

       
63
       
63
       
+
       
				RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),

     

       
64
       
64
       
 
       
			})

     

       
65
       
65
       
 
       
			return

     

       
66
       
66
       
 
       
		}

     
···

       
146
       
146
       
 
       


     

       
147
       
147
       
 
       
	rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       
148
       
148
       
 
       
		LoggedInUser:      user,

     

       
149
       
149
       
-
       
		RepoInfo:          f.RepoInfo(user),

     

       
149
       
149
       
+
       
		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),

     

       
150
       
150
       
 
       
		TagMap:            tagMap,

     

       
151
       
151
       
 
       
		RepoIndexResponse: *result,

     

       
152
       
152
       
 
       
		CommitsTrunc:      commitsTrunc,

     

···

       
134
       
134
       
 
       
	rp.pages.RepoLog(w, pages.RepoLogParams{

     

       
135
       
135
       
 
       
		LoggedInUser:    user,

     

       
136
       
136
       
 
       
		TagMap:          tagMap,

     

       
137
       
137
       
-
       
		RepoInfo:        f.RepoInfo(user),

     

       
137
       
137
       
+
       
		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),

     

       
138
       
138
       
 
       
		RepoLogResponse: xrpcResp,

     

       
139
       
139
       
 
       
		EmailToDid:      emailToDidMap,

     

       
140
       
140
       
 
       
		VerifiedCommits: vc,

     
···

       
210
       
210
       
 
       


     

       
211
       
211
       
 
       
	rp.pages.RepoCommit(w, pages.RepoCommitParams{

     

       
212
       
212
       
 
       
		LoggedInUser:       user,

     

       
213
       
213
       
-
       
		RepoInfo:           f.RepoInfo(user),

     

       
213
       
213
       
+
       
		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),

     

       
214
       
214
       
 
       
		RepoCommitResponse: result,

     

       
215
       
215
       
 
       
		EmailToDid:         emailToDidMap,

     

       
216
       
216
       
 
       
		VerifiedCommit:     vc,

     

···

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

     

       
636
       
636
       
 
       
	rp.pages.LabelPanel(w, pages.LabelPanelParams{

     

       
637
       
637
       
 
       
		LoggedInUser: user,

     

       
638
       
638
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
638
       
638
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
639
       
639
       
 
       
		Defs:         defs,

     

       
640
       
640
       
 
       
		Subject:      subject.String(),

     

       
641
       
641
       
 
       
		State:        state,

     
···

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

     

       
684
       
684
       
 
       
	rp.pages.EditLabelPanel(w, pages.EditLabelPanelParams{

     

       
685
       
685
       
 
       
		LoggedInUser: user,

     

       
686
       
686
       
-
       
		RepoInfo:     f.RepoInfo(user),

     

       
686
       
686
       
+
       
		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
687
       
687
       
 
       
		Defs:         defs,

     

       
688
       
688
       
 
       
		Subject:      subject.String(),

     

       
689
       
689
       
 
       
		State:        state,

     
···

       
1006
       
1006
       
 
       
		rp.pages.ForkRepo(w, pages.ForkRepoParams{

     

       
1007
       
1007
       
 
       
			LoggedInUser: user,

     

       
1008
       
1008
       
 
       
			Knots:        knots,

     

       
1009
       
1009
       
-
       
			RepoInfo:     f.RepoInfo(user),

     

       
1009
       
1009
       
+
       
			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),

     

       
1010
       
1010
       
 
       
		})

     

       
1011
       
1011
       
 
       


     

       
1012
       
1012
       
 
       
	case http.MethodPost:

     

···

       
255
       
255
       
 
       


     

       
256
       
256
       
 
       
	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{

     

       
257
       
257
       
 
       
		LoggedInUser:       user,

     

       
258
       
258
       
-
       
		RepoInfo:           f.RepoInfo(user),

     

       
258
       
258
       
+
       
		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),

     

       
259
       
259
       
 
       
		Branches:           result.Branches,

     

       
260
       
260
       
 
       
		Labels:             labels,

     

       
261
       
261
       
 
       
		DefaultLabels:      defaultLabels,

     
···

       
306
       
306
       
 
       


     

       
307
       
307
       
 
       
	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{

     

       
308
       
308
       
 
       
		LoggedInUser:  user,

     

       
309
       
309
       
-
       
		RepoInfo:      f.RepoInfo(user),

     

       
309
       
309
       
+
       
		RepoInfo:      rp.repoResolver.GetRepoInfo(r, user),

     

       
310
       
310
       
 
       
		Tabs:          settingsTabs,

     

       
311
       
311
       
 
       
		Tab:           "access",

     

       
312
       
312
       
 
       
		Collaborators: collaborators,

     
···

       
367
       
367
       
 
       


     

       
368
       
368
       
 
       
	rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{

     

       
369
       
369
       
 
       
		LoggedInUser:   user,

     

       
370
       
370
       
-
       
		RepoInfo:       f.RepoInfo(user),

     

       
370
       
370
       
+
       
		RepoInfo:       rp.repoResolver.GetRepoInfo(r, user),

     

       
371
       
371
       
 
       
		Tabs:           settingsTabs,

     

       
372
       
372
       
 
       
		Tab:            "pipelines",

     

       
373
       
373
       
 
       
		Spindles:       spindles,

     

···

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

     

       
72
       
72
       
 
       
	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       
73
       
73
       
 
       
		LoggedInUser:      user,

     

       
74
       
74
       
-
       
		RepoInfo:          f.RepoInfo(user),

     

       
74
       
74
       
+
       
		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),

     

       
75
       
75
       
 
       
		RepoTagsResponse:  result,

     

       
76
       
76
       
 
       
		ArtifactMap:       artifactMap,

     

       
77
       
77
       
 
       
		DanglingArtifacts: danglingArtifacts,

     

···

       
102
       
102
       
 
       
		LoggedInUser:     user,

     

       
103
       
103
       
 
       
		BreadCrumbs:      breadcrumbs,

     

       
104
       
104
       
 
       
		TreePath:         treePath,

     

       
105
       
105
       
-
       
		RepoInfo:         f.RepoInfo(user),

     

       
105
       
105
       
+
       
		RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),

     

       
106
       
106
       
 
       
		RepoTreeResponse: result,

     

       
107
       
107
       
 
       
	})

     

       
108
       
108
       
 
       
}

     

···

       
20
       
20
       
 
       


     

       
21
       
21
       
 
       
type ResolvedRepo struct {

     

       
22
       
22
       
 
       
	models.Repo

     

       
23
       
23
       
-
       
	OwnerId    identity.Identity

     

       
24
       
24
       
-
       
	CurrentDir string

     

       
25
       
25
       
-
       
	Ref        string

     

       
26
       
26
       
-
       


     

       
27
       
27
       
-
       
	rr *RepoResolver

     

       
28
       
23
       
 
       
}

     

       
29
       
24
       
 
       


     

       
30
       
25
       
 
       
type RepoResolver struct {

     
···

       
49
       
44
       
 
       
	return path.Join(user, name)

     

       
50
       
45
       
 
       
}

     

       
51
       
46
       
 
       


     

       
47
       
47
       
+
       
// TODO: move this out of `RepoResolver` struct

     

       
52
       
48
       
 
       
func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {

     

       
53
       
49
       
 
       
	repo, ok := r.Context().Value("repo").(*models.Repo)

     

       
54
       
50
       
 
       
	if !ok {

     

       
55
       
51
       
 
       
		log.Println("malformed middleware: `repo` not exist in context")

     

       
56
       
52
       
 
       
		return nil, fmt.Errorf("malformed middleware")

     

       
57
       
53
       
 
       
	}

     

       
58
       
58
       
-
       
	id, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       
59
       
59
       
-
       
	if !ok {

     

       
60
       
60
       
-
       
		log.Println("malformed middleware")

     

       
61
       
61
       
-
       
		return nil, fmt.Errorf("malformed middleware")

     

       
54
       
54
       
+
       


     

       
55
       
55
       
+
       
	return &ResolvedRepo{

     

       
56
       
56
       
+
       
		Repo: *repo,

     

       
57
       
57
       
+
       
	}, nil

     

       
58
       
58
       
+
       
}

     

       
59
       
59
       
+
       


     

       
60
       
60
       
+
       
// 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`

     

       
61
       
61
       
+
       
// 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`

     

       
62
       
62
       
+
       
// 3. [ ] remove `ResolvedRepo`

     

       
63
       
63
       
+
       
// 4. [ ] replace reporesolver to reposervice

     

       
64
       
64
       
+
       
func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {

     

       
65
       
65
       
+
       
	ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)

     

       
66
       
66
       
+
       
	repo, rok := r.Context().Value("repo").(*models.Repo)

     

       
67
       
67
       
+
       
	if !ook || !rok {

     

       
68
       
68
       
+
       
		log.Println("malformed request, failed to get repo from context")

     

       
62
       
69
       
 
       
	}

     

       
63
       
70
       
 
       


     

       
71
       
71
       
+
       
	// get dir/ref

     

       
64
       
72
       
 
       
	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath()))

     

       
65
       
73
       
 
       
	ref := chi.URLParam(r, "ref")

     

       
66
       
74
       
 
       


     

       
67
       
67
       
-
       
	return &ResolvedRepo{

     

       
68
       
68
       
-
       
		Repo:       *repo,

     

       
69
       
69
       
-
       
		OwnerId:    id,

     

       
70
       
70
       
-
       
		CurrentDir: currentDir,

     

       
71
       
71
       
-
       
		Ref:        ref,

     

       
72
       
72
       
-
       


     

       
73
       
73
       
-
       
		rr: rr,

     

       
74
       
74
       
-
       
	}, nil

     

       
75
       
75
       
-
       
}

     

       
76
       
76
       
-
       


     

       
77
       
77
       
-
       
// this function is a bit weird since it now returns RepoInfo from an entirely different

     

       
78
       
78
       
-
       
// package. we should refactor this or get rid of RepoInfo entirely.

     

       
79
       
79
       
-
       
func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {

     

       
80
       
80
       
-
       
	repoAt := f.RepoAt()

     

       
75
       
75
       
+
       
	repoAt := repo.RepoAt()

     

       
81
       
76
       
 
       
	isStarred := false

     

       
82
       
77
       
 
       
	roles := repoinfo.RolesInRepo{}

     

       
83
       
78
       
 
       
	if user != nil {

     

       
84
       
84
       
-
       
		isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)

     

       
85
       
85
       
-
       
		roles.Roles = f.rr.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())

     

       
79
       
79
       
+
       
		isStarred = db.GetStarStatus(rr.execer, user.Did, repoAt)

     

       
80
       
80
       
+
       
		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())

     

       
86
       
81
       
 
       
	}

     

       
87
       
82
       
 
       


     

       
88
       
88
       
-
       
	stats := f.RepoStats

     

       
83
       
83
       
+
       
	stats := repo.RepoStats

     

       
89
       
84
       
 
       
	if stats == nil {

     

       
90
       
90
       
-
       
		starCount, err := db.GetStarCount(f.rr.execer, repoAt)

     

       
85
       
85
       
+
       
		starCount, err := db.GetStarCount(rr.execer, repoAt)

     

       
91
       
86
       
 
       
		if err != nil {

     

       
92
       
87
       
 
       
			log.Println("failed to get star count for ", repoAt)

     

       
93
       
88
       
 
       
		}

     

       
94
       
94
       
-
       
		issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)

     

       
89
       
89
       
+
       
		issueCount, err := db.GetIssueCount(rr.execer, repoAt)

     

       
95
       
90
       
 
       
		if err != nil {

     

       
96
       
91
       
 
       
			log.Println("failed to get issue count for ", repoAt)

     

       
97
       
92
       
 
       
		}

     

       
98
       
98
       
-
       
		pullCount, err := db.GetPullCount(f.rr.execer, repoAt)

     

       
93
       
93
       
+
       
		pullCount, err := db.GetPullCount(rr.execer, repoAt)

     

       
99
       
94
       
 
       
		if err != nil {

     

       
100
       
95
       
 
       
			log.Println("failed to get pull count for ", repoAt)

     

       
101
       
96
       
 
       
		}

     
···

       
106
       
101
       
 
       
		}

     

       
107
       
102
       
 
       
	}

     

       
108
       
103
       
 
       


     

       
109
       
109
       
-
       
	sourceRepo, err := db.GetRepoSourceRepo(f.rr.execer, repoAt)

     

       
110
       
110
       
-
       
	if err != nil {

     

       
111
       
111
       
-
       
		log.Println("failed to get repo by at uri", err)

     

       
104
       
104
       
+
       
	var sourceRepo *models.Repo

     

       
105
       
105
       
+
       
	var err error

     

       
106
       
106
       
+
       
	if repo.Source != "" {

     

       
107
       
107
       
+
       
		sourceRepo, err = db.GetRepoByAtUri(rr.execer, repo.Source)

     

       
108
       
108
       
+
       
		if err != nil {

     

       
109
       
109
       
+
       
			log.Println("failed to get repo by at uri", err)

     

       
110
       
110
       
+
       
		}

     

       
112
       
111
       
 
       
	}

     

       
113
       
112
       
 
       


     

       
114
       
113
       
 
       
	repoInfo := repoinfo.RepoInfo{

     

       
115
       
114
       
 
       
		// this is basically a models.Repo

     

       
116
       
116
       
-
       
		OwnerDid:    f.OwnerId.DID.String(),

     

       
117
       
117
       
-
       
		OwnerHandle: f.OwnerId.Handle.String(),

     

       
118
       
118
       
-
       
		Name:        f.Name,

     

       
119
       
119
       
-
       
		Rkey:        f.Rkey,

     

       
120
       
120
       
-
       
		Description: f.Description,

     

       
121
       
121
       
-
       
		Website:     f.Website,

     

       
122
       
122
       
-
       
		Topics:      f.Topics,

     

       
123
       
123
       
-
       
		Knot:        f.Knot,

     

       
124
       
124
       
-
       
		Spindle:     f.Spindle,

     

       
115
       
115
       
+
       
		OwnerDid:    ownerId.DID.String(),

     

       
116
       
116
       
+
       
		OwnerHandle: ownerId.Handle.String(),

     

       
117
       
117
       
+
       
		Name:        repo.Name,

     

       
118
       
118
       
+
       
		Rkey:        repo.Rkey,

     

       
119
       
119
       
+
       
		Description: repo.Description,

     

       
120
       
120
       
+
       
		Website:     repo.Website,

     

       
121
       
121
       
+
       
		Topics:      repo.Topics,

     

       
122
       
122
       
+
       
		Knot:        repo.Knot,

     

       
123
       
123
       
+
       
		Spindle:     repo.Spindle,

     

       
125
       
124
       
 
       
		Stats:       *stats,

     

       
126
       
125
       
 
       


     

       
127
       
126
       
 
       
		// fork repo upstream

     

       
128
       
127
       
 
       
		Source: sourceRepo,

     

       
129
       
128
       
 
       


     

       
130
       
130
       
-
       
		CurrentDir: f.CurrentDir,

     

       
131
       
131
       
-
       
		Ref:        f.Ref,

     

       
129
       
129
       
+
       
		// page context

     

       
130
       
130
       
+
       
		CurrentDir: currentDir,

     

       
131
       
131
       
+
       
		Ref:        ref,

     

       
132
       
132
       
 
       


     

       
133
       
133
       
 
       
		// info related to the session

     

       
134
       
134
       
 
       
		IsStarred: isStarred,