back round 0 view raw

appview: ingest issue/comment update and delete #526

merged

opened by

anirudh.fi 3 months ago targeting master from push-wnotmtoqlnvl

Also adds the relevant DB helpers for this.

Signed-off-by: Anirudh Oppiliappan anirudh@tangled.sh

options

unified split

Changed files

+72 -3

appview

issues.go

ingester.go

+21

appview/db/issues.go

···

       545
       545
        
       	return err

     

       546
       546
        
       }

     

       547
       547
        
       

     

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

     

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

     

       550
       550
       +
       		`

     

       551
       551
       +
       		update comments

     

       552
       552
       +
       		set body = ?,

     

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

     

       554
       554
       +
       		where owner_did = ? and rkey = ?

     

       555
       555
       +
       		`, newBody, ownerDid, rkey)

     

       556
       556
       +
       	return err

     

       557
       557
       +
       }

     

       558
       558
       +
       

     

       548
       559
        
       func DeleteCommentByRkey(e Execer, ownerDid, rkey string) error {

     

       549
       560
        
       	_, err := e.Exec(

     

       550
       561
        
       		`

     
···

       556
       567
        
       	return err

     

       557
       568
        
       }

     

       558
       569
        
       

     

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

     

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

     

       572
       572
       +
       	return err

     

       573
       573
       +
       }

     

       574
       574
       +
       

     

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

     

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

     

       577
       577
       +
       	return err

     

       578
       578
       +
       }

     

       579
       579
       +
       

     

       559
       580
        
       func CloseIssue(e Execer, repoAt syntax.ATURI, issueId int) error {

     

       560
       581
        
       	_, err := e.Exec(`update issues set open = 0 where repo_at = ? and issue_id = ?`, repoAt, issueId)

     

       561
       582
        
       	return err

+51 -3

appview/ingester.go

···

       665
       665
        
       		return nil

     

       666
       666
        
       

     

       667
       667
        
       	case models.CommitOperationUpdate:

     

       668
       668
       -
       		// TODO: implement updates

     

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

     

       669
       669
       +
       		record := tangled.RepoIssue{}

     

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

     

       671
       671
       +
       		if err != nil {

     

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

     

       673
       673
       +
       			return err

     

       674
       674
       +
       		}

     

       675
       675
       +
       

     

       676
       676
       +
       		body := ""

     

       677
       677
       +
       		if record.Body != nil {

     

       678
       678
       +
       			body = *record.Body

     

       679
       679
       +
       		}

     

       680
       680
       +
       

     

       681
       681
       +
       		sanitizer := markup.NewSanitizer()

     

       682
       682
       +
       		if st := strings.TrimSpace(sanitizer.SanitizeDescription(record.Title)); st == "" {

     

       683
       683
       +
       			return fmt.Errorf("title is empty after HTML sanitization")

     

       684
       684
       +
       		}

     

       685
       685
       +
       		if sb := strings.TrimSpace(sanitizer.SanitizeDefault(body)); sb == "" {

     

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

     

       687
       687
       +
       		}

     

       688
       688
       +
       

     

       689
       689
       +
       		err = db.UpdateIssueByRkey(ddb, did, rkey, record.Title, body)

     

       690
       690
       +
       		if err != nil {

     

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

     

       692
       692
       +
       			return err

     

       693
       693
       +
       		}

     

       694
       694
       +
       

     

       669
       695
        
       		return nil

     

       670
       696
        
       

     

       671
       697
        
       	case models.CommitOperationDelete:

     

       672
       672
       -
       		// TODO: implement issue deletion

     

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

     

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

     

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

     

       701
       701
       +
       		}

     

       702
       702
       +
       

     

       673
       703
        
       		return nil

     

       674
       704
        
       	}

     

       675
       705
        
       

     
···

       720
       750
        
       		return nil

     

       721
       751
        
       

     

       722
       752
        
       	case models.CommitOperationUpdate:

     

       723
       723
       -
       		// TODO: implement comment updates

     

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

     

       754
       754
       +
       		record := tangled.RepoIssueComment{}

     

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

     

       756
       756
       +
       		if err != nil {

     

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

     

       758
       758
       +
       			return err

     

       759
       759
       +
       		}

     

       760
       760
       +
       

     

       761
       761
       +
       		sanitizer := markup.NewSanitizer()

     

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

     

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

     

       764
       764
       +
       		}

     

       765
       765
       +
       

     

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

     

       767
       767
       +
       		if err != nil {

     

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

     

       769
       769
       +
       			return err

     

       770
       770
       +
       		}

     

       771
       771
       +
       

     

       724
       772
        
       		return nil

     

       725
       773
        
       

     

       726
       774
        
       	case models.CommitOperationDelete: