appview: replace PullComment to Comment #865

+197

appview/db/comments.go

··· 1 1 + package db 2 2 + 3 3 + import ( 4 4 + "database/sql" 5 5 + "fmt" 6 6 + "maps" 7 7 + "slices" 8 8 + "sort" 9 9 + "strings" 10 10 + "time" 11 11 + 12 12 + "github.com/bluesky-social/indigo/atproto/syntax" 13 13 + "tangled.org/core/appview/models" 14 14 + ) 15 15 + 16 16 + func PutComment(tx *sql.Tx, c *models.Comment) error { 17 17 + result, err := tx.Exec( 18 18 + `insert into comments ( 19 19 + did, 20 20 + rkey, 21 21 + subject_at, 22 22 + reply_to, 23 23 + body, 24 24 + pull_submission_id, 25 25 + created 26 26 + ) 27 27 + values (?, ?, ?, ?, ?, ?, ?) 28 28 + on conflict(did, rkey) do update set 29 29 + subject_at = excluded.subject_at, 30 30 + reply_to = excluded.reply_to, 31 31 + body = excluded.body, 32 32 + edited = case 33 33 + when 34 34 + comments.subject_at != excluded.subject_at 35 35 + or comments.body != excluded.body 36 36 + or comments.reply_to != excluded.reply_to 37 37 + then ? 38 38 + else comments.edited 39 39 + end`, 40 40 + c.Did, 41 41 + c.Rkey, 42 42 + c.Subject, 43 43 + c.ReplyTo, 44 44 + c.Body, 45 45 + c.PullSubmissionId, 46 46 + c.Created.Format(time.RFC3339), 47 47 + time.Now().Format(time.RFC3339), 48 48 + ) 49 49 + if err != nil { 50 50 + return err 51 51 + } 52 52 + 53 53 + c.Id, err = result.LastInsertId() 54 54 + if err != nil { 55 55 + return err 56 56 + } 57 57 + 58 58 + if err := putReferences(tx, c.AtUri(), c.References); err != nil { 59 59 + return fmt.Errorf("put reference_links: %w", err) 60 60 + } 61 61 + 62 62 + return nil 63 63 + } 64 64 + 65 65 + func DeleteComments(e Execer, filters ...filter) error { 66 66 + var conditions []string 67 67 + var args []any 68 68 + for _, filter := range filters { 69 69 + conditions = append(conditions, filter.Condition()) 70 70 + args = append(args, filter.Arg()...) 71 71 + } 72 72 + 73 73 + whereClause := "" 74 74 + if conditions != nil { 75 75 + whereClause = " where " + strings.Join(conditions, " and ") 76 76 + } 77 77 + 78 78 + query := fmt.Sprintf(`update comments set body = "", deleted = strftime('%%Y-%%m-%%dT%%H:%%M:%%SZ', 'now') %s`, whereClause) 79 79 + 80 80 + _, err := e.Exec(query, args...) 81 81 + return err 82 82 + } 83 83 + 84 84 + func GetComments(e Execer, filters ...filter) ([]models.Comment, error) { 85 85 + commentMap := make(map[string]*models.Comment) 86 86 + 87 87 + var conditions []string 88 88 + var args []any 89 89 + for _, filter := range filters { 90 90 + conditions = append(conditions, filter.Condition()) 91 91 + args = append(args, filter.Arg()...) 92 92 + } 93 93 + 94 94 + whereClause := "" 95 95 + if conditions != nil { 96 96 + whereClause = " where " + strings.Join(conditions, " and ") 97 97 + } 98 98 + 99 99 + query := fmt.Sprintf(` 100 100 + select 101 101 + id, 102 102 + did, 103 103 + rkey, 104 104 + subject_at, 105 105 + reply_to, 106 106 + body, 107 107 + pull_submission_id, 108 108 + created, 109 109 + edited, 110 110 + deleted 111 111 + from 112 112 + comments 113 113 + %s 114 114 + `, whereClause) 115 115 + 116 116 + rows, err := e.Query(query, args...) 117 117 + if err != nil { 118 118 + return nil, err 119 119 + } 120 120 + 121 121 + for rows.Next() { 122 122 + var comment models.Comment 123 123 + var created string 124 124 + var rkey, edited, deleted, replyTo sql.Null[string] 125 125 + err := rows.Scan( 126 126 + &comment.Id, 127 127 + &comment.Did, 128 128 + &rkey, 129 129 + &comment.Subject, 130 130 + &replyTo, 131 131 + &comment.Body, 132 132 + &comment.PullSubmissionId, 133 133 + &created, 134 134 + &edited, 135 135 + &deleted, 136 136 + ) 137 137 + if err != nil { 138 138 + return nil, err 139 139 + } 140 140 + 141 141 + // this is a remnant from old times, newer comments always have rkey 142 142 + if rkey.Valid { 143 143 + comment.Rkey = rkey.V 144 144 + } 145 145 + 146 146 + if t, err := time.Parse(time.RFC3339, created); err == nil { 147 147 + comment.Created = t 148 148 + } 149 149 + 150 150 + if edited.Valid { 151 151 + if t, err := time.Parse(time.RFC3339, edited.V); err == nil { 152 152 + comment.Edited = &t 153 153 + } 154 154 + } 155 155 + 156 156 + if deleted.Valid { 157 157 + if t, err := time.Parse(time.RFC3339, deleted.V); err == nil { 158 158 + comment.Deleted = &t 159 159 + } 160 160 + } 161 161 + 162 162 + if replyTo.Valid { 163 163 + rt := syntax.ATURI(replyTo.V) 164 164 + comment.ReplyTo = &rt 165 165 + } 166 166 + 167 167 + atUri := comment.AtUri().String() 168 168 + commentMap[atUri] = &comment 169 169 + } 170 170 + 171 171 + if err := rows.Err(); err != nil { 172 172 + return nil, err 173 173 + } 174 174 + 175 175 + // collect references from each comments 176 176 + commentAts := slices.Collect(maps.Keys(commentMap)) 177 177 + allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts)) 178 178 + if err != nil { 179 179 + return nil, fmt.Errorf("failed to query reference_links: %w", err) 180 180 + } 181 181 + for commentAt, references := range allReferencs { 182 182 + if comment, ok := commentMap[commentAt.String()]; ok { 183 183 + comment.References = references 184 184 + } 185 185 + } 186 186 + 187 187 + var comments []models.Comment 188 188 + for _, c := range commentMap { 189 189 + comments = append(comments, *c) 190 190 + } 191 191 + 192 192 + sort.Slice(comments, func(i, j int) bool { 193 193 + return comments[i].Created.After(comments[j].Created) 194 194 + }) 195 195 + 196 196 + return comments, nil 197 197 + }

+32

appview/db/db.go

··· 1174 1174 return err 1175 1175 }) 1176 1176 1177 1177 + // not migrating existing comments here 1178 1178 + // all legacy comments will be dropped 1179 1179 + runMigration(conn, logger, "add-comments-table", func(tx *sql.Tx) error { 1180 1180 + _, err := tx.Exec(` 1181 1181 + drop table comments; 1182 1182 + 1183 1183 + create table comments ( 1184 1184 + -- identifiers 1185 1185 + id integer primary key autoincrement, 1186 1186 + did text not null, 1187 1187 + rkey text not null, 1188 1188 + at_uri text generated always as ('at://' || did || '/' || 'sh.tangled.comment' || '/' || rkey) stored, 1189 1189 + 1190 1190 + -- at identifiers 1191 1191 + subject_at text not null, 1192 1192 + reply_to text, -- at_uri of parent comment 1193 1193 + 1194 1194 + pull_submission_id integer, -- dirty fix until we atprotate the pull-rounds 1195 1195 + 1196 1196 + -- content 1197 1197 + body text not null, 1198 1198 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 1199 1199 + edited text, 1200 1200 + deleted text, 1201 1201 + 1202 1202 + -- constraints 1203 1203 + unique(did, rkey) 1204 1204 + ); 1205 1205 + `) 1206 1206 + return err 1207 1207 + }) 1208 1208 + 1177 1209 return &DB{ 1178 1210 db, 1179 1211 logger,

