patch of draft: render backlinks · round #10 · pull #765 · tangled.org/core

+19 -1

appview/db/pulls.go

···

       93
       93
        
       		insert into pull_submissions (pull_at, round_number, patch, combined, source_rev)

     

       94
       94
        
       		values (?, ?, ?, ?, ?)

     

       95
       95
        
       	`, pull.AtUri(), 0, pull.Submissions[0].Patch, pull.Submissions[0].Combined, pull.Submissions[0].SourceRev)

     

       96
       96
       -
       	return err

     

       96
       96
       +
       	if err != nil {

     

       97
       97
       +
       		return err

     

       98
       98
       +
       	}

     

       99
       99
       +
       

     

       100
       100
       +
       	if err := putReferences(tx, pull.AtUri(), pull.References); err != nil {

     

       101
       101
       +
       		return fmt.Errorf("put reference_links: %w", err)

     

       102
       102
       +
       	}

     

       103
       103
       +
       

     

       104
       104
       +
       	return nil

     

       97
       105
        
       }

     

       98
       106
        
       

     

       99
       107
        
       func GetPullAt(e Execer, repoAt syntax.ATURI, pullId int) (syntax.ATURI, error) {

     
···

       266
       274
        
       		}

     

       267
       275
        
       	}

     

       268
       276
        
       

     

       277
       277
       +
       	allReferences, err := GetReferencesAll(e, FilterIn("from_at", pullAts))

     

       278
       278
       +
       	if err != nil {

     

       279
       279
       +
       		return nil, fmt.Errorf("failed to query reference_links: %w", err)

     

       280
       280
       +
       	}

     

       281
       281
       +
       	for pullAt, references := range allReferences {

     

       282
       282
       +
       		if pull, ok := pulls[pullAt]; ok {

     

       283
       283
       +
       			pull.References = references

     

       284
       284
       +
       		}

     

       285
       285
       +
       	}

     

       286
       286
       +
       

     

       269
       287
        
       	orderedByPullId := []*models.Pull{}

     

       270
       288
        
       	for _, p := range pulls {

     

       271
       289
        
       		orderedByPullId = append(orderedByPullId, p)

+212

appview/db/reference.go

···

       248
       248
        
       

     

       249
       249
        
       	return result, nil

     

       250
       250
        
       }

     

       251
       251
       +
       

     

       252
       252
       +
       func GetBacklinks(e Execer, target syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       253
       253
       +
       	rows, err := e.Query(

     

       254
       254
       +
       		`select from_at from reference_links

     

       255
       255
       +
       		where to_at = ?`,

     

       256
       256
       +
       		target,

     

       257
       257
       +
       	)

     

       258
       258
       +
       	if err != nil {

     

       259
       259
       +
       		return nil, fmt.Errorf("query backlinks: %w", err)

     

       260
       260
       +
       	}

     

       261
       261
       +
       	defer rows.Close()

     

       262
       262
       +
       

     

       263
       263
       +
       	var (

     

       264
       264
       +
       		backlinks    []models.RichReferenceLink

     

       265
       265
       +
       		backlinksMap = make(map[string][]syntax.ATURI)

     

       266
       266
       +
       	)

     

       267
       267
       +
       	for rows.Next() {

     

       268
       268
       +
       		var from syntax.ATURI

     

       269
       269
       +
       		if err := rows.Scan(&from); err != nil {

     

       270
       270
       +
       			return nil, fmt.Errorf("scan row: %w", err)

     

       271
       271
       +
       		}

     

       272
       272
       +
       		nsid := from.Collection().String()

     

       273
       273
       +
       		backlinksMap[nsid] = append(backlinksMap[nsid], from)

     

       274
       274
       +
       	}

     

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

     

       276
       276
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       277
       277
       +
       	}

     

       278
       278
       +
       

     

       279
       279
       +
       	var ls []models.RichReferenceLink

     

       280
       280
       +
       	ls, err = getIssueBacklinks(e, backlinksMap[tangled.RepoIssueNSID])

     

       281
       281
       +
       	if err != nil {

     

       282
       282
       +
       		return nil, fmt.Errorf("get issue backlinks: %w", err)

     

       283
       283
       +
       	}

     

       284
       284
       +
       	backlinks = append(backlinks, ls...)

     

       285
       285
       +
       	ls, err = getIssueCommentBacklinks(e, backlinksMap[tangled.RepoIssueCommentNSID])

     

       286
       286
       +
       	if err != nil {

     

       287
       287
       +
       		return nil, fmt.Errorf("get issue_comment backlinks: %w", err)

     

       288
       288
       +
       	}

     

       289
       289
       +
       	backlinks = append(backlinks, ls...)

     

       290
       290
       +
       	ls, err = getPullBacklinks(e, backlinksMap[tangled.RepoPullNSID])

     

       291
       291
       +
       	if err != nil {

     

       292
       292
       +
       		return nil, fmt.Errorf("get pull backlinks: %w", err)

     

       293
       293
       +
       	}

     

       294
       294
       +
       	backlinks = append(backlinks, ls...)

     

       295
       295
       +
       	ls, err = getPullCommentBacklinks(e, backlinksMap[tangled.RepoPullCommentNSID])

     

       296
       296
       +
       	if err != nil {

     

       297
       297
       +
       		return nil, fmt.Errorf("get pull_comment backlinks: %w", err)

     

       298
       298
       +
       	}

     

       299
       299
       +
       	backlinks = append(backlinks, ls...)

     

       300
       300
       +
       

     

       301
       301
       +
       	return backlinks, nil

     

       302
       302
       +
       }

     

       303
       303
       +
       

     

       304
       304
       +
       func getIssueBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       305
       305
       +
       	if len(aturis) == 0 {

     

       306
       306
       +
       		return nil, nil

     

       307
       307
       +
       	}

     

       308
       308
       +
       	vals := make([]string, len(aturis))

     

       309
       309
       +
       	args := make([]any, 0, len(aturis)*2)

     

       310
       310
       +
       	for i, aturi := range aturis {

     

       311
       311
       +
       		vals[i] = "(?, ?)"

     

       312
       312
       +
       		did := aturi.Authority().String()

     

       313
       313
       +
       		rkey := aturi.RecordKey().String()

     

       314
       314
       +
       		args = append(args, did, rkey)

     

       315
       315
       +
       	}

     

       316
       316
       +
       	rows, err := e.Query(

     

       317
       317
       +
       		fmt.Sprintf(

     

       318
       318
       +
       			`select r.did, r.name, i.issue_id, i.title, i.open

     

       319
       319
       +
       			from issues i

     

       320
       320
       +
       			join repos r

     

       321
       321
       +
       				on r.at_uri = i.repo_at

     

       322
       322
       +
       			where (i.did, i.rkey) in (%s)`,

     

       323
       323
       +
       			strings.Join(vals, ","),

     

       324
       324
       +
       		),

     

       325
       325
       +
       		args...,

     

       326
       326
       +
       	)

     

       327
       327
       +
       	if err != nil {

     

       328
       328
       +
       		return nil, err

     

       329
       329
       +
       	}

     

       330
       330
       +
       	defer rows.Close()

     

       331
       331
       +
       	var refLinks []models.RichReferenceLink

     

       332
       332
       +
       	for rows.Next() {

     

       333
       333
       +
       		var l models.RichReferenceLink

     

       334
       334
       +
       		l.Kind = models.RefKindIssue

     

       335
       335
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, &l.Title, &l.State); err != nil {

     

       336
       336
       +
       			return nil, err

     

       337
       337
       +
       		}

     

       338
       338
       +
       		refLinks = append(refLinks, l)

     

       339
       339
       +
       	}

     

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

     

       341
       341
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       342
       342
       +
       	}

     

       343
       343
       +
       	return refLinks, nil

     

       344
       344
       +
       }

     

       345
       345
       +
       

     

       346
       346
       +
       func getIssueCommentBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       347
       347
       +
       	if len(aturis) == 0 {

     

       348
       348
       +
       		return nil, nil

     

       349
       349
       +
       	}

     

       350
       350
       +
       	filter := FilterIn("c.at_uri", aturis)

     

       351
       351
       +
       	rows, err := e.Query(

     

       352
       352
       +
       		fmt.Sprintf(

     

       353
       353
       +
       			`select r.did, r.name, i.issue_id, c.id, i.title, i.open

     

       354
       354
       +
       			from issue_comments c

     

       355
       355
       +
       			join issues i

     

       356
       356
       +
       				on i.at_uri = c.issue_at

     

       357
       357
       +
       			join repos r

     

       358
       358
       +
       				on r.at_uri = i.repo_at

     

       359
       359
       +
       			where %s`,

     

       360
       360
       +
       			filter.Condition(),

     

       361
       361
       +
       		),

     

       362
       362
       +
       		filter.Arg()...,

     

       363
       363
       +
       	)

     

       364
       364
       +
       	if err != nil {

     

       365
       365
       +
       		return nil, err

     

       366
       366
       +
       	}

     

       367
       367
       +
       	defer rows.Close()

     

       368
       368
       +
       	var refLinks []models.RichReferenceLink

     

       369
       369
       +
       	for rows.Next() {

     

       370
       370
       +
       		var l models.RichReferenceLink

     

       371
       371
       +
       		l.Kind = models.RefKindIssue

     

       372
       372
       +
       		l.CommentId = new(int)

     

       373
       373
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, l.CommentId, &l.Title, &l.State); err != nil {

     

       374
       374
       +
       			return nil, err

     

       375
       375
       +
       		}

     

       376
       376
       +
       		refLinks = append(refLinks, l)

     

       377
       377
       +
       	}

     

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

     

       379
       379
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       380
       380
       +
       	}

     

       381
       381
       +
       	return refLinks, nil

     

       382
       382
       +
       }

     

       383
       383
       +
       

     

       384
       384
       +
       func getPullBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       385
       385
       +
       	if len(aturis) == 0 {

     

       386
       386
       +
       		return nil, nil

     

       387
       387
       +
       	}

     

       388
       388
       +
       	vals := make([]string, len(aturis))

     

       389
       389
       +
       	args := make([]any, 0, len(aturis)*2)

     

       390
       390
       +
       	for i, aturi := range aturis {

     

       391
       391
       +
       		vals[i] = "(?, ?)"

     

       392
       392
       +
       		did := aturi.Authority().String()

     

       393
       393
       +
       		rkey := aturi.RecordKey().String()

     

       394
       394
       +
       		args = append(args, did, rkey)

     

       395
       395
       +
       	}

     

       396
       396
       +
       	rows, err := e.Query(

     

       397
       397
       +
       		fmt.Sprintf(

     

       398
       398
       +
       			`select r.did, r.name, p.pull_id, p.title, p.state

     

       399
       399
       +
       			from pulls p

     

       400
       400
       +
       			join repos r

     

       401
       401
       +
       				on r.at_uri = p.repo_at

     

       402
       402
       +
       			where (p.owner_did, p.rkey) in (%s)`,

     

       403
       403
       +
       			strings.Join(vals, ","),

     

       404
       404
       +
       		),

     

       405
       405
       +
       		args...,

     

       406
       406
       +
       	)

     

       407
       407
       +
       	if err != nil {

     

       408
       408
       +
       		return nil, err

     

       409
       409
       +
       	}

     

       410
       410
       +
       	defer rows.Close()

     

       411
       411
       +
       	var refLinks []models.RichReferenceLink

     

       412
       412
       +
       	for rows.Next() {

     

       413
       413
       +
       		var l models.RichReferenceLink

     

       414
       414
       +
       		l.Kind = models.RefKindPull

     

       415
       415
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, &l.Title, &l.State); err != nil {

     

       416
       416
       +
       			return nil, err

     

       417
       417
       +
       		}

     

       418
       418
       +
       		refLinks = append(refLinks, l)

     

       419
       419
       +
       	}

     

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

     

       421
       421
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       422
       422
       +
       	}

     

       423
       423
       +
       	return refLinks, nil

     

       424
       424
       +
       }

     

       425
       425
       +
       

     

       426
       426
       +
       func getPullCommentBacklinks(e Execer, aturis []syntax.ATURI) ([]models.RichReferenceLink, error) {

     

       427
       427
       +
       	if len(aturis) == 0 {

     

       428
       428
       +
       		return nil, nil

     

       429
       429
       +
       	}

     

       430
       430
       +
       	filter := FilterIn("c.comment_at", aturis)

     

       431
       431
       +
       	rows, err := e.Query(

     

       432
       432
       +
       		fmt.Sprintf(

     

       433
       433
       +
       			`select r.did, r.name, p.pull_id, c.id, p.title, p.state

     

       434
       434
       +
       			from repos r

     

       435
       435
       +
       			join pulls p

     

       436
       436
       +
       				on r.at_uri = p.repo_at

     

       437
       437
       +
       			join pull_comments c

     

       438
       438
       +
       				on r.at_uri = c.repo_at and p.pull_id = c.pull_id

     

       439
       439
       +
       			where %s`,

     

       440
       440
       +
       			filter.Condition(),

     

       441
       441
       +
       		),

     

       442
       442
       +
       		filter.Arg()...,

     

       443
       443
       +
       	)

     

       444
       444
       +
       	if err != nil {

     

       445
       445
       +
       		return nil, err

     

       446
       446
       +
       	}

     

       447
       447
       +
       	defer rows.Close()

     

       448
       448
       +
       	var refLinks []models.RichReferenceLink

     

       449
       449
       +
       	for rows.Next() {

     

       450
       450
       +
       		var l models.RichReferenceLink

     

       451
       451
       +
       		l.Kind = models.RefKindPull

     

       452
       452
       +
       		l.CommentId = new(int)

     

       453
       453
       +
       		if err := rows.Scan(&l.Handle, &l.Repo, &l.SubjectId, l.CommentId, &l.Title, &l.State); err != nil {

     

       454
       454
       +
       			return nil, err

     

       455
       455
       +
       		}

     

       456
       456
       +
       		refLinks = append(refLinks, l)

     

       457
       457
       +
       	}

     

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

     

       459
       459
       +
       		return nil, fmt.Errorf("iterate rows: %w", err)

     

       460
       460
       +
       	}

     

       461
       461
       +
       	return refLinks, nil

     

       462
       462
       +
       }

+11

appview/issues/issues.go

···

       100
       100
        
       		userReactions = db.GetReactionStatusMap(rp.db, user.Did, issue.AtUri())

     

       101
       101
        
       	}

     

       102
       102
        
       

     

       103
       103
       +
       	backlinks, err := db.GetBacklinks(rp.db, issue.AtUri())

     

       104
       104
       +
       	if err != nil {

     

       105
       105
       +
       		l.Error("failed to fetch backlinks", "err", err)

     

       106
       106
       +
       		rp.pages.Error503(w)

     

       107
       107
       +
       		return

     

       108
       108
       +
       	}

     

       109
       109
       +
       

     

       103
       110
        
       	labelDefs, err := db.GetLabelDefinitions(

     

       104
       111
        
       		rp.db,

     

       105
       112
        
       		db.FilterIn("at_uri", f.Repo.Labels),

     
···

       121
       128
        
       		RepoInfo:             f.RepoInfo(user),

     

       122
       129
        
       		Issue:                issue,

     

       123
       130
        
       		CommentList:          issue.CommentList(),

     

       131
       131
       +
       		Backlinks:            backlinks,

     

       124
       132
        
       		OrderedReactionKinds: models.OrderedReactionKinds,

     

       125
       133
        
       		Reactions:            reactionMap,

     

       126
       134
        
       		UserReacted:          userReactions,

     
···

       156
       164
        
       		newIssue := issue

     

       157
       165
        
       		newIssue.Title = r.FormValue("title")

     

       158
       166
        
       		newIssue.Body = r.FormValue("body")

     

       167
       167
       +
       		newIssue.Mentions, newIssue.References = rp.refResolver.Resolve(r.Context(), newIssue.Body)

     

       159
       168
        
       

     

       160
       169
        
       		if err := rp.validator.ValidateIssue(newIssue); err != nil {

     

       161
       170
        
       			l.Error("validation error", "err", err)

     
···

       592
       601
        
       		newComment := comment

     

       593
       602
        
       		newComment.Body = newBody

     

       594
       603
        
       		newComment.Edited = &now

     

       604
       604
       +
       		newComment.Mentions, newComment.References = rp.refResolver.Resolve(r.Context(), newBody)

     

       605
       605
       +
       

     

       595
       606
        
       		record := newComment.AsRecord()

     

       596
       607
        
       

     

       597
       608
        
       		tx, err := rp.db.Begin()

+15 -3

appview/models/pull.go

···

       66
       66
        
       	TargetBranch string

     

       67
       67
        
       	State        PullState

     

       68
       68
        
       	Submissions  []*PullSubmission

     

       69
       69
       +
       	Mentions     []syntax.DID

     

       70
       70
       +
       	References   []syntax.ATURI

     

       69
       71
        
       

     

       70
       72
        
       	// stacking

     

       71
       73
        
       	StackId        string // nullable string

     
···

       92
       94
        
       			source.Repo = &s

     

       93
       95
        
       		}

     

       94
       96
        
       	}

     

       97
       97
       +
       	mentions := make([]string, len(p.Mentions))

     

       98
       98
       +
       	for i, did := range p.Mentions {

     

       99
       99
       +
       		mentions[i] = string(did)

     

       100
       100
       +
       	}

     

       101
       101
       +
       	references := make([]string, len(p.References))

     

       102
       102
       +
       	for i, uri := range p.References {

     

       103
       103
       +
       		references[i] = string(uri)

     

       104
       104
       +
       	}

     

       95
       105
        
       

     

       96
       106
        
       	record := tangled.RepoPull{

     

       97
       97
       -
       		Title:     p.Title,

     

       98
       98
       -
       		Body:      &p.Body,

     

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

     

       107
       107
       +
       		Title:      p.Title,

     

       108
       108
       +
       		Body:       &p.Body,

     

       109
       109
       +
       		Mentions:   mentions,

     

       110
       110
       +
       		References: references,

     

       111
       111
       +
       		CreatedAt:  p.Created.Format(time.RFC3339),

     

       100
       112
        
       		Target: &tangled.RepoPull_Target{

     

       101
       113
        
       			Repo:   p.RepoAt.String(),

     

       102
       114
        
       			Branch: p.TargetBranch,

+31

appview/models/reference.go

···

       1
       1
        
       package models

     

       2
       2
        
       

     

       3
       3
       +
       import "fmt"

     

       4
       4
       +
       

     

       3
       5
        
       type RefKind int

     

       4
       6
        
       

     

       5
       7
        
       const (

     
···

       7
       9
        
       	RefKindPull

     

       8
       10
        
       )

     

       9
       11
        
       

     

       12
       12
       +
       func (k RefKind) String() string {

     

       13
       13
       +
       	if k == RefKindIssue {

     

       14
       14
       +
       		return "issues"

     

       15
       15
       +
       	} else {

     

       16
       16
       +
       		return "pulls"

     

       17
       17
       +
       	}

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       10
       20
        
       // /@alice.com/cool-proj/issues/123

     

       11
       21
        
       // /@alice.com/cool-proj/issues/123#comment-321

     

       12
       22
        
       type ReferenceLink struct {

     
···

       16
       26
        
       	SubjectId int

     

       17
       27
        
       	CommentId *int

     

       18
       28
        
       }

     

       29
       29
       +
       

     

       30
       30
       +
       func (l ReferenceLink) String() string {

     

       31
       31
       +
       	comment := ""

     

       32
       32
       +
       	if l.CommentId != nil {

     

       33
       33
       +
       		comment = fmt.Sprintf("#comment-%d", *l.CommentId)

     

       34
       34
       +
       	}

     

       35
       35
       +
       	return fmt.Sprintf("/%s/%s/%s/%d%s",

     

       36
       36
       +
       		l.Handle,

     

       37
       37
       +
       		l.Repo,

     

       38
       38
       +
       		l.Kind.String(),

     

       39
       39
       +
       		l.SubjectId,

     

       40
       40
       +
       		comment,

     

       41
       41
       +
       	)

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       type RichReferenceLink struct {

     

       45
       45
       +
       	ReferenceLink

     

       46
       46
       +
       	Title string

     

       47
       47
       +
       	// reusing PullState for both issue & PR

     

       48
       48
       +
       	State PullState

     

       49
       49
       +
       }

appview/pages/pages.go

···

       936
       936
        
       	Active       string

     

       937
       937
        
       	Issue        *models.Issue

     

       938
       938
        
       	CommentList  []models.CommentListItem

     

       939
       939
       +
       	Backlinks    []models.RichReferenceLink

     

       939
       940
        
       	LabelDefs    map[string]*models.LabelDefinition

     

       940
       941
        
       

     

       941
       942
        
       	OrderedReactionKinds []models.ReactionKind

     
···

       1089
       1090
        
       	Pull               *models.Pull

     

       1090
       1091
        
       	Stack              models.Stack

     

       1091
       1092
        
       	AbandonedPulls     []*models.Pull

     

       1093
       1093
       +
       	Backlinks          []models.RichReferenceLink

     

       1092
       1094
        
       	BranchDeleteStatus *models.BranchDeleteStatus

     

       1093
       1095
        
       	MergeCheck         types.MergeCheckResponse

     

       1094
       1096
        
       	ResubmitCheck      ResubmitResult

+49

appview/pages/templates/repo/fragments/backlinks.html

···

       1
       1
       +
       {{ define "repo/fragments/backlinks" }}

     

       2
       2
       +
         {{ if .Backlinks }}

     

       3
       3
       +
         <div id="at-uri-panel" class="px-2 md:px-0">

     

       4
       4
       +
           <div>

     

       5
       5
       +
             <span class="text-sm py-1 font-bold text-gray-500 dark:text-gray-400">Referenced by</span>

     

       6
       6
       +
           </div>

     

       7
       7
       +
           <ul>

     

       8
       8
       +
             {{ range .Backlinks }}

     

       9
       9
       +
             <li>

     

       10
       10
       +
               {{ $repoOwner := resolve .Handle }}

     

       11
       11
       +
               {{ $repoName := .Repo }}

     

       12
       12
       +
               {{ $repoUrl := printf "%s/%s" $repoOwner $repoName }}

     

       13
       13
       +
               <div class="flex flex-col">

     

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

     

       15
       15
       +
                   {{ if .State.IsClosed }}

     

       16
       16
       +
                     <span class="text-gray-500 dark:text-gray-400">

     

       17
       17
       +
                       {{ i "ban" "w-4 h-4" }}

     

       18
       18
       +
                     </span>

     

       19
       19
       +
                   {{ else if eq .Kind.String "issues" }}

     

       20
       20
       +
                     <span class="text-green-600 dark:text-green-500">

     

       21
       21
       +
                       {{ i "circle-dot" "w-4 h-4" }}

     

       22
       22
       +
                     </span>

     

       23
       23
       +
                   {{ else if .State.IsOpen }}

     

       24
       24
       +
                     <span class="text-green-600 dark:text-green-500">

     

       25
       25
       +
                       {{ i "git-pull-request" "w-4 h-4" }}

     

       26
       26
       +
                     </span>

     

       27
       27
       +
                   {{ else if .State.IsMerged }}

     

       28
       28
       +
                     <span class="text-purple-600 dark:text-purple-500">

     

       29
       29
       +
                       {{ i "git-merge" "w-4 h-4" }}

     

       30
       30
       +
                     </span>

     

       31
       31
       +
                   {{ else }}

     

       32
       32
       +
                     <span class="text-gray-600 dark:text-gray-300">

     

       33
       33
       +
                       {{ i "git-pull-request-closed" "w-4 h-4" }}

     

       34
       34
       +
                     </span>

     

       35
       35
       +
                   {{ end }}

     

       36
       36
       +
                   <a href="{{ . }}"><span class="text-gray-500 dark:text-gray-400">#{{ .SubjectId }}</span> {{ .Title }}</a>

     

       37
       37
       +
                 </div>

     

       38
       38
       +
                 {{ if not (eq $.RepoInfo.FullName $repoUrl) }}

     

       39
       39
       +
                 <div>

     

       40
       40
       +
                   <span>on <a href="/{{ $repoUrl }}">{{ $repoUrl }}</a></span>

     

       41
       41
       +
                 </div>

     

       42
       42
       +
                 {{ end }}

     

       43
       43
       +
               </div>

     

       44
       44
       +
             </li>

     

       45
       45
       +
             {{ end }}

     

       46
       46
       +
           </ul>

     

       47
       47
       +
         </div>

     

       48
       48
       +
         {{ end }}

     

       49
       49
       +
       {{ end }}

appview/pages/templates/repo/issues/issue.html

···

       20
       20
        
                     "Subject" $.Issue.AtUri

     

       21
       21
        
                     "State" $.Issue.Labels) }}

     

       22
       22
        
             {{ template "repo/fragments/participants" $.Issue.Participants }}

     

       23
       23
       +
             {{ template "repo/fragments/backlinks"

     

       24
       24
       +
               (dict "RepoInfo" $.RepoInfo

     

       25
       25
       +
                     "Backlinks" $.Backlinks) }}

     

       23
       26
        
             {{ template "repo/fragments/externalLinkPanel" $.Issue.AtUri }}

     

       24
       27
        
           </div>

     

       25
       28
        
         </div>

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

···

       21
       21
        
                     "Subject" $.Pull.AtUri

     

       22
       22
        
                     "State" $.Pull.Labels) }}

     

       23
       23
        
             {{ template "repo/fragments/participants" $.Pull.Participants }}

     

       24
       24
       +
             {{ template "repo/fragments/backlinks"

     

       25
       25
       +
               (dict "RepoInfo" $.RepoInfo

     

       26
       26
       +
                     "Backlinks" $.Backlinks) }}

     

       24
       27
        
             {{ template "repo/fragments/externalLinkPanel" $.Pull.AtUri }}

     

       25
       28
        
           </div>

     

       26
       29
        
         </div>

+20 -3

appview/pulls/pulls.go

···

       1
       1
        
       package pulls

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"context"

     

       4
       5
        
       	"database/sql"

     

       5
       6
        
       	"encoding/json"

     

       6
       7
        
       	"errors"

     
···

       154
       155
        
       		return

     

       155
       156
        
       	}

     

       156
       157
        
       

     

       158
       158
       +
       	backlinks, err := db.GetBacklinks(s.db, pull.AtUri())

     

       159
       159
       +
       	if err != nil {

     

       160
       160
       +
       		log.Println("failed to get pull backlinks", err)

     

       161
       161
       +
       		s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.")

     

       162
       162
       +
       		return

     

       163
       163
       +
       	}

     

       164
       164
       +
       

     

       157
       165
        
       	// can be nil  if this pull is not stacked

     

       158
       166
        
       	stack, _ := r.Context().Value("stack").(models.Stack)

     

       159
       167
        
       	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)

     
···

       230
       238
        
       		Pull:               pull,

     

       231
       239
        
       		Stack:              stack,

     

       232
       240
        
       		AbandonedPulls:     abandonedPulls,

     

       241
       241
       +
       		Backlinks:          backlinks,

     

       233
       242
        
       		BranchDeleteStatus: branchDeleteStatus,

     

       234
       243
        
       		MergeCheck:         mergeCheckResponse,

     

       235
       244
        
       		ResubmitCheck:      resubmitResult,

     
···

       1209
       1218
        
       		}

     

       1210
       1219
        
       	}

     

       1211
       1220
        
       

     

       1221
       1221
       +
       	mentions, references := s.refResolver.Resolve(r.Context(), body)

     

       1222
       1222
       +
       

     

       1212
       1223
        
       	rkey := tid.TID()

     

       1213
       1224
        
       	initialSubmission := models.PullSubmission{

     

       1214
       1225
        
       		Patch:     patch,

     
···

       1222
       1233
        
       		OwnerDid:     user.Did,

     

       1223
       1234
        
       		RepoAt:       f.RepoAt(),

     

       1224
       1235
        
       		Rkey:         rkey,

     

       1236
       1236
       +
       		Mentions:     mentions,

     

       1237
       1237
       +
       		References:   references,

     

       1225
       1238
        
       		Submissions: []*models.PullSubmission{

     

       1226
       1239
        
       			&initialSubmission,

     

       1227
       1240
        
       		},

     
···

       1309
       1322
        
       

     

       1310
       1323
        
       	// build a stack out of this patch

     

       1311
       1324
        
       	stackId := uuid.New()

     

       1312
       1312
       -
       	stack, err := newStack(f, user, targetBranch, patch, pullSource, stackId.String())

     

       1325
       1325
       +
       	stack, err := s.newStack(r.Context(), f, user, targetBranch, patch, pullSource, stackId.String())

     

       1313
       1326
        
       	if err != nil {

     

       1314
       1327
        
       		log.Println("failed to create stack", err)

     

       1315
       1328
        
       		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))

     
···

       1935
       1948
        
       	targetBranch := pull.TargetBranch

     

       1936
       1949
        
       

     

       1937
       1950
        
       	origStack, _ := r.Context().Value("stack").(models.Stack)

     

       1938
       1938
       -
       	newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)

     

       1951
       1951
       +
       	newStack, err := s.newStack(r.Context(), f, user, targetBranch, patch, pull.PullSource, stackId)

     

       1939
       1952
        
       	if err != nil {

     

       1940
       1953
        
       		log.Println("failed to create resubmitted stack", err)

     

       1941
       1954
        
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     
···

       2379
       2392
        
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2380
       2393
        
       }

     

       2381
       2394
        
       

     

       2382
       2382
       -
       func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       2395
       2395
       +
       func (s *Pulls) newStack(ctx context.Context, f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) {

     

       2383
       2396
        
       	formatPatches, err := patchutil.ExtractPatches(patch)

     

       2384
       2397
        
       	if err != nil {

     

       2385
       2398
        
       		return nil, fmt.Errorf("Failed to extract patches: %v", err)

     
···

       2404
       2417
        
       		body := fp.Body

     

       2405
       2418
        
       		rkey := tid.TID()

     

       2406
       2419
        
       

     

       2420
       2420
       +
       		mentions, references := s.refResolver.Resolve(ctx, body)

     

       2421
       2421
       +
       

     

       2407
       2422
        
       		initialSubmission := models.PullSubmission{

     

       2408
       2423
        
       			Patch:     fp.Raw,

     

       2409
       2424
        
       			SourceRev: fp.SHA,

     
···

       2416
       2431
        
       			OwnerDid:     user.Did,

     

       2417
       2432
        
       			RepoAt:       f.RepoAt(),

     

       2418
       2433
        
       			Rkey:         rkey,

     

       2434
       2434
       +
       			Mentions:     mentions,

     

       2435
       2435
       +
       			References:   references,

     

       2419
       2436
        
       			Submissions: []*models.PullSubmission{

     

       2420
       2437
        
       				&initialSubmission,

     

       2421
       2438
        
       			},