···

       
75
       
 
       
}

     

       
76
       
 
       


     

       
77
       
 
       
type PullEvents struct {

     

       
78
       
-
       
	Items []*Pull

     

       
79
       
 
       
}

     

       
80
       
 
       


     

       
81
       
 
       
func (p PullEvents) Stats() PullEventStats {

     

       
82
       
 
       
	var open, merged, closed int

     

       
83
       
 
       
	for _, pull := range p.Items {

     

       
84
       
 
       
		switch pull.State {

     

       
85
       
-
       
		case PullOpen:

     

       
86
       
 
       
			open += 1

     

       
87
       
-
       
		case PullMerged:

     

       
88
       
 
       
			merged += 1

     

       
89
       
-
       
		case PullClosed:

     

       
90
       
 
       
			closed += 1

     

       
91
       
 
       
		}

     

       
92
       
 
       
	}

     
···

       
546
       
 
       
	switch stat {

     

       
547
       
 
       
	case VanityStatMergedPRCount:

     

       
548
       
 
       
		query = `select count(id) from pulls where owner_did = ? and state = ?`

     

       
549
       
-
       
		args = append(args, did, PullMerged)

     

       
550
       
 
       
	case VanityStatClosedPRCount:

     

       
551
       
 
       
		query = `select count(id) from pulls where owner_did = ? and state = ?`

     

       
552
       
-
       
		args = append(args, did, PullClosed)

     

       
553
       
 
       
	case VanityStatOpenPRCount:

     

       
554
       
 
       
		query = `select count(id) from pulls where owner_did = ? and state = ?`

     

       
555
       
-
       
		args = append(args, did, PullOpen)

     

       
556
       
 
       
	case VanityStatOpenIssueCount:

     

       
557
       
 
       
		query = `select count(id) from issues where did = ? and open = 1`

     

       
558
       
 
       
		args = append(args, did)

     

···

       
75
       
 
       
}

     

       
76
       
 
       


     

       
77
       
 
       
type PullEvents struct {

     

       
78
       
+
       
	Items []*models.Pull

     

       
79
       
 
       
}

     

       
80
       
 
       


     

       
81
       
 
       
func (p PullEvents) Stats() PullEventStats {

     

       
82
       
 
       
	var open, merged, closed int

     

       
83
       
 
       
	for _, pull := range p.Items {

     

       
84
       
 
       
		switch pull.State {

     

       
85
       
+
       
		case models.PullOpen:

     

       
86
       
 
       
			open += 1

     

       
87
       
+
       
		case models.PullMerged:

     

       
88
       
 
       
			merged += 1

     

       
89
       
+
       
		case models.PullClosed:

     

       
90
       
 
       
			closed += 1

     

       
91
       
 
       
		}

     

       
92
       
 
       
	}

     
···

       
546
       
 
       
	switch stat {

     

       
547
       
 
       
	case VanityStatMergedPRCount:

     

       
548
       
 
       
		query = `select count(id) from pulls where owner_did = ? and state = ?`

     

       
549
       
+
       
		args = append(args, did, models.PullMerged)

     

       
550
       
 
       
	case VanityStatClosedPRCount:

     

       
551
       
 
       
		query = `select count(id) from pulls where owner_did = ? and state = ?`

     

       
552
       
+
       
		args = append(args, did, models.PullClosed)

     

       
553
       
 
       
	case VanityStatOpenPRCount:

     

       
554
       
 
       
		query = `select count(id) from pulls where owner_did = ? and state = ?`

     

       
555
       
+
       
		args = append(args, did, models.PullOpen)

     

       
556
       
 
       
	case VanityStatOpenIssueCount:

     

       
557
       
 
       
		query = `select count(id) from issues where did = ? and open = 1`

     

       
558
       
 
       
		args = append(args, did)

     

···

       
4
       
 
       
	"database/sql"

     

       
5
       
 
       
	"fmt"

     

       
6
       
 
       
	"log"

     

       
7
       
-
       
	"slices"

     

       
8
       
 
       
	"sort"

     

       
9
       
 
       
	"strings"

     

       
10
       
 
       
	"time"

     

       
11
       
 
       


     

       
12
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
13
       
-
       
	"tangled.org/core/api/tangled"

     

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

     

       
15
       
-
       
	"tangled.org/core/patchutil"

     

       
16
       
-
       
	"tangled.org/core/types"

     

       
17
       
 
       
)

     

       
18
       
 
       


     

       
19
       
-
       
type PullState int

     

       
20
       
-
       


     

       
21
       
-
       
const (

     

       
22
       
-
       
	PullClosed PullState = iota

     

       
23
       
-
       
	PullOpen

     

       
24
       
-
       
	PullMerged

     

       
25
       
-
       
	PullDeleted

     

       
26
       
-
       
)

     

       
27
       
-
       


     

       
28
       
-
       
func (p PullState) String() string {

     

       
29
       
-
       
	switch p {

     

       
30
       
-
       
	case PullOpen:

     

       
31
       
-
       
		return "open"

     

       
32
       
-
       
	case PullMerged:

     

       
33
       
-
       
		return "merged"

     

       
34
       
-
       
	case PullClosed:

     

       
35
       
-
       
		return "closed"

     

       
36
       
-
       
	case PullDeleted:

     

       
37
       
-
       
		return "deleted"

     

       
38
       
-
       
	default:

     

       
39
       
-
       
		return "closed"

     

       
40
       
-
       
	}

     

       
41
       
-
       
}

     

       
42
       
-
       


     

       
43
       
-
       
func (p PullState) IsOpen() bool {

     

       
44
       
-
       
	return p == PullOpen

     

       
45
       
-
       
}

     

       
46
       
-
       
func (p PullState) IsMerged() bool {

     

       
47
       
-
       
	return p == PullMerged

     

       
48
       
-
       
}

     

       
49
       
-
       
func (p PullState) IsClosed() bool {

     

       
50
       
-
       
	return p == PullClosed

     

       
51
       
-
       
}

     

       
52
       
-
       
func (p PullState) IsDeleted() bool {

     

       
53
       
-
       
	return p == PullDeleted

     

       
54
       
-
       
}

     

       
55
       
-
       


     

       
56
       
-
       
type Pull struct {

     

       
57
       
-
       
	// ids

     

       
58
       
-
       
	ID     int

     

       
59
       
-
       
	PullId int

     

       
60
       
-
       


     

       
61
       
-
       
	// at ids

     

       
62
       
-
       
	RepoAt   syntax.ATURI

     

       
63
       
-
       
	OwnerDid string

     

       
64
       
-
       
	Rkey     string

     

       
65
       
-
       


     

       
66
       
-
       
	// content

     

       
67
       
-
       
	Title        string

     

       
68
       
-
       
	Body         string

     

       
69
       
-
       
	TargetBranch string

     

       
70
       
-
       
	State        PullState

     

       
71
       
-
       
	Submissions  []*PullSubmission

     

       
72
       
-
       


     

       
73
       
-
       
	// stacking

     

       
74
       
-
       
	StackId        string // nullable string

     

       
75
       
-
       
	ChangeId       string // nullable string

     

       
76
       
-
       
	ParentChangeId string // nullable string

     

       
77
       
-
       


     

       
78
       
-
       
	// meta

     

       
79
       
-
       
	Created    time.Time

     

       
80
       
-
       
	PullSource *PullSource

     

       
81
       
-
       


     

       
82
       
-
       
	// optionally, populate this when querying for reverse mappings

     

       
83
       
-
       
	Repo *models.Repo

     

       
84
       
-
       
}

     

       
85
       
-
       


     

       
86
       
-
       
func (p Pull) AsRecord() tangled.RepoPull {

     

       
87
       
-
       
	var source *tangled.RepoPull_Source

     

       
88
       
-
       
	if p.PullSource != nil {

     

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

     

       
90
       
-
       
		source = &s

     

       
91
       
-
       
		source.Sha = p.LatestSha()

     

       
92
       
-
       
	}

     

       
93
       
-
       


     

       
94
       
-
       
	record := tangled.RepoPull{

     

       
95
       
-
       
		Title:     p.Title,

     

       
96
       
-
       
		Body:      &p.Body,

     

       
97
       
-
       
		CreatedAt: p.Created.Format(time.RFC3339),

     

       
98
       
-
       
		Target: &tangled.RepoPull_Target{

     

       
99
       
-
       
			Repo:   p.RepoAt.String(),

     

       
100
       
-
       
			Branch: p.TargetBranch,

     

       
101
       
-
       
		},

     

       
102
       
-
       
		Patch:  p.LatestPatch(),

     

       
103
       
-
       
		Source: source,

     

       
104
       
-
       
	}

     

       
105
       
-
       
	return record

     

       
106
       
-
       
}

     

       
107
       
-
       


     

       
108
       
-
       
type PullSource struct {

     

       
109
       
-
       
	Branch string

     

       
110
       
-
       
	RepoAt *syntax.ATURI

     

       
111
       
-
       


     

       
112
       
-
       
	// optionally populate this for reverse mappings

     

       
113
       
-
       
	Repo *models.Repo

     

       
114
       
-
       
}

     

       
115
       
-
       


     

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

     

       
117
       
-
       
	var repoAt *string

     

       
118
       
-
       
	if p.RepoAt != nil {

     

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

     

       
120
       
-
       
		repoAt = &s

     

       
121
       
-
       
	}

     

       
122
       
-
       
	record := tangled.RepoPull_Source{

     

       
123
       
-
       
		Branch: p.Branch,

     

       
124
       
-
       
		Repo:   repoAt,

     

       
125
       
-
       
	}

     

       
126
       
-
       
	return record

     

       
127
       
-
       
}

     

       
128
       
-
       


     

       
129
       
-
       
type PullSubmission struct {

     

       
130
       
-
       
	// ids

     

       
131
       
-
       
	ID     int

     

       
132
       
-
       
	PullId int

     

       
133
       
-
       


     

       
134
       
-
       
	// at ids

     

       
135
       
-
       
	RepoAt syntax.ATURI

     

       
136
       
-
       


     

       
137
       
-
       
	// content

     

       
138
       
-
       
	RoundNumber int

     

       
139
       
-
       
	Patch       string

     

       
140
       
-
       
	Comments    []PullComment

     

       
141
       
-
       
	SourceRev   string // include the rev that was used to create this submission: only for branch/fork PRs

     

       
142
       
-
       


     

       
143
       
-
       
	// meta

     

       
144
       
-
       
	Created time.Time

     

       
145
       
-
       
}

     

       
146
       
-
       


     

       
147
       
-
       
type PullComment struct {

     

       
148
       
-
       
	// ids

     

       
149
       
-
       
	ID           int

     

       
150
       
-
       
	PullId       int

     

       
151
       
-
       
	SubmissionId int

     

       
152
       
-
       


     

       
153
       
-
       
	// at ids

     

       
154
       
-
       
	RepoAt    string

     

       
155
       
-
       
	OwnerDid  string

     

       
156
       
-
       
	CommentAt string

     

       
157
       
-
       


     

       
158
       
-
       
	// content

     

       
159
       
-
       
	Body string

     

       
160
       
-
       


     

       
161
       
-
       
	// meta

     

       
162
       
-
       
	Created time.Time

     

       
163
       
-
       
}

     

       
164
       
-
       


     

       
165
       
-
       
func (p *Pull) LatestPatch() string {

     

       
166
       
-
       
	latestSubmission := p.Submissions[p.LastRoundNumber()]

     

       
167
       
-
       
	return latestSubmission.Patch

     

       
168
       
-
       
}

     

       
169
       
-
       


     

       
170
       
-
       
func (p *Pull) LatestSha() string {

     

       
171
       
-
       
	latestSubmission := p.Submissions[p.LastRoundNumber()]

     

       
172
       
-
       
	return latestSubmission.SourceRev

     

       
173
       
-
       
}

     

       
174
       
-
       


     

       
175
       
-
       
func (p *Pull) PullAt() syntax.ATURI {

     

       
176
       
-
       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", p.OwnerDid, tangled.RepoPullNSID, p.Rkey))

     

       
177
       
-
       
}

     

       
178
       
-
       


     

       
179
       
-
       
func (p *Pull) LastRoundNumber() int {

     

       
180
       
-
       
	return len(p.Submissions) - 1

     

       
181
       
-
       
}

     

       
182
       
-
       


     

       
183
       
-
       
func (p *Pull) IsPatchBased() bool {

     

       
184
       
-
       
	return p.PullSource == nil

     

       
185
       
-
       
}

     

       
186
       
-
       


     

       
187
       
-
       
func (p *Pull) IsBranchBased() bool {

     

       
188
       
-
       
	if p.PullSource != nil {

     

       
189
       
-
       
		if p.PullSource.RepoAt != nil {

     

       
190
       
-
       
			return p.PullSource.RepoAt == &p.RepoAt

     

       
191
       
-
       
		} else {

     

       
192
       
-
       
			// no repo specified

     

       
193
       
-
       
			return true

     

       
194
       
-
       
		}

     

       
195
       
-
       
	}

     

       
196
       
-
       
	return false

     

       
197
       
-
       
}

     

       
198
       
-
       


     

       
199
       
-
       
func (p *Pull) IsForkBased() bool {

     

       
200
       
-
       
	if p.PullSource != nil {

     

       
201
       
-
       
		if p.PullSource.RepoAt != nil {

     

       
202
       
-
       
			// make sure repos are different

     

       
203
       
-
       
			return p.PullSource.RepoAt != &p.RepoAt

     

       
204
       
-
       
		}

     

       
205
       
-
       
	}

     

       
206
       
-
       
	return false

     

       
207
       
-
       
}

     

       
208
       
-
       


     

       
209
       
-
       
func (p *Pull) IsStacked() bool {

     

       
210
       
-
       
	return p.StackId != ""

     

       
211
       
-
       
}

     

       
212
       
-
       


     

       
213
       
-
       
func (s PullSubmission) IsFormatPatch() bool {

     

       
214
       
-
       
	return patchutil.IsFormatPatch(s.Patch)

     

       
215
       
-
       
}

     

       
216
       
-
       


     

       
217
       
-
       
func (s PullSubmission) AsFormatPatch() []types.FormatPatch {

     

       
218
       
-
       
	patches, err := patchutil.ExtractPatches(s.Patch)

     

       
219
       
-
       
	if err != nil {

     

       
220
       
-
       
		log.Println("error extracting patches from submission:", err)

     

       
221
       
-
       
		return []types.FormatPatch{}

     

       
222
       
-
       
	}

     

       
223
       
-
       


     

       
224
       
-
       
	return patches

     

       
225
       
-
       
}

     

       
226
       
-
       


     

       
227
       
-
       
func NewPull(tx *sql.Tx, pull *Pull) error {

     

       
228
       
 
       
	_, err := tx.Exec(`

     

       
229
       
 
       
		insert or ignore into repo_pull_seqs (repo_at, next_pull_id)

     

       
230
       
 
       
		values (?, 1)

     
···

       
245
       
 
       
	}

     

       
246
       
 
       


     

       
247
       
 
       
	pull.PullId = nextId

     

       
248
       
-
       
	pull.State = PullOpen

     

       
249
       
 
       


     

       
250
       
 
       
	var sourceBranch, sourceRepoAt *string

     

       
251
       
 
       
	if pull.PullSource != nil {

     
···

       
312
       
 
       
	return pullId - 1, err

     

       
313
       
 
       
}

     

       
314
       
 
       


     

       
315
       
-
       
func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*Pull, error) {

     

       
316
       
-
       
	pulls := make(map[int]*Pull)

     

       
317
       
 
       


     

       
318
       
 
       
	var conditions []string

     

       
319
       
 
       
	var args []any

     
···

       
362
       
 
       
	defer rows.Close()

     

       
363
       
 
       


     

       
364
       
 
       
	for rows.Next() {

     

       
365
       
-
       
		var pull Pull

     

       
366
       
 
       
		var createdAt string

     

       
367
       
 
       
		var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString

     

       
368
       
 
       
		err := rows.Scan(

     
···

       
392
       
 
       
		pull.Created = createdTime

     

       
393
       
 
       


     

       
394
       
 
       
		if sourceBranch.Valid {

     

       
395
       
-
       
			pull.PullSource = &PullSource{

     

       
396
       
 
       
				Branch: sourceBranch.String,

     

       
397
       
 
       
			}

     

       
398
       
 
       
			if sourceRepoAt.Valid {

     
···

       
445
       
 
       
	defer submissionsRows.Close()

     

       
446
       
 
       


     

       
447
       
 
       
	for submissionsRows.Next() {

     

       
448
       
-
       
		var s PullSubmission

     

       
449
       
 
       
		var sourceRev sql.NullString

     

       
450
       
 
       
		var createdAt string

     

       
451
       
 
       
		err := submissionsRows.Scan(

     
···

       
471
       
 
       
		}

     

       
472
       
 
       


     

       
473
       
 
       
		if p, ok := pulls[s.PullId]; ok {

     

       
474
       
-
       
			p.Submissions = make([]*PullSubmission, s.RoundNumber+1)

     

       
475
       
 
       
			p.Submissions[s.RoundNumber] = &s

     

       
476
       
 
       
		}

     

       
477
       
 
       
	}

     
···

       
512
       
 
       
			return nil, err

     

       
513
       
 
       
		}

     

       
514
       
 
       
		if p, ok := pulls[pullId]; ok {

     

       
515
       
-
       
			p.Submissions[p.LastRoundNumber()].Comments = make([]PullComment, commentCount)

     

       
516
       
 
       
		}

     

       
517
       
 
       
	}

     

       
518
       
 
       
	if err := rows.Err(); err != nil {

     

       
519
       
 
       
		return nil, err

     

       
520
       
 
       
	}

     

       
521
       
 
       


     

       
522
       
-
       
	orderedByPullId := []*Pull{}

     

       
523
       
 
       
	for _, p := range pulls {

     

       
524
       
 
       
		orderedByPullId = append(orderedByPullId, p)

     

       
525
       
 
       
	}

     
···

       
530
       
 
       
	return orderedByPullId, nil

     

       
531
       
 
       
}

     

       
532
       
 
       


     

       
533
       
-
       
func GetPulls(e Execer, filters ...filter) ([]*Pull, error) {

     

       
534
       
 
       
	return GetPullsWithLimit(e, 0, filters...)

     

       
535
       
 
       
}

     

       
536
       
 
       


     

       
537
       
-
       
func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*Pull, error) {

     

       
538
       
 
       
	query := `

     

       
539
       
 
       
		select

     

       
540
       
 
       
			owner_did,

     
···

       
558
       
 
       
		`

     

       
559
       
 
       
	row := e.QueryRow(query, repoAt, pullId)

     

       
560
       
 
       


     

       
561
       
-
       
	var pull Pull

     

       
562
       
 
       
	var createdAt string

     

       
563
       
 
       
	var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString

     

       
564
       
 
       
	err := row.Scan(

     
···

       
589
       
 
       


     

       
590
       
 
       
	// populate source

     

       
591
       
 
       
	if sourceBranch.Valid {

     

       
592
       
-
       
		pull.PullSource = &PullSource{

     

       
593
       
 
       
			Branch: sourceBranch.String,

     

       
594
       
 
       
		}

     

       
595
       
 
       
		if sourceRepoAt.Valid {

     
···

       
625
       
 
       
	}

     

       
626
       
 
       
	defer submissionsRows.Close()

     

       
627
       
 
       


     

       
628
       
-
       
	submissionsMap := make(map[int]*PullSubmission)

     

       
629
       
 
       


     

       
630
       
 
       
	for submissionsRows.Next() {

     

       
631
       
-
       
		var submission PullSubmission

     

       
632
       
 
       
		var submissionCreatedStr string

     

       
633
       
 
       
		var submissionSourceRev sql.NullString

     

       
634
       
 
       
		err := submissionsRows.Scan(

     
···

       
692
       
 
       
	defer commentsRows.Close()

     

       
693
       
 
       


     

       
694
       
 
       
	for commentsRows.Next() {

     

       
695
       
-
       
		var comment PullComment

     

       
696
       
 
       
		var commentCreatedStr string

     

       
697
       
 
       
		err := commentsRows.Scan(

     

       
698
       
 
       
			&comment.ID,

     
···

       
736
       
 
       
		}

     

       
737
       
 
       
	}

     

       
738
       
 
       


     

       
739
       
-
       
	pull.Submissions = make([]*PullSubmission, len(submissionsMap))

     

       
740
       
 
       
	for _, submission := range submissionsMap {

     

       
741
       
 
       
		pull.Submissions[submission.RoundNumber] = submission

     

       
742
       
 
       
	}

     
···

       
746
       
 
       


     

       
747
       
 
       
// timeframe here is directly passed into the sql query filter, and any

     

       
748
       
 
       
// timeframe in the past should be negative; e.g.: "-3 months"

     

       
749
       
-
       
func GetPullsByOwnerDid(e Execer, did, timeframe string) ([]Pull, error) {

     

       
750
       
-
       
	var pulls []Pull

     

       
751
       
 
       


     

       
752
       
 
       
	rows, err := e.Query(`

     

       
753
       
 
       
			select

     
···

       
776
       
 
       
	defer rows.Close()

     

       
777
       
 
       


     

       
778
       
 
       
	for rows.Next() {

     

       
779
       
-
       
		var pull Pull

     

       
780
       
 
       
		var repo models.Repo

     

       
781
       
 
       
		var pullCreatedAt, repoCreatedAt string

     

       
782
       
 
       
		err := rows.Scan(

     
···

       
820
       
 
       
	return pulls, nil

     

       
821
       
 
       
}

     

       
822
       
 
       


     

       
823
       
-
       
func NewPullComment(e Execer, comment *PullComment) (int64, error) {

     

       
824
       
 
       
	query := `insert into pull_comments (owner_did, repo_at, submission_id, comment_at, pull_id, body) values (?, ?, ?, ?, ?, ?)`

     

       
825
       
 
       
	res, err := e.Exec(

     

       
826
       
 
       
		query,

     
···

       
843
       
 
       
	return i, nil

     

       
844
       
 
       
}

     

       
845
       
 
       


     

       
846
       
-
       
func SetPullState(e Execer, repoAt syntax.ATURI, pullId int, pullState PullState) error {

     

       
847
       
 
       
	_, err := e.Exec(

     

       
848
       
 
       
		`update pulls set state = ? where repo_at = ? and pull_id = ? and (state <> ? or state <> ?)`,

     

       
849
       
 
       
		pullState,

     

       
850
       
 
       
		repoAt,

     

       
851
       
 
       
		pullId,

     

       
852
       
-
       
		PullDeleted, // only update state of non-deleted pulls

     

       
853
       
-
       
		PullMerged,  // only update state of non-merged pulls

     

       
854
       
 
       
	)

     

       
855
       
 
       
	return err

     

       
856
       
 
       
}

     

       
857
       
 
       


     

       
858
       
 
       
func ClosePull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
859
       
-
       
	err := SetPullState(e, repoAt, pullId, PullClosed)

     

       
860
       
 
       
	return err

     

       
861
       
 
       
}

     

       
862
       
 
       


     

       
863
       
 
       
func ReopenPull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
864
       
-
       
	err := SetPullState(e, repoAt, pullId, PullOpen)

     

       
865
       
 
       
	return err

     

       
866
       
 
       
}

     

       
867
       
 
       


     

       
868
       
 
       
func MergePull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
869
       
-
       
	err := SetPullState(e, repoAt, pullId, PullMerged)

     

       
870
       
 
       
	return err

     

       
871
       
 
       
}

     

       
872
       
 
       


     

       
873
       
 
       
func DeletePull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
874
       
-
       
	err := SetPullState(e, repoAt, pullId, PullDeleted)

     

       
875
       
 
       
	return err

     

       
876
       
 
       
}

     

       
877
       
 
       


     

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

     

       
879
       
 
       
	newRoundNumber := len(pull.Submissions)

     

       
880
       
 
       
	_, err := e.Exec(`

     

       
881
       
 
       
		insert into pull_submissions (pull_id, repo_at, round_number, patch, source_rev)

     
···

       
941
       
 
       
			count(case when state = ? then 1 end) as deleted_count

     

       
942
       
 
       
		from pulls

     

       
943
       
 
       
		where repo_at = ?`,

     

       
944
       
-
       
		PullOpen,

     

       
945
       
-
       
		PullMerged,

     

       
946
       
-
       
		PullClosed,

     

       
947
       
-
       
		PullDeleted,

     

       
948
       
 
       
		repoAt,

     

       
949
       
 
       
	)

     

       
950
       
 
       


     
···

       
956
       
 
       
	return count, nil

     

       
957
       
 
       
}

     

       
958
       
 
       


     

       
959
       
