patch of appview: replace `IssueComment` to `Comment` · round #0 · pull #866 · tangled.org/core

+6 -185

appview/db/issues.go

···

       99
       99
        
       }

     

       100
       100
        
       

     

       101
       101
        
       func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]models.Issue, error) {

     

       102
       102
       -
       	issueMap := make(map[string]*models.Issue) // at-uri -> issue

     

       102
       102
       +
       	issueMap := make(map[syntax.ATURI]*models.Issue) // at-uri -> issue

     

       103
       103
        
       

     

       104
       104
        
       	var conditions []string

     

       105
       105
        
       	var args []any

     
···

       195
       195
        
       			}

     

       196
       196
        
       		}

     

       197
       197
        
       

     

       198
       198
       -
       		atUri := issue.AtUri().String()

     

       199
       199
       -
       		issueMap[atUri] = &issue

     

       198
       198
       +
       		issueMap[issue.AtUri()] = &issue

     

       200
       199
        
       	}

     

       201
       200
        
       

     

       202
       201
        
       	// collect reverse repos

     
···

       228
       227
        
       	// collect comments

     

       229
       228
        
       	issueAts := slices.Collect(maps.Keys(issueMap))

     

       230
       229
        
       

     

       231
       231
       -
       	comments, err := GetIssueComments(e, FilterIn("issue_at", issueAts))

     

       230
       230
       +
       	comments, err := GetComments(e, FilterIn("subject_at", issueAts))

     

       232
       231
        
       	if err != nil {

     

       233
       232
        
       		return nil, fmt.Errorf("failed to query comments: %w", err)

     

       234
       233
        
       	}

     

       235
       234
        
       	for i := range comments {

     

       236
       236
       -
       		issueAt := comments[i].IssueAt

     

       235
       235
       +
       		issueAt := comments[i].Subject

     

       237
       236
        
       		if issue, ok := issueMap[issueAt]; ok {

     

       238
       237
        
       			issue.Comments = append(issue.Comments, comments[i])

     

       239
       238
        
       		}

     
···

       245
       244
        
       		return nil, fmt.Errorf("failed to query labels: %w", err)

     

       246
       245
        
       	}

     

       247
       246
        
       	for issueAt, labels := range allLabels {

     

       248
       248
       -
       		if issue, ok := issueMap[issueAt.String()]; ok {

     

       247
       247
       +
       		if issue, ok := issueMap[issueAt]; ok {

     

       249
       248
        
       			issue.Labels = labels

     

       250
       249
        
       		}

     

       251
       250
        
       	}

     
···

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

     

       257
       256
        
       	}

     

       258
       257
        
       	for issueAt, references := range allReferencs {

     

       259
       259
       -
       		if issue, ok := issueMap[issueAt.String()]; ok {

     

       258
       258
       +
       		if issue, ok := issueMap[issueAt]; ok {

     

       260
       259
        
       			issue.References = references

     

       261
       260
        
       		}

     

       262
       261
        
       	}

     
···

       350
       349
        
       	return ids, nil

     

       351
       350
        
       }

     

       352
       351
        
       

     

       353
       353
       -
       func AddIssueComment(tx *sql.Tx, c models.IssueComment) (int64, error) {

     

       354
       354
       -
       	result, err := tx.Exec(

     

       355
       355
       -
       		`insert into issue_comments (

     

       356
       356
       -
       			did,

     

       357
       357
       -
       			rkey,

     

       358
       358
       -
       			issue_at,

     

       359
       359
       -
       			body,

     

       360
       360
       -
       			reply_to,

     

       361
       361
       -
       			created,

     

       362
       362
       -
       			edited

     

       363
       363
       -
       		)

     

       364
       364
       -
       		values (?, ?, ?, ?, ?, ?, null)

     

       365
       365
       -
       		on conflict(did, rkey) do update set

     

       366
       366
       -
       			issue_at = excluded.issue_at,

     

       367
       367
       -
       			body = excluded.body,

     

       368
       368
       -
       			edited = case

     

       369
       369
       -
       				when

     

       370
       370
       -
       					issue_comments.issue_at != excluded.issue_at

     

       371
       371
       -
       					or issue_comments.body != excluded.body

     

       372
       372
       -
       					or issue_comments.reply_to != excluded.reply_to

     

       373
       373
       -
       				then ?

     

       374
       374
       -
       				else issue_comments.edited

     

       375
       375
       -
       			end`,

     

       376
       376
       -
       		c.Did,

     

       377
       377
       -
       		c.Rkey,

     

       378
       378
       -
       		c.IssueAt,

     

       379
       379
       -
       		c.Body,

     

       380
       380
       -
       		c.ReplyTo,

     

       381
       381
       -
       		c.Created.Format(time.RFC3339),

     

       382
       382
       -
       		time.Now().Format(time.RFC3339),

     

       383
       383
       -
       	)

     

       384
       384
       -
       	if err != nil {

     

       385
       385
       -
       		return 0, err

     

       386
       386
       -
       	}

     

       387
       387
       -
       

     

       388
       388
       -
       	id, err := result.LastInsertId()

     

       389
       389
       -
       	if err != nil {

     

       390
       390
       -
       		return 0, err

     

       391
       391
       -
       	}

     

       392
       392
       -
       

     

       393
       393
       -
       	if err := putReferences(tx, c.AtUri(), c.References); err != nil {

     

       394
       394
       -
       		return 0, fmt.Errorf("put reference_links: %w", err)

     

       395
       395
       -
       	}

     

       396
       396
       -
       

     

       397
       397
       -
       	return id, nil

     

       398
       398
       -
       }

     

       399
       399
       -
       

     

       400
       400
       -
       func DeleteIssueComments(e Execer, filters ...filter) error {

     

       401
       401
       -
       	var conditions []string

     

       402
       402
       -
       	var args []any

     

       403
       403
       -
       	for _, filter := range filters {

     

       404
       404
       -
       		conditions = append(conditions, filter.Condition())

     

       405
       405
       -
       		args = append(args, filter.Arg()...)

     

       406
       406
       -
       	}

     

       407
       407
       -
       

     

       408
       408
       -
       	whereClause := ""

     

       409
       409
       -
       	if conditions != nil {

     

       410
       410
       -
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       411
       411
       -
       	}

     

       412
       412
       -
       

     

       413
       413
       -
       	query := fmt.Sprintf(`update issue_comments set body = "", deleted = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now') %s`, whereClause)

     

       414
       414
       -
       

     

       415
       415
       -
       	_, err := e.Exec(query, args...)

     

       416
       416
       -
       	return err

     

       417
       417
       -
       }

     

       418
       418
       -
       

     

       419
       419
       -
       func GetIssueComments(e Execer, filters ...filter) ([]models.IssueComment, error) {

     

       420
       420
       -
       	commentMap := make(map[string]*models.IssueComment)

     

       421
       421
       -
       

     

       422
       422
       -
       	var conditions []string

     

       423
       423
       -
       	var args []any

     

       424
       424
       -
       	for _, filter := range filters {

     

       425
       425
       -
       		conditions = append(conditions, filter.Condition())

     

       426
       426
       -
       		args = append(args, filter.Arg()...)

     

       427
       427
       -
       	}

     

       428
       428
       -
       

     

       429
       429
       -
       	whereClause := ""

     

       430
       430
       -
       	if conditions != nil {

     

       431
       431
       -
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       432
       432
       -
       	}

     

       433
       433
       -
       

     

       434
       434
       -
       	query := fmt.Sprintf(`

     

       435
       435
       -
       		select

     

       436
       436
       -
       			id,

     

       437
       437
       -
       			did,

     

       438
       438
       -
       			rkey,

     

       439
       439
       -
       			issue_at,

     

       440
       440
       -
       			reply_to,

     

       441
       441
       -
       			body,

     

       442
       442
       -
       			created,

     

       443
       443
       -
       			edited,

     

       444
       444
       -
       			deleted

     

       445
       445
       -
       		from

     

       446
       446
       -
       			issue_comments

     

       447
       447
       -
       		%s

     

       448
       448
       -
       		`, whereClause)

     

       449
       449
       -
       

     

       450
       450
       -
       	rows, err := e.Query(query, args...)

     

       451
       451
       -
       	if err != nil {

     

       452
       452
       -
       		return nil, err

     

       453
       453
       -
       	}

     

       454
       454
       -
       

     

       455
       455
       -
       	for rows.Next() {

     

       456
       456
       -
       		var comment models.IssueComment

     

       457
       457
       -
       		var created string

     

       458
       458
       -
       		var rkey, edited, deleted, replyTo sql.Null[string]

     

       459
       459
       -
       		err := rows.Scan(

     

       460
       460
       -
       			&comment.Id,

     

       461
       461
       -
       			&comment.Did,

     

       462
       462
       -
       			&rkey,

     

       463
       463
       -
       			&comment.IssueAt,

     

       464
       464
       -
       			&replyTo,

     

       465
       465
       -
       			&comment.Body,

     

       466
       466
       -
       			&created,

     

       467
       467
       -
       			&edited,

     

       468
       468
       -
       			&deleted,

     

       469
       469
       -
       		)

     

       470
       470
       -
       		if err != nil {

     

       471
       471
       -
       			return nil, err

     

       472
       472
       -
       		}

     

       473
       473
       -
       

     

       474
       474
       -
       		// this is a remnant from old times, newer comments always have rkey

     

       475
       475
       -
       		if rkey.Valid {

     

       476
       476
       -
       			comment.Rkey = rkey.V

     

       477
       477
       -
       		}

     

       478
       478
       -
       

     

       479
       479
       -
       		if t, err := time.Parse(time.RFC3339, created); err == nil {

     

       480
       480
       -
       			comment.Created = t

     

       481
       481
       -
       		}

     

       482
       482
       -
       

     

       483
       483
       -
       		if edited.Valid {

     

       484
       484
       -
       			if t, err := time.Parse(time.RFC3339, edited.V); err == nil {

     

       485
       485
       -
       				comment.Edited = &t

     

       486
       486
       -
       			}

     

       487
       487
       -
       		}

     

       488
       488
       -
       

     

       489
       489
       -
       		if deleted.Valid {

     

       490
       490
       -
       			if t, err := time.Parse(time.RFC3339, deleted.V); err == nil {

     

       491
       491
       -
       				comment.Deleted = &t

     

       492
       492
       -
       			}

     

       493
       493
       -
       		}

     

       494
       494
       -
       

     

       495
       495
       -
       		if replyTo.Valid {

     

       496
       496
       -
       			comment.ReplyTo = &replyTo.V

     

       497
       497
       -
       		}

     

       498
       498
       -
       

     

       499
       499
       -
       		atUri := comment.AtUri().String()

     

       500
       500
       -
       		commentMap[atUri] = &comment

     

       501
       501
       -
       	}

     

       502
       502
       -
       

     

       503
       503
       -
       	if err = rows.Err(); err != nil {

     

       504
       504
       -
       		return nil, err

     

       505
       505
       -
       	}

     

       506
       506
       -
       

     

       507
       507
       -
       	// collect references for each comments

     

       508
       508
       -
       	commentAts := slices.Collect(maps.Keys(commentMap))

     

       509
       509
       -
       	allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts))

     

       510
       510
       -
       	if err != nil {

     

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

     

       512
       512
       -
       	}

     

       513
       513
       -
       	for commentAt, references := range allReferencs {

     

       514
       514
       -
       		if comment, ok := commentMap[commentAt.String()]; ok {

     

       515
       515
       -
       			comment.References = references

     

       516
       516
       -
       		}

     

       517
       517
       -
       	}

     

       518
       518
       -
       

     

       519
       519
       -
       	var comments []models.IssueComment

     

       520
       520
       -
       	for _, c := range commentMap {

     

       521
       521
       -
       		comments = append(comments, *c)

     

       522
       522
       -
       	}

     

       523
       523
       -
       

     

       524
       524
       -
       	sort.Slice(comments, func(i, j int) bool {

     

       525
       525
       -
       		return comments[i].Created.After(comments[j].Created)

     

       526
       526
       -
       	})

     

       527
       527
       -
       

     

       528
       528
       -
       	return comments, nil

     

       529
       529
       -
       }

     

       530
       530
       -
       

     

       531
       352
        
       func DeleteIssues(tx *sql.Tx, did, rkey string) error {

     

       532
       353
        
       	_, err := tx.Exec(

     

       533
       354
        
       		`delete from issues

+13 -24

appview/db/reference.go

···

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

     

       11
       11
        
       )

     

       12
       12
        
       

     

       13
       13
       -
       // ValidateReferenceLinks resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs.

     

       13
       13
       +
       // ValidateReferenceLinks resolves refLinks to Issue/PR/Comment ATURIs.

     

       14
       14
        
       // It will ignore missing refLinks.

     

       15
       15
        
       func ValidateReferenceLinks(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       16
       16
        
       	var (

     
···

       52
       52
        
       			values %s

     

       53
       53
        
       		)

     

       54
       54
        
       		select

     

       55
       55
       -
       			i.did, i.rkey,

     

       56
       56
       -
       			c.did, c.rkey

     

       55
       55
       +
       			i.at_uri, c.at_uri

     

       57
       56
        
       		from input inp

     

       58
       57
        
       		join repos r

     

       59
       58
        
       			on r.did = inp.owner_did

     
···

       61
       60
        
       		join issues i

     

       62
       61
        
       			on i.repo_at = r.at_uri

     

       63
       62
        
       				and i.issue_id = inp.issue_id

     

       64
       64
       -
       		left join issue_comments c

     

       63
       63
       +
       		left join comments c

     

       65
       64
        
       			on inp.comment_id is not null

     

       66
       66
       -
       				and c.issue_at = i.at_uri

     

       65
       65
       +
       				and c.subject_at = i.at_uri

     

       67
       66
        
       				and c.id = inp.comment_id

     

       68
       67
        
       		`,

     

       69
       68
        
       		strings.Join(vals, ","),

     
···

       78
       77
        
       

     

       79
       78
        
       	for rows.Next() {

     

       80
       79
        
       		// Scan rows

     

       81
       81
       -
       		var issueOwner, issueRkey string

     

       82
       82
       -
       		var commentOwner, commentRkey sql.NullString

     

       80
       80
       +
       		var issueUri string

     

       81
       81
       +
       		var commentUri sql.NullString

     

       83
       82
        
       		var uri syntax.ATURI

     

       84
       84
       -
       		if err := rows.Scan(&issueOwner, &issueRkey, &commentOwner, &commentRkey); err != nil {

     

       83
       83
       +
       		if err := rows.Scan(&issueUri, &commentUri); err != nil {

     

       85
       84
        
       			return nil, err

     

       86
       85
        
       		}

     

       87
       87
       -
       		if commentOwner.Valid && commentRkey.Valid {

     

       88
       88
       -
       			uri = syntax.ATURI(fmt.Sprintf(

     

       89
       89
       -
       				"at://%s/%s/%s",

     

       90
       90
       -
       				commentOwner.String,

     

       91
       91
       -
       				tangled.RepoIssueCommentNSID,

     

       92
       92
       -
       				commentRkey.String,

     

       93
       93
       -
       			))

     

       86
       86
       +
       		if commentUri.Valid {

     

       87
       87
       +
       			uri = syntax.ATURI(commentUri.String)

     

       94
       88
        
       		} else {

     

       95
       95
       -
       			uri = syntax.ATURI(fmt.Sprintf(

     

       96
       96
       -
       				"at://%s/%s/%s",

     

       97
       97
       -
       				issueOwner,

     

       98
       98
       -
       				tangled.RepoIssueNSID,

     

       99
       99
       -
       				issueRkey,

     

       100
       100
       -
       			))

     

       89
       89
       +
       			uri = syntax.ATURI(issueUri)

     

       101
       90
        
       		}

     

       102
       91
        
       		uris = append(uris, uri)

     

       103
       92
        
       	}

     
···

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

     

       282
       271
        
       	}

     

       283
       272
        
       	backlinks = append(backlinks, ls...)

     

       284
       284
       -
       	ls, err = getIssueCommentBacklinks(e, backlinksMap[tangled.RepoIssueCommentNSID])

     

       273
       273
       +
       	ls, err = getIssueCommentBacklinks(e, backlinksMap[tangled.CommentNSID])

     

       285
       274
        
       	if err != nil {

     

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

     

       287
       276
        
       	}

     
···

       350
       339
        
       	rows, err := e.Query(

     

       351
       340
        
       		fmt.Sprintf(

     

       352
       341
        
       			`select r.did, r.name, i.issue_id, c.id, i.title, i.open

     

       353
       353
       -
       			from issue_comments c

     

       342
       342
       +
       			from comments c

     

       354
       343
        
       			join issues i

     

       355
       355
       -
       				on i.at_uri = c.issue_at

     

       344
       344
       +
       				on i.at_uri = c.subject_at

     

       356
       345
        
       			join repos r

     

       357
       346
        
       				on r.at_uri = i.repo_at

     

       358
       347
        
       			where %s`,

+19 -11

appview/ingester.go

···

       78
       78
        
       				err = i.ingestString(e)

     

       79
       79
        
       			case tangled.RepoIssueNSID:

     

       80
       80
        
       				err = i.ingestIssue(ctx, e)

     

       81
       81
       -
       			case tangled.RepoIssueCommentNSID:

     

       82
       82
       -
       				err = i.ingestIssueComment(e)

     

       81
       81
       +
       			case tangled.CommentNSID:

     

       82
       82
       +
       				err = i.ingestComment(e)

     

       83
       83
        
       			case tangled.LabelDefinitionNSID:

     

       84
       84
        
       				err = i.ingestLabelDefinition(e)

     

       85
       85
        
       			case tangled.LabelOpNSID:

     
···

       867
       867
        
       	return nil

     

       868
       868
        
       }

     

       869
       869
        
       

     

       870
       870
       -
       func (i *Ingester) ingestIssueComment(e *jmodels.Event) error {

     

       870
       870
       +
       func (i *Ingester) ingestComment(e *jmodels.Event) error {

     

       871
       871
        
       	did := e.Did

     

       872
       872
        
       	rkey := e.Commit.RKey

     

       873
       873
        
       

     

       874
       874
        
       	var err error

     

       875
       875
        
       

     

       876
       876
       -
       	l := i.Logger.With("handler", "ingestIssueComment", "nsid", e.Commit.Collection, "did", did, "rkey", rkey)

     

       876
       876
       +
       	l := i.Logger.With("handler", "ingestComment", "nsid", e.Commit.Collection, "did", did, "rkey", rkey)

     

       877
       877
        
       	l.Info("ingesting record")

     

       878
       878
        
       

     

       879
       879
        
       	ddb, ok := i.Db.Execer.(*db.DB)

     
···

       884
       884
        
       	switch e.Commit.Operation {

     

       885
       885
        
       	case jmodels.CommitOperationCreate, jmodels.CommitOperationUpdate:

     

       886
       886
        
       		raw := json.RawMessage(e.Commit.Record)

     

       887
       887
       -
       		record := tangled.RepoIssueComment{}

     

       887
       887
       +
       		record := tangled.Comment{}

     

       888
       888
        
       		err = json.Unmarshal(raw, &record)

     

       889
       889
        
       		if err != nil {

     

       890
       890
        
       			return fmt.Errorf("invalid record: %w", err)

     

       891
       891
        
       		}

     

       892
       892
        
       

     

       893
       893
       -
       		comment, err := models.IssueCommentFromRecord(did, rkey, record)

     

       893
       893
       +
       		comment, err := models.CommentFromRecord(did, rkey, record)

     

       894
       894
        
       		if err != nil {

     

       895
       895
        
       			return fmt.Errorf("failed to parse comment from record: %w", err)

     

       896
       896
        
       		}

     

       897
       897
        
       

     

       898
       898
       -
       		if err := i.Validator.ValidateIssueComment(comment); err != nil {

     

       898
       898
       +
       		// TODO: ingest pull comments

     

       899
       899
       +
       		// we aren't ingesting pull comments yet because pull itself isn't fully atprotated.

     

       900
       900
       +
       		// so we cannot know which round this comment is pointing to

     

       901
       901
       +
       		if comment.Subject.Collection().String() == tangled.RepoPullNSID {

     

       902
       902
       +
       			l.Info("skip ingesting pull comments")

     

       903
       903
       +
       			return nil

     

       904
       904
       +
       		}

     

       905
       905
       +
       

     

       906
       906
       +
       		if err := comment.Validate(); err != nil {

     

       899
       907
        
       			return fmt.Errorf("failed to validate comment: %w", err)

     

       900
       908
        
       		}

     

       901
       909
        
       

     
···

       905
       913
        
       		}

     

       906
       914
        
       		defer tx.Rollback()

     

       907
       915
        
       

     

       908
       908
       -
       		_, err = db.AddIssueComment(tx, *comment)

     

       916
       916
       +
       		err = db.PutComment(tx, comment)

     

       909
       917
        
       		if err != nil {

     

       910
       910
       -
       			return fmt.Errorf("failed to create issue comment: %w", err)

     

       918
       918
       +
       			return fmt.Errorf("failed to create comment: %w", err)

     

       911
       919
        
       		}

     

       912
       920
        
       

     

       913
       921
        
       		return tx.Commit()

     

       914
       922
        
       

     

       915
       923
        
       	case jmodels.CommitOperationDelete:

     

       916
       916
       -
       		if err := db.DeleteIssueComments(

     

       924
       924
       +
       		if err := db.DeleteComments(

     

       917
       925
        
       			ddb,

     

       918
       926
        
       			db.FilterEq("did", did),

     

       919
       927
        
       			db.FilterEq("rkey", rkey),

     

       920
       928
        
       		); err != nil {

     

       921
       921
       -
       			return fmt.Errorf("failed to delete issue comment record: %w", err)

     

       929
       929
       +
       			return fmt.Errorf("failed to delete comment record: %w", err)

     

       922
       930
        
       		}

     

       923
       931
        
       

     

       924
       932
        
       		return nil

+30 -28

appview/issues/issues.go

···

       402
       402
        
       

     

       403
       403
        
       	body := r.FormValue("body")

     

       404
       404
        
       	if body == "" {

     

       405
       405
       -
       		rp.pages.Notice(w, "issue", "Body is required")

     

       405
       405
       +
       		rp.pages.Notice(w, "issue-comment", "Body is required")

     

       406
       406
        
       		return

     

       407
       407
        
       	}

     

       408
       408
        
       

     

       409
       409
       -
       	replyToUri := r.FormValue("reply-to")

     

       410
       410
       -
       	var replyTo *string

     

       411
       411
       -
       	if replyToUri != "" {

     

       412
       412
       -
       		replyTo = &replyToUri

     

       409
       409
       +
       	var replyTo *syntax.ATURI

     

       410
       410
       +
       	replyToRaw := r.FormValue("reply-to")

     

       411
       411
       +
       	if replyToRaw != "" {

     

       412
       412
       +
       		aturi, err := syntax.ParseATURI(r.FormValue("reply-to"))

     

       413
       413
       +
       		if err != nil {

     

       414
       414
       +
       			rp.pages.Notice(w, "issue-comment", "reply-to should be valid AT-URI")

     

       415
       415
       +
       			return

     

       416
       416
       +
       		}

     

       417
       417
       +
       		replyTo = &aturi

     

       413
       418
        
       	}

     

       414
       419
        
       

     

       415
       420
        
       	mentions, references := rp.refResolver.Resolve(r.Context(), body)

     

       416
       421
        
       

     

       417
       417
       -
       	comment := models.IssueComment{

     

       418
       418
       -
       		Did:        user.Did,

     

       422
       422
       +
       	comment := models.Comment{

     

       423
       423
       +
       		Did:        syntax.DID(user.Did),

     

       419
       424
        
       		Rkey:       tid.TID(),

     

       420
       420
       -
       		IssueAt:    issue.AtUri().String(),

     

       425
       425
       +
       		Subject:    issue.AtUri(),

     

       421
       426
        
       		ReplyTo:    replyTo,

     

       422
       427
        
       		Body:       body,

     

       423
       428
        
       		Created:    time.Now(),

     

       424
       429
        
       		Mentions:   mentions,

     

       425
       430
        
       		References: references,

     

       426
       431
        
       	}

     

       427
       427
       -
       	if err = rp.validator.ValidateIssueComment(&comment); err != nil {

     

       432
       432
       +
       	if err = comment.Validate(); err != nil {

     

       428
       433
        
       		l.Error("failed to validate comment", "err", err)

     

       429
       434
        
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment.")

     

       430
       435
        
       		return

     
···

       440
       445
        
       

     

       441
       446
        
       	// create a record first

     

       442
       447
        
       	resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       443
       443
       -
       		Collection: tangled.RepoIssueCommentNSID,

     

       444
       444
       -
       		Repo:       comment.Did,

     

       448
       448
       +
       		Collection: tangled.CommentNSID,

     

       449
       449
       +
       		Repo:       user.Did,

     

       445
       450
        
       		Rkey:       comment.Rkey,

     

       446
       451
        
       		Record: &lexutil.LexiconTypeDecoder{

     

       447
       452
        
       			Val: &record,

     
···

       467
       472
        
       	}

     

       468
       473
        
       	defer tx.Rollback()

     

       469
       474
        
       

     

       470
       470
       -
       	commentId, err := db.AddIssueComment(tx, comment)

     

       475
       475
       +
       	err = db.PutComment(tx, &comment)

     

       471
       476
        
       	if err != nil {

     

       472
       477
        
       		l.Error("failed to create comment", "err", err)

     

       473
       478
        
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment.")

     
···

       483
       488
        
       	// reset atUri to make rollback a no-op

     

       484
       489
        
       	atUri = ""

     

       485
       490
        
       

     

       486
       486
       -
       	// notify about the new comment

     

       487
       487
       -
       	comment.Id = commentId

     

       488
       488
       -
       

     

       489
       491
        
       	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)

     

       490
       492
        
       

     

       491
       493
        
       	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)

     

       492
       492
       -
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))

     

       494
       494
       +
       	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, comment.Id))

     

       493
       495
        
       }

     

       494
       496
        
       

     

       495
       497
        
       func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) {

     
···

       504
       506
        
       	}

     

       505
       507
        
       

     

       506
       508
        
       	commentId := chi.URLParam(r, "commentId")

     

       507
       507
       -
       	comments, err := db.GetIssueComments(

     

       509
       509
       +
       	comments, err := db.GetComments(

     

       508
       510
        
       		rp.db,

     

       509
       511
        
       		db.FilterEq("id", commentId),

     

       510
       512
        
       	)

     
···

       540
       542
        
       	}

     

       541
       543
        
       

     

       542
       544
        
       	commentId := chi.URLParam(r, "commentId")

     

       543
       543
       -
       	comments, err := db.GetIssueComments(

     

       545
       545
       +
       	comments, err := db.GetComments(

     

       544
       546
        
       		rp.db,

     

       545
       547
        
       		db.FilterEq("id", commentId),

     

       546
       548
        
       	)

     
···

       556
       558
        
       	}

     

       557
       559
        
       	comment := comments[0]

     

       558
       560
        
       

     

       559
       559
       -
       	if comment.Did != user.Did {

     

       561
       561
       +
       	if comment.Did.String() != user.Did {

     

       560
       562
        
       		l.Error("unauthorized comment edit", "expectedDid", comment.Did, "gotDid", user.Did)

     

       561
       563
        
       		http.Error(w, "you are not the author of this comment", http.StatusUnauthorized)

     

       562
       564
        
       		return

     
···

       596
       598
        
       		}

     

       597
       599
        
       		defer tx.Rollback()

     

       598
       600
        
       

     

       599
       599
       -
       		_, err = db.AddIssueComment(tx, newComment)

     

       601
       601
       +
       		err = db.PutComment(tx, &newComment)

     

       600
       602
        
       		if err != nil {

     

       601
       603
        
       			l.Error("failed to perferom update-description query", "err", err)

     

       602
       604
        
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     
···

       607
       609
        
       		// rkey is optional, it was introduced later

     

       608
       610
        
       		if newComment.Rkey != "" {

     

       609
       611
        
       			// update the record on pds

     

       610
       610
       -
       			ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.Did, comment.Rkey)

     

       612
       612
       +
       			ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.CommentNSID, user.Did, comment.Rkey)

     

       611
       613
        
       			if err != nil {

     

       612
       614
        
       				l.Error("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey)

     

       613
       615
        
       				rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.")

     
···

       615
       617
        
       			}

     

       616
       618
        
       

     

       617
       619
        
       			_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       618
       618
       -
       				Collection: tangled.RepoIssueCommentNSID,

     

       620
       620
       +
       				Collection: tangled.CommentNSID,

     

       619
       621
        
       				Repo:       user.Did,

     

       620
       622
        
       				Rkey:       newComment.Rkey,

     

       621
       623
        
       				SwapRecord: ex.Cid,

     
···

       650
       652
        
       	}

     

       651
       653
        
       

     

       652
       654
        
       	commentId := chi.URLParam(r, "commentId")

     

       653
       653
       -
       	comments, err := db.GetIssueComments(

     

       655
       655
       +
       	comments, err := db.GetComments(

     

       654
       656
        
       		rp.db,

     

       655
       657
        
       		db.FilterEq("id", commentId),

     

       656
       658
        
       	)

     
···

       686
       688
        
       	}

     

       687
       689
        
       

     

       688
       690
        
       	commentId := chi.URLParam(r, "commentId")

     

       689
       689
       -
       	comments, err := db.GetIssueComments(

     

       691
       691
       +
       	comments, err := db.GetComments(

     

       690
       692
        
       		rp.db,

     

       691
       693
        
       		db.FilterEq("id", commentId),

     

       692
       694
        
       	)

     
···

       722
       724
        
       	}

     

       723
       725
        
       

     

       724
       726
        
       	commentId := chi.URLParam(r, "commentId")

     

       725
       725
       -
       	comments, err := db.GetIssueComments(

     

       727
       727
       +
       	comments, err := db.GetComments(

     

       726
       728
        
       		rp.db,

     

       727
       729
        
       		db.FilterEq("id", commentId),

     

       728
       730
        
       	)

     
···

       738
       740
        
       	}

     

       739
       741
        
       	comment := comments[0]

     

       740
       742
        
       

     

       741
       741
       -
       	if comment.Did != user.Did {

     

       743
       743
       +
       	if comment.Did.String() != user.Did {

     

       742
       744
        
       		l.Error("unauthorized action", "expectedDid", comment.Did, "gotDid", user.Did)

     

       743
       745
        
       		http.Error(w, "you are not the author of this comment", http.StatusUnauthorized)

     

       744
       746
        
       		return

     
···

       751
       753
        
       

     

       752
       754
        
       	// optimistic deletion

     

       753
       755
        
       	deleted := time.Now()

     

       754
       754
       -
       	err = db.DeleteIssueComments(rp.db, db.FilterEq("id", comment.Id))

     

       756
       756
       +
       	err = db.DeleteComments(rp.db, db.FilterEq("id", comment.Id))

     

       755
       757
        
       	if err != nil {

     

       756
       758
        
       		l.Error("failed to delete comment", "err", err)

     

       757
       759
        
       		rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")

     
···

       767
       769
        
       			return

     

       768
       770
        
       		}

     

       769
       771
        
       		_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{

     

       770
       770
       -
       			Collection: tangled.RepoIssueCommentNSID,

     

       772
       772
       +
       			Collection: tangled.CommentNSID,

     

       771
       773
        
       			Repo:       user.Did,

     

       772
       774
        
       			Rkey:       comment.Rkey,

     

       773
       775
        
       		})

+8 -89

appview/models/issue.go

···

       26
       26
        
       

     

       27
       27
        
       	// optionally, populate this when querying for reverse mappings

     

       28
       28
        
       	// like comment counts, parent repo etc.

     

       29
       29
       -
       	Comments []IssueComment

     

       29
       29
       +
       	Comments []Comment

     

       30
       30
        
       	Labels   LabelState

     

       31
       31
        
       	Repo     *Repo

     

       32
       32
        
       }

     
···

       62
       62
        
       }

     

       63
       63
        
       

     

       64
       64
        
       type CommentListItem struct {

     

       65
       65
       -
       	Self    *IssueComment

     

       66
       66
       -
       	Replies []*IssueComment

     

       65
       65
       +
       	Self    *Comment

     

       66
       66
       +
       	Replies []*Comment

     

       67
       67
        
       }

     

       68
       68
        
       

     

       69
       69
        
       func (it *CommentListItem) Participants() []syntax.DID {

     
···

       88
       88
        
       

     

       89
       89
        
       func (i *Issue) CommentList() []CommentListItem {

     

       90
       90
        
       	// Create a map to quickly find comments by their aturi

     

       91
       91
       -
       	toplevel := make(map[string]*CommentListItem)

     

       92
       92
       -
       	var replies []*IssueComment

     

       91
       91
       +
       	toplevel := make(map[syntax.ATURI]*CommentListItem)

     

       92
       92
       +
       	var replies []*Comment

     

       93
       93
        
       

     

       94
       94
        
       	// collect top level comments into the map

     

       95
       95
        
       	for _, comment := range i.Comments {

     

       96
       96
        
       		if comment.IsTopLevel() {

     

       97
       97
       -
       			toplevel[comment.AtUri().String()] = &CommentListItem{

     

       97
       97
       +
       			toplevel[comment.AtUri()] = &CommentListItem{

     

       98
       98
        
       				Self: &comment,

     

       99
       99
        
       			}

     

       100
       100
        
       		} else {

     
···

       115
       115
        
       	}

     

       116
       116
        
       

     

       117
       117
        
       	// sort everything

     

       118
       118
       -
       	sortFunc := func(a, b *IssueComment) bool {

     

       118
       118
       +
       	sortFunc := func(a, b *Comment) bool {

     

       119
       119
        
       		return a.Created.Before(b.Created)

     

       120
       120
        
       	}

     

       121
       121
        
       	sort.Slice(listing, func(i, j int) bool {

     
···

       144
       144
        
       	addParticipant(i.Did)

     

       145
       145
        
       

     

       146
       146
        
       	for _, c := range i.Comments {

     

       147
       147
       -
       		addParticipant(c.Did)

     

       147
       147
       +
       		addParticipant(c.Did.String())

     

       148
       148
        
       	}

     

       149
       149
        
       

     

       150
       150
        
       	return participants

     
···

       171
       171
        
       		Open:    true, // new issues are open by default

     

       172
       172
        
       	}

     

       173
       173
        
       }

     

       174
       174
       -
       

     

       175
       175
       -
       type IssueComment struct {

     

       176
       176
       -
       	Id         int64

     

       177
       177
       -
       	Did        string

     

       178
       178
       -
       	Rkey       string

     

       179
       179
       -
       	IssueAt    string

     

       180
       180
       -
       	ReplyTo    *string

     

       181
       181
       -
       	Body       string

     

       182
       182
       -
       	Created    time.Time

     

       183
       183
       -
       	Edited     *time.Time

     

       184
       184
       -
       	Deleted    *time.Time

     

       185
       185
       -
       	Mentions   []syntax.DID

     

       186
       186
       -
       	References []syntax.ATURI

     

       187
       187
       -
       }

     

       188
       188
       -
       

     

       189
       189
       -
       func (i *IssueComment) AtUri() syntax.ATURI {

     

       190
       190
       -
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueCommentNSID, i.Rkey))

     

       191
       191
       -
       }

     

       192
       192
       -
       

     

       193
       193
       -
       func (i *IssueComment) AsRecord() tangled.RepoIssueComment {

     

       194
       194
       -
       	mentions := make([]string, len(i.Mentions))

     

       195
       195
       -
       	for i, did := range i.Mentions {

     

       196
       196
       -
       		mentions[i] = string(did)

     

       197
       197
       -
       	}

     

       198
       198
       -
       	references := make([]string, len(i.References))

     

       199
       199
       -
       	for i, uri := range i.References {

     

       200
       200
       -
       		references[i] = string(uri)

     

       201
       201
       -
       	}

     

       202
       202
       -
       	return tangled.RepoIssueComment{

     

       203
       203
       -
       		Body:       i.Body,

     

       204
       204
       -
       		Issue:      i.IssueAt,

     

       205
       205
       -
       		CreatedAt:  i.Created.Format(time.RFC3339),

     

       206
       206
       -
       		ReplyTo:    i.ReplyTo,

     

       207
       207
       -
       		Mentions:   mentions,

     

       208
       208
       -
       		References: references,

     

       209
       209
       -
       	}

     

       210
       210
       -
       }

     

       211
       211
       -
       

     

       212
       212
       -
       func (i *IssueComment) IsTopLevel() bool {

     

       213
       213
       -
       	return i.ReplyTo == nil

     

       214
       214
       -
       }

     

       215
       215
       -
       

     

       216
       216
       -
       func (i *IssueComment) IsReply() bool {

     

       217
       217
       -
       	return i.ReplyTo != nil

     

       218
       218
       -
       }

     

       219
       219
       -
       

     

       220
       220
       -
       func IssueCommentFromRecord(did, rkey string, record tangled.RepoIssueComment) (*IssueComment, error) {

     

       221
       221
       -
       	created, err := time.Parse(time.RFC3339, record.CreatedAt)

     

       222
       222
       -
       	if err != nil {

     

       223
       223
       -
       		created = time.Now()

     

       224
       224
       -
       	}

     

       225
       225
       -
       

     

       226
       226
       -
       	ownerDid := did

     

       227
       227
       -
       

     

       228
       228
       -
       	if _, err = syntax.ParseATURI(record.Issue); err != nil {

     

       229
       229
       -
       		return nil, err

     

       230
       230
       -
       	}

     

       231
       231
       -
       

     

       232
       232
       -
       	i := record

     

       233
       233
       -
       	mentions := make([]syntax.DID, len(record.Mentions))

     

       234
       234
       -
       	for i, did := range record.Mentions {

     

       235
       235
       -
       		mentions[i] = syntax.DID(did)

     

       236
       236
       -
       	}

     

       237
       237
       -
       	references := make([]syntax.ATURI, len(record.References))

     

       238
       238
       -
       	for i, uri := range i.References {

     

       239
       239
       -
       		references[i] = syntax.ATURI(uri)

     

       240
       240
       -
       	}

     

       241
       241
       -
       

     

       242
       242
       -
       	comment := IssueComment{

     

       243
       243
       -
       		Did:        ownerDid,

     

       244
       244
       -
       		Rkey:       rkey,

     

       245
       245
       -
       		Body:       record.Body,

     

       246
       246
       -
       		IssueAt:    record.Issue,

     

       247
       247
       -
       		ReplyTo:    record.ReplyTo,

     

       248
       248
       -
       		Created:    created,

     

       249
       249
       -
       		Mentions:   mentions,

     

       250
       250
       -
       		References: references,

     

       251
       251
       -
       	}

     

       252
       252
       -
       

     

       253
       253
       -
       	return &comment, nil

     

       254
       254
       -
       }

+4 -4

appview/notify/db/db.go

···

       118
       118
        
       	)

     

       119
       119
        
       }

     

       120
       120
        
       

     

       121
       121
       -
       func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       122
       122
       -
       	issues, err := db.GetIssues(n.db, db.FilterEq("at_uri", comment.IssueAt))

     

       121
       121
       +
       func (n *databaseNotifier) NewIssueComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) {

     

       122
       122
       +
       	issues, err := db.GetIssues(n.db, db.FilterEq("at_uri", comment.Subject))

     

       123
       123
        
       	if err != nil {

     

       124
       124
        
       		log.Printf("NewIssueComment: failed to get issues: %v", err)

     

       125
       125
        
       		return

     

       126
       126
        
       	}

     

       127
       127
        
       	if len(issues) == 0 {

     

       128
       128
       -
       		log.Printf("NewIssueComment: no issue found for %s", comment.IssueAt)

     

       128
       128
       +
       		log.Printf("NewIssueComment: no issue found for %s", comment.Subject)

     

       129
       129
        
       		return

     

       130
       130
        
       	}

     

       131
       131
        
       	issue := issues[0]

     
···

       140
       140
        
       

     

       141
       141
        
       		// find the parent thread, and add all DIDs from here to the recipient list

     

       142
       142
        
       		for _, t := range allThreads {

     

       143
       143
       -
       			if t.Self.AtUri().String() == parentAtUri {

     

       143
       143
       +
       			if t.Self.AtUri() == parentAtUri {

     

       144
       144
        
       				recipients = append(recipients, t.Participants()...)

     

       145
       145
        
       			}

     

       146
       146
        
       		}

+1 -1

appview/notify/merged_notifier.go

···

       58
       58
        
       	m.fanout("NewIssue", ctx, issue, mentions)

     

       59
       59
        
       }

     

       60
       60
        
       

     

       61
       61
       -
       func (m *mergedNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       61
       61
       +
       func (m *mergedNotifier) NewIssueComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) {

     

       62
       62
        
       	m.fanout("NewIssueComment", ctx, comment, mentions)

     

       63
       63
        
       }

     

       64
       64

+2 -2

appview/notify/notifier.go

···

       14
       14
        
       	DeleteStar(ctx context.Context, star *models.Star)

     

       15
       15
        
       

     

       16
       16
        
       	NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID)

     

       17
       17
       -
       	NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID)

     

       17
       17
       +
       	NewIssueComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID)

     

       18
       18
        
       	NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue)

     

       19
       19
        
       	DeleteIssue(ctx context.Context, issue *models.Issue)

     

       20
       20
        
       

     
···

       43
       43
        
       func (m *BaseNotifier) DeleteStar(ctx context.Context, star *models.Star) {}

     

       44
       44
        
       

     

       45
       45
        
       func (m *BaseNotifier) NewIssue(ctx context.Context, issue *models.Issue, mentions []syntax.DID) {}

     

       46
       46
       -
       func (m *BaseNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       46
       46
       +
       func (m *BaseNotifier) NewIssueComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) {

     

       47
       47
        
       }

     

       48
       48
        
       func (m *BaseNotifier) NewIssueState(ctx context.Context, actor syntax.DID, issue *models.Issue) {}

     

       49
       49
        
       func (m *BaseNotifier) DeleteIssue(ctx context.Context, issue *models.Issue)                     {}

+3 -3

appview/notify/posthog/notifier.go

···

       179
       179
        
       	}

     

       180
       180
        
       }

     

       181
       181
        
       

     

       182
       182
       -
       func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment, mentions []syntax.DID) {

     

       182
       182
       +
       func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) {

     

       183
       183
        
       	err := n.client.Enqueue(posthog.Capture{

     

       184
       184
       -
       		DistinctId: comment.Did,

     

       184
       184
       +
       		DistinctId: comment.Did.String(),

     

       185
       185
        
       		Event:      "new_issue_comment",

     

       186
       186
        
       		Properties: posthog.Properties{

     

       187
       187
       -
       			"issue_at": comment.IssueAt,

     

       187
       187
       +
       			"issue_at": comment.Subject,

     

       188
       188
        
       			"mentions": mentions,

     

       189
       189
        
       		},

     

       190
       190
        
       	})

+4 -4

appview/pages/pages.go

···

       989
       989
        
       	LoggedInUser *oauth.User

     

       990
       990
        
       	RepoInfo     repoinfo.RepoInfo

     

       991
       991
        
       	Issue        *models.Issue

     

       992
       992
       -
       	Comment      *models.IssueComment

     

       992
       992
       +
       	Comment      *models.Comment

     

       993
       993
        
       }

     

       994
       994
        
       

     

       995
       995
        
       func (p *Pages) EditIssueCommentFragment(w io.Writer, params EditIssueCommentParams) error {

     
···

       1000
       1000
        
       	LoggedInUser *oauth.User

     

       1001
       1001
        
       	RepoInfo     repoinfo.RepoInfo

     

       1002
       1002
        
       	Issue        *models.Issue

     

       1003
       1003
       -
       	Comment      *models.IssueComment

     

       1003
       1003
       +
       	Comment      *models.Comment

     

       1004
       1004
        
       }

     

       1005
       1005
        
       

     

       1006
       1006
        
       func (p *Pages) ReplyIssueCommentPlaceholderFragment(w io.Writer, params ReplyIssueCommentPlaceholderParams) error {

     
···

       1011
       1011
        
       	LoggedInUser *oauth.User

     

       1012
       1012
        
       	RepoInfo     repoinfo.RepoInfo

     

       1013
       1013
        
       	Issue        *models.Issue

     

       1014
       1014
       -
       	Comment      *models.IssueComment

     

       1014
       1014
       +
       	Comment      *models.Comment

     

       1015
       1015
        
       }

     

       1016
       1016
        
       

     

       1017
       1017
        
       func (p *Pages) ReplyIssueCommentFragment(w io.Writer, params ReplyIssueCommentParams) error {

     
···

       1022
       1022
        
       	LoggedInUser *oauth.User

     

       1023
       1023
        
       	RepoInfo     repoinfo.RepoInfo

     

       1024
       1024
        
       	Issue        *models.Issue

     

       1025
       1025
       -
       	Comment      *models.IssueComment

     

       1025
       1025
       +
       	Comment      *models.Comment

     

       1026
       1026
        
       }

     

       1027
       1027
        
       

     

       1028
       1028
        
       func (p *Pages) IssueCommentBodyFragment(w io.Writer, params IssueCommentBodyParams) error {

+2 -2

appview/pages/templates/repo/issues/fragments/issueCommentHeader.html

···

       1
       1
        
       {{ define "repo/issues/fragments/issueCommentHeader" }}

     

       2
       2
        
         <div class="flex flex-wrap items-center gap-2 text-sm text-gray-500 dark:text-gray-400 ">

     

       3
       3
       -
           {{ template "user/fragments/picHandleLink" .Comment.Did }}

     

       3
       3
       +
           {{ template "user/fragments/picHandleLink" .Comment.Did.String }}

     

       4
       4
        
           {{ template "hats" $ }}

     

       5
       5
        
           {{ template "timestamp" . }}

     

       6
       6
       -
           {{ $isCommentOwner := and .LoggedInUser (eq .LoggedInUser.Did .Comment.Did) }}

     

       6
       6
       +
           {{ $isCommentOwner := and .LoggedInUser (eq .LoggedInUser.Did .Comment.Did.String) }}

     

       7
       7
        
           {{ if and $isCommentOwner (not .Comment.Deleted) }}

     

       8
       8
        
             {{ template "editIssueComment" . }}

     

       9
       9
        
             {{ template "deleteIssueComment" . }}

+1 -1

appview/state/state.go

···

       116
       116
        
       			tangled.SpindleNSID,

     

       117
       117
        
       			tangled.StringNSID,

     

       118
       118
        
       			tangled.RepoIssueNSID,

     

       119
       119
       -
       			tangled.RepoIssueCommentNSID,

     

       119
       119
       +
       			tangled.CommentNSID,

     

       120
       120
        
       			tangled.LabelDefinitionNSID,

     

       121
       121
        
       			tangled.LabelOpNSID,

     

       122
       122
        
       		},

