back round 7 view raw

appview: Update New PR Page #490

merged

opened by

freshlybakedca.ke 4 months ago targeting master from freshlybakedca.ke/core: private/coded/push-nvwonuuosssx

The compare forks option dropdown now shows repos in which you are a collaborator on instead of just repos you own.

options

unified split

Changed files

+22 -14

appview

repos.go

pages

templates

repo

pulls

fragments

pullCompareForks.html

pullHeader.html

pulls

pulls.go

+8 -5

appview/db/repos.go

···

       466
       466
        
       	var repos []Repo

     

       467
       467
        
       

     

       468
       468
        
       	rows, err := e.Query(

     

       469
       469
       -
       		`select did, name, knot, rkey, description, created, source

     

       470
       470
       -
       		from repos

     

       471
       471
       -
       		where did = ? and source is not null and source != ''

     

       472
       472
       -
       		order by created desc`,

     

       473
       473
       -
       		did,

     

       469
       469
       +
       		`select distinct r.did, r.name, r.knot, r.rkey, r.description, r.created, r.source

     

       470
       470
       +
       		from repos r

     

       471
       471
       +
       		left join collaborators c on r.at_uri = c.repo_at

     

       472
       472
       +
       		where (r.did = ? or c.subject_did = ?)

     

       473
       473
       +
       			and r.source is not null

     

       474
       474
       +
       			and r.source != ''

     

       475
       475
       +
       		order by r.created desc`,

     

       476
       476
       +
       		did, did,

     

       474
       477
        
       	)

     

       475
       478
        
       	if err != nil {

     

       476
       479
        
       		return nil, err

+2 -2

appview/pages/templates/repo/pulls/fragments/pullCompareForks.html

···

       19
       19
        
                       >

     

       20
       20
        
                           <option disabled selected>select a fork</option>

     

       21
       21
        
                           {{ range .Forks }}

     

       22
       22
       -
                               <option value="{{ .Name }}" {{ if eq .Name $.Selected }}selected{{ end }} class="py-1">

     

       23
       23
       -
                                   {{ .Name }}

     

       22
       22
       +
                               <option value="{{ .Did }}/{{ .Name }}" {{ if eq .Name $.Selected }}selected{{ end }} class="py-1">

     

       23
       23
       +
                                   {{ .Did | resolve }}/{{ .Name }}

     

       24
       24
        
                               </option>

     

       25
       25
        
                           {{ end }}

     

       26
       26
        
                       </select>

+1 -1

appview/pages/templates/repo/pulls/fragments/pullHeader.html

···

       17
       17
        
           {{ $icon = "git-merge" }}

     

       18
       18
        
       {{ end }}

     

       19
       19
        
       

     

       20
       20
       -
       {{ $owner := resolve .Pull.OwnerDid }}

     

       20
       20
       +
       {{ $owner := resolve .Pull.PullSource.Repo.Did }}

     

       21
       21
        
       <section class="mt-2">

     

       22
       22
        
           <div class="flex items-center gap-2">

     

       23
       23
        
               <div

+11 -6

appview/pulls/pulls.go

···

       857
       857
        
       }

     

       858
       858
        
       

     

       859
       859
        
       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) {

     

       860
       860
       -
       	fork, err := db.GetForkByDid(s.db, user.Did, forkRepo)

     

       860
       860
       +
       	repoString := strings.SplitN(forkRepo, "/", 2)

     

       861
       861
       +
       	forkOwnerDid := repoString[0]

     

       862
       862
       +
       	repoName := repoString[1]

     

       863
       863
       +
       	fork, err := db.GetForkByDid(s.db, forkOwnerDid, repoName)

     

       861
       864
        
       	if errors.Is(err, sql.ErrNoRows) {

     

       862
       865
        
       		s.pages.Notice(w, "pull", "No such fork.")

     

       863
       866
        
       		return

     
···

       888
       891
        
       		return

     

       889
       892
        
       	}

     

       890
       893
        
       

     

       891
       891
       -
       	resp, err := sc.NewHiddenRef(user.Did, fork.Name, sourceBranch, targetBranch)

     

       894
       894
       +
       	resp, err := sc.NewHiddenRef(fork.Did, fork.Name, sourceBranch, targetBranch)

     

       892
       895
        
       	if err != nil {

     

       893
       896
        
       		log.Println("failed to create hidden ref:", err, resp.StatusCode)

     

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

     
···

       908
       911
        
       	// hiddenRef: hidden/feature-1/main (on repo-fork)

     

       909
       912
        
       	// targetBranch: main (on repo-1)

     

       910
       913
        
       	// sourceBranch: feature-1 (on repo-fork)

     

       911
       911
       -
       	comparison, err := us.Compare(user.Did, fork.Name, hiddenRef, sourceBranch)

     

       914
       914
       +
       	comparison, err := us.Compare(fork.Did, fork.Name, hiddenRef, sourceBranch)

     

       912
       915
        
       	if err != nil {

     

       913
       916
        
       		log.Println("failed to compare across branches", err)

     

       914
       917
        
       		s.pages.Notice(w, "pull", err.Error())

     
···

       1270
       1273
        
       	}

     

       1271
       1274
        
       

     

       1272
       1275
        
       	forkVal := r.URL.Query().Get("fork")

     

       1273
       1273
       -
       

     

       1276
       1276
       +
       	repoString := strings.SplitN(forkVal, "/", 2)

     

       1277
       1277
       +
       	forkOwnerDid := repoString[0]

     

       1278
       1278
       +
       	forkName := repoString[1]

     

       1274
       1279
        
       	// fork repo

     

       1275
       1275
       -
       	repo, err := db.GetRepo(s.db, user.Did, forkVal)

     

       1280
       1280
       +
       	repo, err := db.GetRepo(s.db, forkOwnerDid, forkName)

     

       1276
       1281
        
       	if err != nil {

     

       1277
       1282
        
       		log.Println("failed to get repo", user.Did, forkVal)

     

       1278
       1283
        
       		return

     
···

       1285
       1290
        
       		return

     

       1286
       1291
        
       	}

     

       1287
       1292
        
       

     

       1288
       1288
       -
       	sourceResult, err := sourceBranchesClient.Branches(user.Did, repo.Name)

     

       1293
       1293
       +
       	sourceResult, err := sourceBranchesClient.Branches(forkOwnerDid, repo.Name)

     

       1289
       1294
        
       	if err != nil {

     

       1290
       1295
        
       		log.Println("failed to reach knotserver for source branches", err)

     

       1291
       1296
        
       		return