commit a3950990c42cf2ce2012415293598410df845827 · veryroundbird.house/core

+40 -6

appview/db/issues.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"database/sql"

     

       5
       5
        
       	"fmt"

     

       6
       6
       +
       	mathrand "math/rand/v2"

     

       6
       7
        
       	"strings"

     

       7
       8
        
       	"time"

     

       8
       9
        
       

     
···

       109
       110
        
       	}

     

       110
       111
        
       

     

       111
       112
        
       	comment := Comment{

     

       112
       112
       -
       		OwnerDid: ownerDid,

     

       113
       113
       -
       		RepoAt:   repoAt,

     

       114
       114
       -
       		Rkey:     rkey,

     

       115
       115
       -
       		Body:     record.Body,

     

       116
       116
       -
       		Issue:    issueId,

     

       117
       117
       -
       		Created:  &created,

     

       113
       113
       +
       		OwnerDid:  ownerDid,

     

       114
       114
       +
       		RepoAt:    repoAt,

     

       115
       115
       +
       		Rkey:      rkey,

     

       116
       116
       +
       		Body:      record.Body,

     

       117
       117
       +
       		Issue:     issueId,

     

       118
       118
       +
       		CommentId: mathrand.IntN(1000000),

     

       119
       119
       +
       		Created:   &created,

     

       118
       120
        
       	}

     

       119
       121
        
       

     

       120
       122
        
       	return comment, nil

     
