commit 0bba9fb380a0957ce9b2fd2866a66098d651ee64 · julien.rbrt.fr/tangled-core

+2 -3

appview/db/pulls.go

···

       590
       590
        
       	return err

     

       591
       591
        
       }

     

       592
       592
        
       

     

       593
       593
       -
       func ResubmitPull(e Execer, pull *models.Pull, newPatch, sourceRev string) error {

     

       594
       594
       -
       	newRoundNumber := len(pull.Submissions)

     

       593
       593
       +
       func ResubmitPull(e Execer, pullAt syntax.ATURI, newRoundNumber int, newPatch string, newSourceRev string) error {

     

       595
       594
        
       	_, err := e.Exec(`

     

       596
       595
        
       		insert into pull_submissions (pull_at, round_number, patch, source_rev)

     

       597
       596
        
       		values (?, ?, ?, ?)

     

       598
       598
       -
       	`, pull.PullAt(), newRoundNumber, newPatch, sourceRev)

     

       597
       597
       +
       	`, pullAt, newRoundNumber, newPatch, newSourceRev)

     

       599
       598
        
       

     

       600
       599
        
       	return err

     

       601
       600
        
       }

+6 -15

appview/models/pull.go

···

       84
       84
        
       func (p Pull) AsRecord() tangled.RepoPull {

     

       85
       85
        
       	var source *tangled.RepoPull_Source

     

       86
       86
        
       	if p.PullSource != nil {

     

       87
       87
       -
       		s := p.PullSource.AsRecord()

     

       88
       88
       -
       		source = &s

     

       87
       87
       +
       		source = &tangled.RepoPull_Source{}

     

       88
       88
       +
       		source.Branch = p.PullSource.Branch

     

       89
       89
        
       		source.Sha = p.LatestSha()

     

       90
       90
       +
       		if p.PullSource.RepoAt != nil {

     

       91
       91
       +
       			s := p.PullSource.Repo.RepoAt().String()

     

       92
       92
       +
       			source.Repo = &s

     

       93
       93
       +
       		}

     

       90
       94
        
       	}

     

       91
       95
        
       

     

       92
       96
        
       	record := tangled.RepoPull{

     
···

       109
       113
        
       

     

       110
       114
        
       	// optionally populate this for reverse mappings

     

       111
       115
        
       	Repo *Repo

     

       112
       112
       -
       }

     

       113
       113
       -
       

     

       114
       114
       -
       func (p PullSource) AsRecord() tangled.RepoPull_Source {

     

       115
       115
       -
       	var repoAt *string

     

       116
       116
       -
       	if p.RepoAt != nil {

     

       117
       117
       -
       		s := p.RepoAt.String()

     

       118
       118
       -
       		repoAt = &s

     

       119
       119
       -
       	}

     

       120
       120
       -
       	record := tangled.RepoPull_Source{

     

       121
       121
       -
       		Branch: p.Branch,

     

       122
       122
       -
       		Repo:   repoAt,

     

       123
       123
       -
       	}

     

       124
       124
       -
       	return record

     

       125
       116
        
       }

     

       126
       117
        
       

     

       127
       118
        
       type PullSubmission struct {

+15 -10

appview/pulls/pulls.go

···

       415
       415
        
       

     

       416
       416
        
       	targetBranch := branchResp

     

       417
       417
        
       

     

       418
       418
       -
       	latestSourceRev := pull.Submissions[pull.LastRoundNumber()].SourceRev

     

       418
       418
       +
       	latestSourceRev := pull.LatestSha()

     

       419
       419
        
       

     

       420
       420
        
       	if pull.IsStacked() && stack != nil {

     

       421
       421
        
       		top := stack[0]

     

       422
       422
       -
       		latestSourceRev = top.Submissions[top.LastRoundNumber()].SourceRev

     

       422
       422
       +
       		latestSourceRev = top.LatestSha()

     

       423
       423
        
       	}

     

       424
       424
        
       

     

       425
       425
        
       	if latestSourceRev != targetBranch.Hash {

     
···

       1811
       1811
        
       

     

       1812
       1812
        
       	// validate sourceRev if branch/fork based

     

       1813
       1813
        
       	if pull.IsBranchBased() || pull.IsForkBased() {

     

       1814
       1814
       -
       		if sourceRev == pull.Submissions[pull.LastRoundNumber()].SourceRev {

     

       1814
       1814
       +
       		if sourceRev == pull.LatestSha() {

     

       1815
       1815
        
       			s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.")

     

       1816
       1816
        
       			return

     

       1817
       1817
        
       		}

     
···

       1825
       1825
        
       	}

     

       1826
       1826
        
       	defer tx.Rollback()

     

       1827
       1827
        
       

     

       1828
       1828
       -
       	err = db.ResubmitPull(tx, pull, patch, sourceRev)

     

       1828
       1828
       +
       	pullAt := pull.PullAt()

     

       1829
       1829
       +
       	newRoundNumber := len(pull.Submissions)

     

       1830
       1830
       +
       	newPatch := patch

     

       1831
       1831
       +
       	newSourceRev := sourceRev

     

       1832
       1832
       +
       	err = db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, newSourceRev)

     

       1829
       1833
        
       	if err != nil {

     

       1830
       1834
        
       		log.Println("failed to create pull request", err)

     

       1831
       1835
        
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     
···

       2016
       2020
        
       			continue

     

       2017
       2021
        
       		}

     

       2018
       2022
        
       

     

       2019
       2019
       -
       		submission := np.Submissions[np.LastRoundNumber()]

     

       2020
       2020
       -
       

     

       2021
       2021
       -
       		// resubmit the old pull

     

       2022
       2022
       -
       		err := db.ResubmitPull(tx, op, submission.Patch, submission.SourceRev)

     

       2023
       2023
       +
       		// resubmit the new pull

     

       2024
       2024
       +
       		pullAt := op.PullAt()

     

       2025
       2025
       +
       		newRoundNumber := len(op.Submissions)

     

       2026
       2026
       +
       		newPatch := np.LatestPatch()

     

       2027
       2027
       +
       		newSourceRev := np.LatestSha()

     

       2028
       2028
       +
       		err := db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, newSourceRev)

     

       2023
       2029
        
       

     

       2024
       2030
        
       		if err != nil {

     

       2025
       2031
        
       			log.Println("failed to update pull", err, op.PullId)

     
···

       2027
       2033
        
       			return

     

       2028
       2034
        
       		}

     

       2029
       2035
        
       

     

       2030
       2030
       -
       		record := op.AsRecord()

     

       2031
       2031
       -
       		record.Patch = submission.Patch

     

       2036
       2036
       +
       		record := np.AsRecord()

     

       2032
       2037
        
       

     

       2033
       2038
        
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       2034
       2039
        
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{