+6 -121

appview/db/pulls.go

··· 446 446 return nil, err 447 447 } 448 448 449 449 - // Get comments for all submissions using GetPullComments 449 449 + // Get comments for all submissions using GetComments 450 450 submissionIds := slices.Collect(maps.Keys(submissionMap)) 451 451 - comments, err := GetPullComments(e, FilterIn("submission_id", submissionIds)) 451 451 + comments, err := GetComments(e, FilterIn("pull_submission_id", submissionIds)) 452 452 if err != nil { 453 453 return nil, fmt.Errorf("failed to get pull comments: %w", err) 454 454 } 455 455 for _, comment := range comments { 456 456 - if submission, ok := submissionMap[comment.SubmissionId]; ok { 457 457 - submission.Comments = append(submission.Comments, comment) 456 456 + if comment.PullSubmissionId != nil { 457 457 + if submission, ok := submissionMap[*comment.PullSubmissionId]; ok { 458 458 + submission.Comments = append(submission.Comments, comment) 459 459 + } 458 460 } 459 461 } 460 462 ··· 474 476 return m, nil 475 477 } 476 478 477 477 - func GetPullComments(e Execer, filters ...filter) ([]models.PullComment, error) { 478 478 - var conditions []string 479 479 - var args []any 480 480 - for _, filter := range filters { 481 481 - conditions = append(conditions, filter.Condition()) 482 482 - args = append(args, filter.Arg()...) 483 483 - } 484 484 - 485 485 - whereClause := "" 486 486 - if conditions != nil { 487 487 - whereClause = " where " + strings.Join(conditions, " and ") 488 488 - } 489 489 - 490 490 - query := fmt.Sprintf(` 491 491 - select 492 492 - id, 493 493 - pull_id, 494 494 - submission_id, 495 495 - repo_at, 496 496 - owner_did, 497 497 - comment_at, 498 498 - body, 499 499 - created 500 500 - from 501 501 - pull_comments 502 502 - %s 503 503 - order by 504 504 - created asc 505 505 - `, whereClause) 506 506 - 507 507 - rows, err := e.Query(query, args...) 508 508 - if err != nil { 509 509 - return nil, err 510 510 - } 511 511 - defer rows.Close() 512 512 - 513 513 - commentMap := make(map[string]*models.PullComment) 514 514 - for rows.Next() { 515 515 - var comment models.PullComment 516 516 - var createdAt string 517 517 - err := rows.Scan( 518 518 - &comment.ID, 519 519 - &comment.PullId, 520 520 - &comment.SubmissionId, 521 521 - &comment.RepoAt, 522 522 - &comment.OwnerDid, 523 523 - &comment.CommentAt, 524 524 - &comment.Body, 525 525 - &createdAt, 526 526 - ) 527 527 - if err != nil { 528 528 - return nil, err 529 529 - } 530 530 - 531 531 - if t, err := time.Parse(time.RFC3339, createdAt); err == nil { 532 532 - comment.Created = t 533 533 - } 534 534 - 535 535 - atUri := comment.AtUri().String() 536 536 - commentMap[atUri] = &comment 537 537 - } 538 538 - 539 539 - if err := rows.Err(); err != nil { 540 540 - return nil, err 541 541 - } 542 542 - 543 543 - // collect references for each comments 544 544 - commentAts := slices.Collect(maps.Keys(commentMap)) 545 545 - allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts)) 546 546 - if err != nil { 547 547 - return nil, fmt.Errorf("failed to query reference_links: %w", err) 548 548 - } 549 549 - for commentAt, references := range allReferencs { 550 550 - if comment, ok := commentMap[commentAt.String()]; ok { 551 551 - comment.References = references 552 552 - } 553 553 - } 554 554 - 555 555 - var comments []models.PullComment 556 556 - for _, c := range commentMap { 557 557 - comments = append(comments, *c) 558 558 - } 559 559 - 560 560 - sort.Slice(comments, func(i, j int) bool { 561 561 - return comments[i].Created.Before(comments[j].Created) 562 562 - }) 563 563 - 564 564 - return comments, nil 565 565 - } 566 566 - 567 479 // timeframe here is directly passed into the sql query filter, and any 568 480 // timeframe in the past should be negative; e.g.: "-3 months" 569 481 func GetPullsByOwnerDid(e Execer, did, timeframe string) ([]models.Pull, error) { ··· 640 552 return pulls, nil 641 553 } 642 554 643 643 - func NewPullComment(tx *sql.Tx, comment *models.PullComment) (int64, error) { 644 644 - query := `insert into pull_comments (owner_did, repo_at, submission_id, comment_at, pull_id, body) values (?, ?, ?, ?, ?, ?)` 645 645 - res, err := tx.Exec( 646 646 - query, 647 647 - comment.OwnerDid, 648 648 - comment.RepoAt, 649 649 - comment.SubmissionId, 650 650 - comment.CommentAt, 651 651 - comment.PullId, 652 652 - comment.Body, 653 653 - ) 654 654 - if err != nil { 655 655 - return 0, err 656 656 - } 657 657 - 658 658 - i, err := res.LastInsertId() 659 659 - if err != nil { 660 660 - return 0, err 661 661 - } 662 662 - 663 663 - if err := putReferences(tx, comment.AtUri(), comment.References); err != nil { 664 664 - return 0, fmt.Errorf("put reference_links: %w", err) 665 665 - } 666 666 - 667 667 - return i, nil 668 668 - } 669 669 - 670 555 func SetPullState(e Execer, repoAt syntax.ATURI, pullId int, pullState models.PullState) error { 671 556 _, err := e.Exec( 672 557 `update pulls set state = ? where repo_at = ? and pull_id = ? and (state <> ? or state <> ?)`,

