commit f699b193c561380e2e0b6c4a1857c0a5c54643eb · notnite.com/core

+94 -7

appview/db/pulls.go

···

       4
       4
        
       	"database/sql"

     

       5
       5
        
       	"fmt"

     

       6
       6
        
       	"log"

     

       7
       7
       +
       	"sort"

     

       7
       8
        
       	"strings"

     

       8
       9
        
       	"time"

     

       9
       10
        
       

     
···

       274
       275
        
       	return pullId - 1, err

     

       275
       276
        
       }

     

       276
       277
        
       

     

       277
       277
       -
       func GetPulls(e Execer, repoAt syntax.ATURI, state PullState) ([]Pull, error) {

     

       278
       278
       -
       	var pulls []Pull

     

       278
       278
       +
       func GetPulls(e Execer, repoAt syntax.ATURI, state PullState) ([]*Pull, error) {

     

       279
       279
       +
       	pulls := make(map[int]*Pull)

     

       279
       280
        
       

     

       280
       281
        
       	rows, err := e.Query(`

     

       281
       282
        
       		select

     
···

       293
       294
        
       		from

     

       294
       295
        
       			pulls

     

       295
       296
        
       		where

     

       296
       296
       -
       			repo_at = ? and state = ?

     

       297
       297
       -
       		order by

     

       298
       298
       -
       			created desc`, repoAt, state)

     

       297
       297
       +
       			repo_at = ? and state = ?`, repoAt, state)

     

       299
       298
        
       	if err != nil {

     

       300
       299
        
       		return nil, err

     

       301
       300
        
       	}

     
···

       341
       340
        
       			}

     

       342
       341
        
       		}

     

       343
       342
        
       

     

       344
       344
       -
       		pulls = append(pulls, pull)

     

       343
       343
       +
       		pulls[pull.PullId] = &pull

     

       345
       344
        
       	}

     

       346
       345
        
       

     

       346
       346
       +
       	// get latest round no. for each pull

     

       347
       347
       +
       	inClause := strings.TrimSuffix(strings.Repeat("?, ", len(pulls)), ", ")

     

       348
       348
       +
       	submissionsQuery := fmt.Sprintf(`

     

       349
       349
       +
       		select

     

       350
       350
       +
       			id, pull_id, round_number

     

       351
       351
       +
       		from

     

       352
       352
       +
       			pull_submissions

     

       353
       353
       +
       		where

     

       354
       354
       +
       			repo_at = ? and pull_id in (%s)

     

       355
       355
       +
       	`, inClause)

     

       356
       356
       +
       

     

       357
       357
       +
       	args := make([]any, len(pulls)+1)

     

       358
       358
       +
       	args[0] = repoAt.String()

     

       359
       359
       +
       	idx := 1

     

       360
       360
       +
       	for _, p := range pulls {

     

       361
       361
       +
       		args[idx] = p.PullId

     

       362
       362
       +
       		idx += 1

     

       363
       363
       +
       	}

     

       364
       364
       +
       	submissionsRows, err := e.Query(submissionsQuery, args...)

     

       365
       365
       +
       	if err != nil {

     

       366
       366
       +
       		return nil, err

     

       367
       367
       +
       	}

     

       368
       368
       +
       	defer submissionsRows.Close()

     

       369
       369
       +
       

     

       370
       370
       +
       	for submissionsRows.Next() {

     

       371
       371
       +
       		var s PullSubmission

     

       372
       372
       +
       		err := submissionsRows.Scan(

     

       373
       373
       +
       			&s.ID,

     

       374
       374
       +
       			&s.PullId,

     

       375
       375
       +
       			&s.RoundNumber,

     

       376
       376
       +
       		)

     

       377
       377
       +
       		if err != nil {

     

       378
       378
       +
       			return nil, err

     

       379
       379
       +
       		}

     

       380
       380
       +
       

     

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

     

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

     

       383
       383
       +
       			p.Submissions[s.RoundNumber] = &s

     

       384
       384
       +
       		}

     

       385
       385
       +
       	}

     

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

     

       348
       387
        
       		return nil, err

     

       349
       388
        
       	}

     

       350
       389
        
       

     

       351
       351
       -
       	return pulls, nil

     

       390
       390
       +
       	// get comment count on latest submission on each pull

     

       391
       391
       +
       	inClause = strings.TrimSuffix(strings.Repeat("?, ", len(pulls)), ", ")

     

       392
       392
       +
       	commentsQuery := fmt.Sprintf(`

     

       393
       393
       +
       		select

     

       394
       394
       +
       			count(id), pull_id

     

       395
       395
       +
       		from

     

       396
       396
       +
       			pull_comments

     

       397
       397
       +
       		where

     

       398
       398
       +
       			submission_id in (%s)

     

       399
       399
       +
       		group by

     

       400
       400
       +
       			submission_id

     

       401
       401
       +
       	`, inClause)

     

       402
       402
       +
       

     

       403
       403
       +
       	args = []any{}

     

       404
       404
       +
       	for _, p := range pulls {

     

       405
       405
       +
       		args = append(args, p.Submissions[p.LastRoundNumber()].ID)

     

       406
       406
       +
       	}

     

       407
       407
       +
       	commentsRows, err := e.Query(commentsQuery, args...)

     

       408
       408
       +
       	if err != nil {

     

       409
       409
       +
       		return nil, err

     

       410
       410
       +
       	}

     

       411
       411
       +
       	defer commentsRows.Close()

     

       412
       412
       +
       

     

       413
       413
       +
       	for commentsRows.Next() {

     

       414
       414
       +
       		var commentCount, pullId int

     

       415
       415
       +
       		err := commentsRows.Scan(

     

       416
       416
       +
       			&commentCount,

     

       417
       417
       +
       			&pullId,

     

       418
       418
       +
       		)

     

       419
       419
       +
       		if err != nil {

     

       420
       420
       +
       			return nil, err

     

       421
       421
       +
       		}

     

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

     

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

     

       424
       424
       +
       		}

     

       425
       425
       +
       	}

     

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

     

       427
       427
       +
       		return nil, err

     

       428
       428
       +
       	}

     

       429
       429
       +
       

     

       430
       430
       +
       	orderedByDate := []*Pull{}

     

       431
       431
       +
       	for _, p := range pulls {

     

       432
       432
       +
       		orderedByDate = append(orderedByDate, p)

     

       433
       433
       +
       	}

     

       434
       434
       +
       	sort.Slice(orderedByDate, func(i, j int) bool {

     

       435
       435
       +
       		return orderedByDate[i].Created.After(orderedByDate[j].Created)

     

       436
       436
       +
       	})

     

       437
       437
       +
       

     

       438
       438
       +
       	return orderedByDate, nil

     

       352
       439
        
       }

     

       353
       440
        
       

     

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

+1 -1

appview/pages/pages.go

···

       649
       649
        
       type RepoPullsParams struct {

     

       650
       650
        
       	LoggedInUser *auth.User

     

       651
       651
        
       	RepoInfo     RepoInfo

     

       652
       652
       -
       	Pulls        []db.Pull

     

       652
       652
       +
       	Pulls        []*db.Pull

     

       653
       653
        
       	Active       string

     

       654
       654
        
       	DidHandleMap map[string]string

     

       655
       655
        
       	FilteringBy  db.PullState

+19

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

···

       93
       93
        
                             </span>

     

       94
       94
        
                           </span>

     

       95
       95
        
                           {{ end }}

     

       96
       96
       +
                           <span class="before:content-['·']">

     

       97
       97
       +
                               {{ $latestRound := .LastRoundNumber }}

     

       98
       98
       +
                               {{ $lastSubmission := index .Submissions $latestRound }}

     

       99
       99
       +
                               round

     

       100
       100
       +
                               <span class="text-xs rounded bg-gray-100 dark:bg-gray-700 text-black dark:text-white font-mono px-2 mx-1/2 inline-flex items-center">

     

       101
       101
       +
                                 #{{ .LastRoundNumber }}

     

       102
       102
       +
                               </span>

     

       103
       103
       +
                               {{ $commentCount := len $lastSubmission.Comments }}

     

       104
       104
       +
                               {{ $s := "s" }}

     

       105
       105
       +
                               {{ if eq $commentCount 1 }}

     

       106
       106
       +
                                 {{ $s = "" }}

     

       107
       107
       +
                               {{ end }}

     

       108
       108
       +
       

     

       109
       109
       +
                               {{ if eq $commentCount 0 }}

     

       110
       110
       +
                                 awaiting comments

     

       111
       111
       +
                               {{ else }}

     

       112
       112
       +
                                 recieved {{ len $lastSubmission.Comments}} comment{{$s}}

     

       113
       113
       +
                               {{ end }}

     

       114
       114
       +
                           </span>

     

       96
       115
        
                       </p>

     

       97
       116
        
                   </div>

     

       98
       117
        
               {{ end }}