-
       
type Stack []*Pull

     

       
960
       
-
       


     

       
961
       
 
       
//	change-id     parent-change-id

     

       
962
       
 
       
//

     

       
963
       
 
       
// 4       w      ,-------- z          (TOP)

     
···

       
966
       
 
       
// 1       x <------'      nil         (BOT)

     

       
967
       
 
       
//

     

       
968
       
 
       
// `w` is parent of none, so it is the top of the stack

     

       
969
       
-
       
func GetStack(e Execer, stackId string) (Stack, error) {

     

       
970
       
 
       
	unorderedPulls, err := GetPulls(

     

       
971
       
 
       
		e,

     

       
972
       
 
       
		FilterEq("stack_id", stackId),

     

       
973
       
-
       
		FilterNotEq("state", PullDeleted),

     

       
974
       
 
       
	)

     

       
975
       
 
       
	if err != nil {

     

       
976
       
 
       
		return nil, err

     

       
977
       
 
       
	}

     

       
978
       
 
       
	// map of parent-change-id to pull

     

       
979
       
-
       
	changeIdMap := make(map[string]*Pull, len(unorderedPulls))

     

       
980
       
-
       
	parentMap := make(map[string]*Pull, len(unorderedPulls))

     

       
981
       
 
       
	for _, p := range unorderedPulls {

     

       
982
       
 
       
		changeIdMap[p.ChangeId] = p

     

       
983
       
 
       
		if p.ParentChangeId != "" {

     
···

       
986
       
 
       
	}

     

       
987
       
 
       


     

       
988
       
 
       
	// the top of the stack is the pull that is not a parent of any pull

     

       
989
       
-
       
	var topPull *Pull

     

       
990
       
 
       
	for _, maybeTop := range unorderedPulls {

     

       
991
       
 
       
		if _, ok := parentMap[maybeTop.ChangeId]; !ok {

     

       
992
       
 
       
			topPull = maybeTop

     
···

       
994
       
 
       
		}

     

       
995
       
 
       
	}

     

       
996
       
 
       


     

       
997
       
-
       
	pulls := []*Pull{}

     

       
998
       
 
       
	for {

     

       
999
       
 
       
		pulls = append(pulls, topPull)

     

       
1000
       
 
       
		if topPull.ParentChangeId != "" {

     
···

       
1011
       
 
       
	return pulls, nil

     

       
1012
       
 
       
}

     

       
1013
       
 
       


     

       
1014
       
-
       
func GetAbandonedPulls(e Execer, stackId string) ([]*Pull, error) {

     

       
1015
       
 
       
	pulls, err := GetPulls(

     

       
1016
       
 
       
		e,

     

       
1017
       
 
       
		FilterEq("stack_id", stackId),

     

       
1018
       
-
       
		FilterEq("state", PullDeleted),

     

       
1019
       
 
       
	)

     

       
1020
       
 
       
	if err != nil {

     

       
1021
       
 
       
		return nil, err

     
···

       
1023
       
 
       


     

       
1024
       
 
       
	return pulls, nil

     

       
1025
       
 
       
}

     

       
1026
       
-
       


     

       
1027
       
-
       
// position of this pull in the stack

     

       
1028
       
-
       
func (stack Stack) Position(pull *Pull) int {

     

       
1029
       
-
       
	return slices.IndexFunc(stack, func(p *Pull) bool {

     

       
1030
       
-
       
		return p.ChangeId == pull.ChangeId

     

       
1031
       
-
       
	})

     

       
1032
       
-
       
}

     

       
1033
       
-
       


     

       
1034
       
-
       
// all pulls below this pull (including self) in this stack

     

       
1035
       
-
       
//

     

       
1036
       
-
       
// nil if this pull does not belong to this stack

     

       
1037
       
-
       
func (stack Stack) Below(pull *Pull) Stack {

     

       
1038
       
-
       
	position := stack.Position(pull)

     

       
1039
       
-
       


     

       
1040
       
-
       
	if position < 0 {

     

       
1041
       
-
       
		return nil

     

       
1042
       
-
       
	}

     

       
1043
       
-
       


     

       
1044
       
-
       
	return stack[position:]

     

       
1045
       
-
       
}

     

       
1046
       
-
       


     

       
1047
       
-
       
// all pulls below this pull (excluding self) in this stack

     

       
1048
       
-
       
func (stack Stack) StrictlyBelow(pull *Pull) Stack {

     

       
1049
       
-
       
	below := stack.Below(pull)

     

       
1050
       
-
       


     

       
1051
       
-
       
	if len(below) > 0 {

     

       
1052
       
-
       
		return below[1:]

     

       
1053
       
-
       
	}

     

       
1054
       
-
       


     

       
1055
       
-
       
	return nil

     

       
1056
       
-
       
}

     

       
1057
       
-
       


     

       
1058
       
-
       
// all pulls above this pull (including self) in this stack

     

       
1059
       
-
       
func (stack Stack) Above(pull *Pull) Stack {

     

       
1060
       
-
       
	position := stack.Position(pull)

     

       
1061
       
-
       


     

       
1062
       
-
       
	if position < 0 {

     

       
1063
       
-
       
		return nil

     

       
1064
       
-
       
	}

     

       
1065
       
-
       


     

       
1066
       
-
       
	return stack[:position+1]

     

       
1067
       
-
       
}

     

       
1068
       
-
       


     

       
1069
       
-
       
// all pulls below this pull (excluding self) in this stack

     

       
1070
       
-
       
func (stack Stack) StrictlyAbove(pull *Pull) Stack {

     

       
1071
       
-
       
	above := stack.Above(pull)

     

       
1072
       
-
       


     

       
1073
       
-
       
	if len(above) > 0 {

     

       
1074
       
-
       
		return above[:len(above)-1]

     

       
1075
       
-
       
	}

     

       
1076
       
-
       


     

       
1077
       
-
       
	return nil

     

       
1078
       
-
       
}

     

       
1079
       
-
       


     

       
1080
       
-
       
// the combined format-patches of all the newest submissions in this stack

     

       
1081
       
-
       
func (stack Stack) CombinedPatch() string {

     

       
1082
       
-
       
	// go in reverse order because the bottom of the stack is the last element in the slice

     

       
1083
       
-
       
	var combined strings.Builder

     

       
1084
       
-
       
	for idx := range stack {

     

       
1085
       
-
       
		pull := stack[len(stack)-1-idx]

     

       
1086
       
-
       
		combined.WriteString(pull.LatestPatch())

     

       
1087
       
-
       
		combined.WriteString("\n")

     

       
1088
       
-
       
	}

     

       
1089
       
-
       
	return combined.String()

     

       
1090
       
-
       
}

     

       
1091
       
-
       


     

       
1092
       
-
       
// filter out PRs that are "active"

     

       
1093
       
-
       
//

     

       
1094
       
-
       
// PRs that are still open are active

     

       
1095
       
-
       
func (stack Stack) Mergeable() Stack {

     

       
1096
       
-
       
	var mergeable Stack

     

       
1097
       
-
       


     

       
1098
       
-
       
	for _, p := range stack {

     

       
1099
       
-
       
		// stop at the first merged PR

     

       
1100
       
-
       
		if p.State == PullMerged || p.State == PullClosed {

     

       
1101
       
-
       
			break

     

       
1102
       
-
       
		}

     

       
1103
       
-
       


     

       
1104
       
-
       
		// skip over deleted PRs

     

       
1105
       
-
       
		if p.State != PullDeleted {

     

       
1106
       
-
       
			mergeable = append(mergeable, p)

     

       
1107
       
-
       
		}

     

       
1108
       
-
       
	}

     

       
1109
       
-
       


     

       
1110
       
-
       
	return mergeable

     

       
1111
       
-
       
}

     

···

       
4
       
 
       
	"database/sql"

     

       
5
       
 
       
	"fmt"

     

       
6
       
 
       
	"log"

     

       
0
       
 
       

     

       
7
       
 
       
	"sort"

     

       
8
       
 
       
	"strings"

     

       
9
       
 
       
	"time"

     

       
10
       
 
       


     

       
11
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     

       
0
       
 
       

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
13
       
 
       
)

     

       
14
       
 
       


     

       
15
       
+
       
func NewPull(tx *sql.Tx, pull *models.Pull) error {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
16
       
 
       
	_, err := tx.Exec(`

     

       
17
       
 
       
		insert or ignore into repo_pull_seqs (repo_at, next_pull_id)

     

       
18
       
 
       
		values (?, 1)

     
···

       
33
       
 
       
	}

     

       
34
       
 
       


     

       
35
       
 
       
	pull.PullId = nextId

     

       
36
       
+
       
	pull.State = models.PullOpen

     

       
37
       
 
       


     

       
38
       
 
       
	var sourceBranch, sourceRepoAt *string

     

       
39
       
 
       
	if pull.PullSource != nil {

     
···

       
100
       
 
       
	return pullId - 1, err

     

       
101
       
 
       
}

     

       
102
       
 
       


     

       
103
       
+
       
func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*models.Pull, error) {

     

       
104
       
+
       
	pulls := make(map[int]*models.Pull)

     

       
105
       
 
       


     

       
106
       
 
       
	var conditions []string

     

       
107
       
 
       
	var args []any

     
···

       
150
       
 
       
	defer rows.Close()

     

       
151
       
 
       


     

       
152
       
 
       
	for rows.Next() {

     

       
153
       
+
       
		var pull models.Pull

     

       
154
       
 
       
		var createdAt string

     

       
155
       
 
       
		var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString

     

       
156
       
 
       
		err := rows.Scan(

     
···

       
180
       
 
       
		pull.Created = createdTime

     

       
181
       
 
       


     

       
182
       
 
       
		if sourceBranch.Valid {

     

       
183
       
+
       
			pull.PullSource = &models.PullSource{

     

       
184
       
 
       
				Branch: sourceBranch.String,

     

       
185
       
 
       
			}

     

       
186
       
 
       
			if sourceRepoAt.Valid {

     
···

       
233
       
 
       
	defer submissionsRows.Close()

     

       
234
       
 
       


     

       
235
       
 
       
	for submissionsRows.Next() {

     

       
236
       
+
       
		var s models.PullSubmission

     

       
237
       
 
       
		var sourceRev sql.NullString

     

       
238
       
 
       
		var createdAt string

     

       
239
       
 
       
		err := submissionsRows.Scan(

     
···

       
259
       
 
       
		}

     

       
260
       
 
       


     

       
261
       
 
       
		if p, ok := pulls[s.PullId]; ok {

     

       
262
       
+
       
			p.Submissions = make([]*models.PullSubmission, s.RoundNumber+1)

     

       
263
       
 
       
			p.Submissions[s.RoundNumber] = &s

     

       
264
       
 
       
		}

     

       
265
       
 
       
	}

     
···

       
300
       
 
       
			return nil, err

     

       
301
       
 
       
		}

     

       
302
       
 
       
		if p, ok := pulls[pullId]; ok {

     

       
303
       
+
       
			p.Submissions[p.LastRoundNumber()].Comments = make([]models.PullComment, commentCount)

     

       
304
       
 
       
		}

     

       
305
       
 
       
	}

     

       
306
       
 
       
	if err := rows.Err(); err != nil {

     

       
307
       
 
       
		return nil, err

     

       
308
       
 
       
	}

     

       
309
       
 
       


     

       
310
       
+
       
	orderedByPullId := []*models.Pull{}

     

       
311
       
 
       
	for _, p := range pulls {

     

       
312
       
 
       
		orderedByPullId = append(orderedByPullId, p)

     

       
313
       
 
       
	}

     
···

       
318
       
 
       
	return orderedByPullId, nil

     

       
319
       
 
       
}

     

       
320
       
 
       


     

       
321
       
+
       
func GetPulls(e Execer, filters ...filter) ([]*models.Pull, error) {

     

       
322
       
 
       
	return GetPullsWithLimit(e, 0, filters...)

     

       
323
       
 
       
}

     

       
324
       
 
       


     

       
325
       
+
       
func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*models.Pull, error) {

     

       
326
       
 
       
	query := `

     

       
327
       
 
       
		select

     

       
328
       
 
       
			owner_did,

     
···

       
346
       
 
       
		`

     

       
347
       
 
       
	row := e.QueryRow(query, repoAt, pullId)

     

       
348
       
 
       


     

       
349
       
+
       
	var pull models.Pull

     

       
350
       
 
       
	var createdAt string

     

       
351
       
 
       
	var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString

     

       
352
       
 
       
	err := row.Scan(

     
···

       
377
       
 
       


     

       
378
       
 
       
	// populate source

     

       
379
       
 
       
	if sourceBranch.Valid {

     

       
380
       
+
       
		pull.PullSource = &models.PullSource{

     

       
381
       
 
       
			Branch: sourceBranch.String,

     

       
382
       
 
       
		}

     

       
383
       
 
       
		if sourceRepoAt.Valid {

     
···

       
413
       
 
       
	}

     

       
414
       
 
       
	defer submissionsRows.Close()

     

       
415
       
 
       


     

       
416
       
+
       
	submissionsMap := make(map[int]*models.PullSubmission)

     

       
417
       
 
       


     

       
418
       
 
       
	for submissionsRows.Next() {

     

       
419
       
+
       
		var submission models.PullSubmission

     

       
420
       
 
       
		var submissionCreatedStr string

     

       
421
       
 
       
		var submissionSourceRev sql.NullString

     

       
422
       
 
       
		err := submissionsRows.Scan(

     
···

       
480
       
 
       
	defer commentsRows.Close()

     

       
481
       
 
       


     

       
482
       
 
       
	for commentsRows.Next() {

     

       
483
       
+
       
		var comment models.PullComment

     

       
484
       
 
       
		var commentCreatedStr string

     

       
485
       
 
       
		err := commentsRows.Scan(

     

       
486
       
 
       
			&comment.ID,

     
···

       
524
       
 
       
		}

     

       
525
       
 
       
	}

     

       
526
       
 
       


     

       
527
       
+
       
	pull.Submissions = make([]*models.PullSubmission, len(submissionsMap))

     

       
528
       
 
       
	for _, submission := range submissionsMap {

     

       
529
       
 
       
		pull.Submissions[submission.RoundNumber] = submission

     

       
530
       
 
       
	}

     
···

       
534
       
 
       


     

       
535
       
 
       
// timeframe here is directly passed into the sql query filter, and any

     

       
536
       
 
       
// timeframe in the past should be negative; e.g.: "-3 months"

     

       
537
       
+
       
func GetPullsByOwnerDid(e Execer, did, timeframe string) ([]models.Pull, error) {

     

       
538
       
+
       
	var pulls []models.Pull

     

       
539
       
 
       


     

       
540
       
 
       
	rows, err := e.Query(`

     

       
541
       
 
       
			select

     
···

       
564
       
 
       
	defer rows.Close()

     

       
565
       
 
       


     

       
566
       
 
       
	for rows.Next() {

     

       
567
       
+
       
		var pull models.Pull

     

       
568
       
 
       
		var repo models.Repo

     

       
569
       
 
       
		var pullCreatedAt, repoCreatedAt string

     

       
570
       
 
       
		err := rows.Scan(

     
···

       
608
       
 
       
	return pulls, nil

     

       
609
       
 
       
}

     

       
610
       
 
       


     

       
611
       
+
       
func NewPullComment(e Execer, comment *models.PullComment) (int64, error) {

     

       
612
       
 
       
	query := `insert into pull_comments (owner_did, repo_at, submission_id, comment_at, pull_id, body) values (?, ?, ?, ?, ?, ?)`

     

       
613
       
 
       
	res, err := e.Exec(

     

       
614
       
 
       
		query,

     
···

       
631
       
 
       
	return i, nil

     

       
632
       
 
       
}

     

       
633
       
 
       


     

       
634
       
+
       
func SetPullState(e Execer, repoAt syntax.ATURI, pullId int, pullState models.PullState) error {

     

       
635
       
 
       
	_, err := e.Exec(

     

       
636
       
 
       
		`update pulls set state = ? where repo_at = ? and pull_id = ? and (state <> ? or state <> ?)`,

     

       
637
       
 
       
		pullState,

     

       
638
       
 
       
		repoAt,

     

       
639
       
 
       
		pullId,

     

       
640
       
+
       
		models.PullDeleted, // only update state of non-deleted pulls

     

       
641
       
+
       
		models.PullMerged,  // only update state of non-merged pulls

     

       
642
       
 
       
	)

     

       
643
       
 
       
	return err

     

       
644
       
 
       
}

     

       
645
       
 
       


     

       
646
       
 
       
func ClosePull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
647
       
+
       
	err := SetPullState(e, repoAt, pullId, models.PullClosed)

     

       
648
       
 
       
	return err

     

       
649
       
 
       
}

     

       
650
       
 
       


     

       
651
       
 
       
func ReopenPull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
652
       
+
       
	err := SetPullState(e, repoAt, pullId, models.PullOpen)

     

       
653
       
 
       
	return err

     

       
654
       
 
       
}

     

       
655
       
 
       


     

       
656
       
 
       
func MergePull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
657
       
+
       
	err := SetPullState(e, repoAt, pullId, models.PullMerged)

     

       
658
       
 
       
	return err

     

       
659
       
 
       
}

     

       
660
       
 
       


     

       
661
       
 
       
func DeletePull(e Execer, repoAt syntax.ATURI, pullId int) error {

     

       
662
       
+
       
	err := SetPullState(e, repoAt, pullId, models.PullDeleted)

     

       
663
       
 
       
	return err

     

       
664
       
 
       
}

     

       
665
       
 
       


     

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

     

       
667
       
 
       
	newRoundNumber := len(pull.Submissions)

     

       
668
       
 
       
	_, err := e.Exec(`

     

       
669
       
 
       
		insert into pull_submissions (pull_id, repo_at, round_number, patch, source_rev)

     
···

       
729
       
 
       
			count(case when state = ? then 1 end) as deleted_count

     

       
730
       
 
       
		from pulls

     

       
731
       
 
       
		where repo_at = ?`,

     

       
732
       
+
       
		models.PullOpen,

     

       
733
       
+
       
		models.PullMerged,

     

       
734
       
+
       
		models.PullClosed,

     

       
735
       
+
       
		models.PullDeleted,

     

       
736
       
 
       
		repoAt,

     

       
737
       
 
       
	)

     

       
738
       
 
       


     
···

       
744
       
 
       
	return count, nil

     

       
745
       
 
       
}

     

       
746
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
747
       
 
       
//	change-id     parent-change-id

     

       
748
       
 
       
//

     

       
749
       
 
       
// 4       w      ,-------- z          (TOP)

     
···

       
752
       
 
       
// 1       x <------'      nil         (BOT)

     

       
753
       
 
       
//

     

       
754
       
 
       
// `w` is parent of none, so it is the top of the stack

     

       
755
       
+
       
func GetStack(e Execer, stackId string) (models.Stack, error) {

     

       
756
       
 
       
	unorderedPulls, err := GetPulls(

     

       
757
       
 
       
		e,

     

       
758
       
 
       
		FilterEq("stack_id", stackId),

     

       
759
       
+
       
		FilterNotEq("state", models.PullDeleted),

     

       
760
       
 
       
	)

     

       
761
       
 
       
	if err != nil {

     

       
762
       
 
       
		return nil, err

     

       
763
       
 
       
	}

     

       
764
       
 
       
	// map of parent-change-id to pull

     

       
765
       
+
       
	changeIdMap := make(map[string]*models.Pull, len(unorderedPulls))

     

       
766
       
+
       
	parentMap := make(map[string]*models.Pull, len(unorderedPulls))

     

       
767
       
 
       
	for _, p := range unorderedPulls {

     

       
768
       
 
       
		changeIdMap[p.ChangeId] = p

     

       
769
       
 
       
		if p.ParentChangeId != "" {

     
···

       
772
       
 
       
	}

     

       
773
       
 
       


     

       
774
       
 
       
	// the top of the stack is the pull that is not a parent of any pull

     

       
775
       
+
       
	var topPull *models.Pull

     

       
776
       
 
       
	for _, maybeTop := range unorderedPulls {

     

       
777
       
 
       
		if _, ok := parentMap[maybeTop.ChangeId]; !ok {

     

       
778
       
 
       
			topPull = maybeTop

     
···

       
780
       
 
       
		}

     

       
781
       
 
       
	}

     

       
782
       
 
       


     

       
783
       
+
       
	pulls := []*models.Pull{}

     

       
784
       
 
       
	for {

     

       
785
       
 
       
		pulls = append(pulls, topPull)

     

       
786
       
 
       
		if topPull.ParentChangeId != "" {

     
···

       
797
       
 
       
	return pulls, nil

     

       
798
       
 
       
}

     

       
799
       
 
       


     

       
800
       
+
       
func GetAbandonedPulls(e Execer, stackId string) ([]*models.Pull, error) {

     

       
801
       
 
       
	pulls, err := GetPulls(

     

       
802
       
 
       
		e,

     

       
803
       
 
       
		FilterEq("stack_id", stackId),

     

       
804
       
+
       
		FilterEq("state", models.PullDeleted),

     

       
805
       
 
       
	)

     

       
806
       
 
       
	if err != nil {

     

       
807
       
 
       
		return nil, err

     
···

       
809
       
 
       


     

       
810
       
 
       
	return pulls, nil

     

       
811
       
 
       
}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
237
       
 
       
		inClause,

     

       
238
       
 
       
	)

     

       
239
       
 
       
	args = append([]any{

     

       
240
       
-
       
		PullOpen,

     

       
241
       
-
       
		PullMerged,

     

       
242
       
-
       
		PullClosed,

     

       
243
       
-
       
		PullDeleted,

     

       
244
       
 
       
	}, args...)

     

       
245
       
 
       
	rows, err = e.Query(

     

       
246
       
 
       
		pullCountQuery,

     

···

       
237
       
 
       
		inClause,

     

       
238
       
 
       
	)

     

       
239
       
 
       
	args = append([]any{

     

       
240
       
+
       
		models.PullOpen,

     

       
241
       
+
       
		models.PullMerged,

     

       
242
       
+
       
		models.PullClosed,

     

       
243
       
+
       
		models.PullDeleted,

     

       
244
       
 
       
	}, args...)

     

       
245
       
 
       
	rows, err = e.Query(

     

       
246
       
 
       
		pullCountQuery,

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0