+7 -8

appview/db/reference.go

··· 123 123 values %s 124 124 ) 125 125 select 126 126 - p.owner_did, p.rkey, 127 127 - c.comment_at 126 126 + p.owner_did, p.rkey, c.at_uri 128 127 from input inp 129 128 join repos r 130 129 on r.did = inp.owner_did ··· 132 131 join pulls p 133 132 on p.repo_at = r.at_uri 134 133 and p.pull_id = inp.pull_id 135 135 - left join pull_comments c 134 134 + left join comments c 136 135 on inp.comment_id is not null 137 137 - and c.repo_at = r.at_uri and c.pull_id = p.pull_id 136 136 + and c.subject_at = ('at://' || p.owner_did || '/' || 'sh.tangled.repo.pull' || '/' || p.rkey) 138 137 and c.id = inp.comment_id 139 138 `, 140 139 strings.Join(vals, ","), ··· 292 291 return nil, fmt.Errorf("get pull backlinks: %w", err) 293 292 } 294 293 backlinks = append(backlinks, ls...) 295 295 - ls, err = getPullCommentBacklinks(e, backlinksMap[tangled.RepoPullCommentNSID]) 294 294 + ls, err = getPullCommentBacklinks(e, backlinksMap[tangled.CommentNSID]) 296 295 if err != nil { 297 296 return nil, fmt.Errorf("get pull_comment backlinks: %w", err) 298 297 } ··· 427 426 if len(aturis) == 0 { 428 427 return nil, nil 429 428 } 430 430 - filter := FilterIn("c.comment_at", aturis) 429 429 + filter := FilterIn("c.at_uri", aturis) 431 430 rows, err := e.Query( 432 431 fmt.Sprintf( 433 432 `select r.did, r.name, p.pull_id, c.id, p.title, p.state 434 433 from repos r 435 434 join pulls p 436 435 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 436 436 + join comments c 437 437 + on ('at://' || p.owner_did || '/' || 'sh.tangled.repo.pull' || '/' || p.rkey) = c.subject_at 439 438 where %s`, 440 439 filter.Condition(), 441 440 ),

+117

appview/models/comment.go

··· 1 1 + package models 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "strings" 6 6 + "time" 7 7 + 8 8 + "github.com/bluesky-social/indigo/atproto/syntax" 9 9 + "tangled.org/core/api/tangled" 10 10 + ) 11 11 + 12 12 + type Comment struct { 13 13 + Id int64 14 14 + Did syntax.DID 15 15 + Rkey string 16 16 + Subject syntax.ATURI 17 17 + ReplyTo *syntax.ATURI 18 18 + Body string 19 19 + Created time.Time 20 20 + Edited *time.Time 21 21 + Deleted *time.Time 22 22 + Mentions []syntax.DID 23 23 + References []syntax.ATURI 24 24 + PullSubmissionId *int 25 25 + } 26 26 + 27 27 + func (c *Comment) AtUri() syntax.ATURI { 28 28 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", c.Did, tangled.CommentNSID, c.Rkey)) 29 29 + } 30 30 + 31 31 + func (c *Comment) AsRecord() tangled.Comment { 32 32 + mentions := make([]string, len(c.Mentions)) 33 33 + for i, did := range c.Mentions { 34 34 + mentions[i] = string(did) 35 35 + } 36 36 + references := make([]string, len(c.References)) 37 37 + for i, uri := range c.References { 38 38 + references[i] = string(uri) 39 39 + } 40 40 + var replyTo *string 41 41 + if c.ReplyTo != nil { 42 42 + replyToStr := c.ReplyTo.String() 43 43 + replyTo = &replyToStr 44 44 + } 45 45 + return tangled.Comment{ 46 46 + Subject: c.Subject.String(), 47 47 + Body: c.Body, 48 48 + CreatedAt: c.Created.Format(time.RFC3339), 49 49 + ReplyTo: replyTo, 50 50 + Mentions: mentions, 51 51 + References: references, 52 52 + } 53 53 + } 54 54 + 55 55 + func (c *Comment) IsTopLevel() bool { 56 56 + return c.ReplyTo == nil 57 57 + } 58 58 + 59 59 + func (c *Comment) IsReply() bool { 60 60 + return c.ReplyTo != nil 61 61 + } 62 62 + 63 63 + func (c *Comment) Validate() error { 64 64 + // TODO: sanitize the body and then trim space 65 65 + if sb := strings.TrimSpace(c.Body); sb == "" { 66 66 + return fmt.Errorf("body is empty after HTML sanitization") 67 67 + } 68 68 + 69 69 + // if it's for PR, PullSubmissionId should not be nil 70 70 + if c.Subject.Collection().String() == tangled.RepoPullNSID { 71 71 + if c.PullSubmissionId == nil { 72 72 + return fmt.Errorf("PullSubmissionId should not be nil") 73 73 + } 74 74 + } 75 75 + return nil 76 76 + } 77 77 + 78 78 + func CommentFromRecord(did, rkey string, record tangled.Comment) (*Comment, error) { 79 79 + created, err := time.Parse(time.RFC3339, record.CreatedAt) 80 80 + if err != nil { 81 81 + created = time.Now() 82 82 + } 83 83 + 84 84 + ownerDid := did 85 85 + 86 86 + if _, err = syntax.ParseATURI(record.Subject); err != nil { 87 87 + return nil, err 88 88 + } 89 89 + 90 90 + i := record 91 91 + mentions := make([]syntax.DID, len(record.Mentions)) 92 92 + for i, did := range record.Mentions { 93 93 + mentions[i] = syntax.DID(did) 94 94 + } 95 95 + references := make([]syntax.ATURI, len(record.References)) 96 96 + for i, uri := range i.References { 97 97 + references[i] = syntax.ATURI(uri) 98 98 + } 99 99 + var replyTo *syntax.ATURI 100 100 + if record.ReplyTo != nil { 101 101 + replyToAtUri := syntax.ATURI(*record.ReplyTo) 102 102 + replyTo = &replyToAtUri 103 103 + } 104 104 + 105 105 + comment := Comment{ 106 106 + Did: syntax.DID(ownerDid), 107 107 + Rkey: rkey, 108 108 + Body: record.Body, 109 109 + Subject: syntax.ATURI(record.Subject), 110 110 + ReplyTo: replyTo, 111 111 + Created: created, 112 112 + Mentions: mentions, 113 113 + References: references, 114 114 + } 115 115 + 116 116 + return &comment, nil 117 117 + }

+2 -46

appview/models/pull.go

··· 138 138 RoundNumber int 139 139 Patch string 140 140 Combined string 141 141 - Comments []PullComment 141 141 + Comments []Comment 142 142 SourceRev string // include the rev that was used to create this submission: only for branch/fork PRs 143 143 144 144 // meta 145 145 Created time.Time 146 146 } 147 147 148 148 - type PullComment struct { 149 149 - // ids 150 150 - ID int 151 151 - PullId int 152 152 - SubmissionId int 153 153 - 154 154 - // at ids 155 155 - RepoAt string 156 156 - OwnerDid string 157 157 - CommentAt string 158 158 - 159 159 - // content 160 160 - Body string 161 161 - 162 162 - // meta 163 163 - Mentions []syntax.DID 164 164 - References []syntax.ATURI 165 165 - 166 166 - // meta 167 167 - Created time.Time 168 168 - } 169 169 - 170 170 - func (p *PullComment) AtUri() syntax.ATURI { 171 171 - return syntax.ATURI(p.CommentAt) 172 172 - } 173 173 - 174 174 - // func (p *PullComment) AsRecord() tangled.RepoPullComment { 175 175 - // mentions := make([]string, len(p.Mentions)) 176 176 - // for i, did := range p.Mentions { 177 177 - // mentions[i] = string(did) 178 178 - // } 179 179 - // references := make([]string, len(p.References)) 180 180 - // for i, uri := range p.References { 181 181 - // references[i] = string(uri) 182 182 - // } 183 183 - // return tangled.RepoPullComment{ 184 184 - // Pull: p.PullAt, 185 185 - // Body: p.Body, 186 186 - // Mentions: mentions, 187 187 - // References: references, 188 188 - // CreatedAt: p.Created.Format(time.RFC3339), 189 189 - // } 190 190 - // } 191 191 - 192 148 func (p *Pull) LastRoundNumber() int { 193 149 return len(p.Submissions) - 1 194 150 } ··· 289 245 addParticipant(s.PullAt.Authority().String()) 290 246 291 247 for _, c := range s.Comments { 292 292 - addParticipant(c.OwnerDid) 248 248 + addParticipant(c.Did.String()) 293 249 } 294 250 295 251 return participants

+11 -6

appview/notify/db/db.go

··· 248 248 ) 249 249 } 250 250 251 251 - func (n *databaseNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) { 252 252 - pull, err := db.GetPull(n.db, 253 253 - syntax.ATURI(comment.RepoAt), 254 254 - comment.PullId, 251 251 + func (n *databaseNotifier) NewPullComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) { 252 252 + pulls, err := db.GetPulls(n.db, 253 253 + db.FilterEq("owner_did", comment.Subject.Authority()), 254 254 + db.FilterEq("rkey", comment.Subject.RecordKey()), 255 255 ) 256 256 if err != nil { 257 257 log.Printf("NewPullComment: failed to get pulls: %v", err) 258 258 return 259 259 } 260 260 + if len(pulls) == 0 { 261 261 + log.Printf("NewPullComment: no pull found for %s", comment.Subject) 262 262 + return 263 263 + } 264 264 + pull := pulls[0] 260 265 261 261 - repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", comment.RepoAt)) 266 266 + repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", pull.RepoAt)) 262 267 if err != nil { 263 268 log.Printf("NewPullComment: failed to get repos: %v", err) 264 269 return ··· 273 278 recipients = append(recipients, syntax.DID(p)) 274 279 } 275 280 276 276 - actorDid := syntax.DID(comment.OwnerDid) 281 281 + actorDid := comment.Did 277 282 eventType := models.NotificationTypePullCommented 278 283 entityType := "pull" 279 284 entityId := pull.AtUri().String()

+1 -1

appview/notify/merged_notifier.go

··· 82 82 m.fanout("NewPull", ctx, pull) 83 83 } 84 84 85 85 - func (m *mergedNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) { 85 85 + func (m *mergedNotifier) NewPullComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) { 86 86 m.fanout("NewPullComment", ctx, comment, mentions) 87 87 } 88 88

+2 -2

appview/notify/notifier.go

··· 22 22 DeleteFollow(ctx context.Context, follow *models.Follow) 23 23 24 24 NewPull(ctx context.Context, pull *models.Pull) 25 25 - NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) 25 25 + NewPullComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) 26 26 NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) 27 27 28 28 UpdateProfile(ctx context.Context, profile *models.Profile) ··· 52 52 func (m *BaseNotifier) DeleteFollow(ctx context.Context, follow *models.Follow) {} 53 53 54 54 func (m *BaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {} 55 55 - func (m *BaseNotifier) NewPullComment(ctx context.Context, models *models.PullComment, mentions []syntax.DID) { 55 55 + func (m *BaseNotifier) NewPullComment(ctx context.Context, models *models.Comment, mentions []syntax.DID) { 56 56 } 57 57 func (m *BaseNotifier) NewPullState(ctx context.Context, actor syntax.DID, pull *models.Pull) {} 58 58

+3 -4

appview/notify/posthog/notifier.go

··· 86 86 } 87 87 } 88 88 89 89 - func (n *posthogNotifier) NewPullComment(ctx context.Context, comment *models.PullComment, mentions []syntax.DID) { 89 89 + func (n *posthogNotifier) NewPullComment(ctx context.Context, comment *models.Comment, mentions []syntax.DID) { 90 90 err := n.client.Enqueue(posthog.Capture{ 91 91 - DistinctId: comment.OwnerDid, 91 91 + DistinctId: comment.Did.String(), 92 92 Event: "new_pull_comment", 93 93 Properties: posthog.Properties{ 94 94 - "repo_at": comment.RepoAt, 95 95 - "pull_id": comment.PullId, 94 94 + "pull_at": comment.Subject, 96 95 "mentions": mentions, 97 96 }, 98 97 })

+3 -3

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

··· 165 165 166 166 <div class="md:pl-[3.5rem] flex flex-col gap-2 mt-2 relative"> 167 167 {{ range $cidx, $c := .Comments }} 168 168 - <div id="comment-{{$c.ID}}" class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-2 px-4 relative w-full"> 168 168 + <div id="comment-{{$c.Id}}" class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-2 px-4 relative w-full"> 169 169 {{ if gt $cidx 0 }} 170 170 <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div> 171 171 {{ end }} 172 172 <div class="text-sm text-gray-500 dark:text-gray-400 flex items-center gap-1"> 173 173 - {{ template "user/fragments/picHandleLink" $c.OwnerDid }} 173 173 + {{ template "user/fragments/picHandleLink" $c.Did.String }} 174 174 <span class="before:content-['·']"></span> 175 175 - <a class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-300" href="#comment-{{.ID}}">{{ template "repo/fragments/time" $c.Created }}</a> 175 175 + <a class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-300" href="#comment-{{.Id}}">{{ template "repo/fragments/time" $c.Created }}</a> 176 176 </div> 177 177 <div class="prose dark:prose-invert"> 178 178 {{ $c.Body | markdown }}

+1 -1

appview/pulls/opengraph.go

··· 276 276 } 277 277 278 278 // Get comment count from database 279 279 - comments, err := db.GetPullComments(s.db, db.FilterEq("pull_id", pull.ID)) 279 279 + comments, err := db.GetComments(s.db, db.FilterEq("subject_at", pull.AtUri())) 280 280 if err != nil { 281 281 log.Printf("failed to get pull comments: %v", err) 282 282 }

+24 -23

appview/pulls/pulls.go

··· 740 740 } 741 741 defer tx.Rollback() 742 742 743 743 - createdAt := time.Now().Format(time.RFC3339) 743 743 + comment := models.Comment{ 744 744 + Did: syntax.DID(user.Did), 745 745 + Rkey: tid.TID(), 746 746 + Subject: pull.AtUri(), 747 747 + ReplyTo: nil, 748 748 + Body: body, 749 749 + Created: time.Now(), 750 750 + Mentions: mentions, 751 751 + References: references, 752 752 + PullSubmissionId: &pull.Submissions[roundNumber].ID, 753 753 + } 754 754 + if err = comment.Validate(); err != nil { 755 755 + log.Println("failed to validate comment", err) 756 756 + s.pages.Notice(w, "pull-comment", "Failed to create comment.") 757 757 + return 758 758 + } 759 759 + record := comment.AsRecord() 744 760 745 761 client, err := s.oauth.AuthorizedClient(r) 746 762 if err != nil { ··· 748 764 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 749 765 return 750 766 } 751 751 - atResp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 752 752 - Collection: tangled.RepoPullCommentNSID, 767 767 + _, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 768 768 + Collection: tangled.CommentNSID, 753 769 Repo: user.Did, 754 754 - Rkey: tid.TID(), 770 770 + Rkey: comment.Rkey, 755 771 Record: &lexutil.LexiconTypeDecoder{ 756 756 - Val: &tangled.RepoPullComment{ 757 757 - Pull: pull.AtUri().String(), 758 758 - Body: body, 759 759 - CreatedAt: createdAt, 760 760 - }, 772 772 + Val: &record, 761 773 }, 762 774 }) 763 775 if err != nil { ··· 766 778 return 767 779 } 768 780 769 769 - comment := &models.PullComment{ 770 770 - OwnerDid: user.Did, 771 771 - RepoAt: f.RepoAt().String(), 772 772 - PullId: pull.PullId, 773 773 - Body: body, 774 774 - CommentAt: atResp.Uri, 775 775 - SubmissionId: pull.Submissions[roundNumber].ID, 776 776 - Mentions: mentions, 777 777 - References: references, 778 778 - } 779 779 - 780 781 // Create the pull comment in the database with the commentAt field 781 781 - commentId, err := db.NewPullComment(tx, comment) 782 782 + err = db.PutComment(tx, &comment) 782 783 if err != nil { 783 784 log.Println("failed to create pull comment", err) 784 785 s.pages.Notice(w, "pull-comment", "Failed to create comment.") ··· 792 793 return 793 794 } 794 795 795 795 - s.notifier.NewPullComment(r.Context(), comment, mentions) 796 796 + s.notifier.NewPullComment(r.Context(), &comment, mentions) 796 797 797 798 ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f) 798 798 - s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId)) 799 799 + s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, comment.Id)) 799 800 return 800 801 } 801 802 }