-26

appview/validator/issue.go

···

       4
       4
        
       	"fmt"

     

       5
       5
        
       	"strings"

     

       6
       6
        
       

     

       7
       7
       -
       	"tangled.org/core/appview/db"

     

       8
       7
        
       	"tangled.org/core/appview/models"

     

       9
       8
        
       )

     

       10
       9
        
       

     

       11
       11
       -
       func (v *Validator) ValidateIssueComment(comment *models.IssueComment) error {

     

       12
       12
       -
       	// if comments have parents, only ingest ones that are 1 level deep

     

       13
       13
       -
       	if comment.ReplyTo != nil {

     

       14
       14
       -
       		parents, err := db.GetIssueComments(v.db, db.FilterEq("at_uri", *comment.ReplyTo))

     

       15
       15
       -
       		if err != nil {

     

       16
       16
       -
       			return fmt.Errorf("failed to fetch parent comment: %w", err)

     

       17
       17
       -
       		}

     

       18
       18
       -
       		if len(parents) != 1 {

     

       19
       19
       -
       			return fmt.Errorf("incorrect number of parent comments returned: %d", len(parents))

     

       20
       20
       -
       		}

     

       21
       21
       -
       

     

       22
       22
       -
       		// depth check

     

       23
       23
       -
       		parent := parents[0]

     

       24
       24
       -
       		if parent.ReplyTo != nil {

     

       25
       25
       -
       			return fmt.Errorf("incorrect depth, this comment is replying at depth >1")

     

       26
       26
       -
       		}

     

       27
       27
       -
       	}

     

       28
       28
       -
       

     

       29
       29
       -
       	if sb := strings.TrimSpace(v.sanitizer.SanitizeDefault(comment.Body)); sb == "" {

     

       30
       30
       -
       		return fmt.Errorf("body is empty after HTML sanitization")

     

       31
       31
       -
       	}

     

       32
       32
       -
       

     

       33
       33
       -
       	return nil

     

       34
       34
       -
       }

     

       35
       35
       -
       

     

       36
       10
        
       func (v *Validator) ValidateIssue(issue *models.Issue) error {

     

       37
       11
        
       	if issue.Title == "" {

     

       38
       12
        
       		return fmt.Errorf("issue title is empty")