···

       621
       623
        
       			deleted = strftime('%Y-%m-%dT%H:%M:%SZ', 'now')

     

       622
       624
        
       		where repo_at = ? and issue_id = ? and comment_id = ?

     

       623
       625
        
       		`, repoAt, issueId, commentId)

     

       626
       626
       +
       	return err

     

       627
       627
       +
       }

     

       628
       628
       +
       

     

       629
       629
       +
       func UpdateCommentByRkey(e Execer, ownerDid, rkey, newBody string) error {

     

       630
       630
       +
       	_, err := e.Exec(

     

       631
       631
       +
       		`

     

       632
       632
       +
       		update comments

     

       633
       633
       +
       		set body = ?,

     

       634
       634
       +
       			edited = strftime('%Y-%m-%dT%H:%M:%SZ', 'now')

     

       635
       635
       +
       		where owner_did = ? and rkey = ?

     

       636
       636
       +
       		`, newBody, ownerDid, rkey)

     

       637
       637
       +
       	return err

     

       638
       638
       +
       }

     

       639
       639
       +
       

     

       640
       640
       +
       func DeleteCommentByRkey(e Execer, ownerDid, rkey string) error {

     

       641
       641
       +
       	_, err := e.Exec(

     

       642
       642
       +
       		`

     

       643
       643
       +
       		update comments

     

       644
       644
       +
       		set body = "",

     

       645
       645
       +
       			deleted = strftime('%Y-%m-%dT%H:%M:%SZ', 'now')

     

       646
       646
       +
       		where owner_did = ? and rkey = ?

     

       647
       647
       +
       		`, ownerDid, rkey)

     

       648
       648
       +
       	return err

     

       649
       649
       +
       }

     

       650
       650
       +
       

     

       651
       651
       +
       func UpdateIssueByRkey(e Execer, ownerDid, rkey, title, body string) error {

     

       652
       652
       +
       	_, err := e.Exec(`update issues set title = ?, body = ? where owner_did = ? and rkey = ?`, title, body, ownerDid, rkey)

     

       653
       653
       +
       	return err

     

       654
       654
       +
       }

     

       655
       655
       +
       

     

       656
       656
       +
       func DeleteIssueByRkey(e Execer, ownerDid, rkey string) error {

     

       657
       657
       +
       	_, err := e.Exec(`delete from issues where owner_did = ? and rkey = ?`, ownerDid, rkey)

     

       624
       658
        
       	return err

     

       625
       659
        
       }

     

       626
       660

+79

appview/ingester.go

···

       74
       74
        
       				err = i.ingestString(e)

     

       75
       75
        
       			case tangled.RepoIssueNSID:

     

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

     

       77
       77
       +
       			case tangled.RepoIssueCommentNSID:

     

       78
       78
       +
       				err = i.ingestIssueComment(e)

     

       77
       79
        
       			}

     

       78
       80
        
       			l = i.Logger.With("nsid", e.Commit.Collection)

     

       79
       81
        
       		}

     
···

       862
       864
        
       

     

       863
       865
        
       	return fmt.Errorf("unknown operation: %s", e.Commit.Operation)

     

       864
       866
        
       }

     

       867
       867
       +
       

     

       868
       868
       +
       func (i *Ingester) ingestIssueComment(e *models.Event) error {

     

       869
       869
       +
       	did := e.Did

     

       870
       870
       +
       	rkey := e.Commit.RKey

     

       871
       871
       +
       

     

       872
       872
       +
       	var err error

     

       873
       873
       +
       

     

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

     

       875
       875
       +
       	l.Info("ingesting record")

     

       876
       876
       +
       

     

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

     

       878
       878
       +
       	if !ok {

     

       879
       879
       +
       		return fmt.Errorf("failed to index issue comment record, invalid db cast")

     

       880
       880
       +
       	}

     

       881
       881
       +
       

     

       882
       882
       +
       	switch e.Commit.Operation {

     

       883
       883
       +
       	case models.CommitOperationCreate:

     

       884
       884
       +
       		raw := json.RawMessage(e.Commit.Record)

     

       885
       885
       +
       		record := tangled.RepoIssueComment{}

     

       886
       886
       +
       		err = json.Unmarshal(raw, &record)

     

       887
       887
       +
       		if err != nil {

     

       888
       888
       +
       			l.Error("invalid record", "err", err)

     

       889
       889
       +
       			return err

     

       890
       890
       +
       		}

     

       891
       891
       +
       

     

       892
       892
       +
       		comment, err := db.IssueCommentFromRecord(ddb, did, rkey, record)

     

       893
       893
       +
       		if err != nil {

     

       894
       894
       +
       			l.Error("failed to parse comment from record", "err", err)

     

       895
       895
       +
       			return err

     

       896
       896
       +
       		}

     

       897
       897
       +
       

     

       898
       898
       +
       		sanitizer := markup.NewSanitizer()

     

       899
       899
       +
       		if sb := strings.TrimSpace(sanitizer.SanitizeDefault(comment.Body)); sb == "" {

     

       900
       900
       +
       			return fmt.Errorf("body is empty after HTML sanitization")

     

       901
       901
       +
       		}

     

       902
       902
       +
       

     

       903
       903
       +
       		err = db.NewIssueComment(ddb, &comment)

     

       904
       904
       +
       		if err != nil {

     

       905
       905
       +
       			l.Error("failed to create issue comment", "err", err)

     

       906
       906
       +
       			return err

     

       907
       907
       +
       		}

     

       908
       908
       +
       

     

       909
       909
       +
       		return nil

     

       910
       910
       +
       

     

       911
       911
       +
       	case models.CommitOperationUpdate:

     

       912
       912
       +
       		raw := json.RawMessage(e.Commit.Record)

     

       913
       913
       +
       		record := tangled.RepoIssueComment{}

     

       914
       914
       +
       		err = json.Unmarshal(raw, &record)

     

       915
       915
       +
       		if err != nil {

     

       916
       916
       +
       			l.Error("invalid record", "err", err)

     

       917
       917
       +
       			return err

     

       918
       918
       +
       		}

     

       919
       919
       +
       

     

       920
       920
       +
       		sanitizer := markup.NewSanitizer()

     

       921
       921
       +
       		if sb := strings.TrimSpace(sanitizer.SanitizeDefault(record.Body)); sb == "" {

     

       922
       922
       +
       			return fmt.Errorf("body is empty after HTML sanitization")

     

       923
       923
       +
       		}

     

       924
       924
       +
       

     

       925
       925
       +
       		err = db.UpdateCommentByRkey(ddb, did, rkey, record.Body)

     

       926
       926
       +
       		if err != nil {

     

       927
       927
       +
       			l.Error("failed to update issue comment", "err", err)

     

       928
       928
       +
       			return err

     

       929
       929
       +
       		}

     

       930
       930
       +
       

     

       931
       931
       +
       		return nil

     

       932
       932
       +
       

     

       933
       933
       +
       	case models.CommitOperationDelete:

     

       934
       934
       +
       		if err := db.DeleteCommentByRkey(ddb, did, rkey); err != nil {

     

       935
       935
       +
       			l.Error("failed to delete", "err", err)

     

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

     

       937
       937
       +
       		}

     

       938
       938
       +
       

     

       939
       939
       +
       		return nil

     

       940
       940
       +
       	}

     

       941
       941
       +
       

     

       942
       942
       +
       	return fmt.Errorf("unknown operation: %s", e.Commit.Operation)

     

       943
       943
       +
       }

appview/state/state.go

···

       100
       100
        
       			tangled.SpindleNSID,

     

       101
       101
        
       			tangled.StringNSID,

     

       102
       102
        
       			tangled.RepoIssueNSID,

     

       103
       103
       +
       			tangled.RepoIssueCommentNSID,

     

       103
       104
        
       		},

     

       104
       105
        
       		nil,

     

       105
       106
        
       		slog.Default(),