appview: ingest issue/comment update and delete #526

···

       
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
       
629
       
 
       
func DeleteCommentByRkey(e Execer, ownerDid, rkey string) error {

     

       
641
       
630
       
 
       
	_, err := e.Exec(

     

       
642
       
631
       
 
       
		`

     
···

       
648
       
637
       
 
       
	return err

     

       
649
       
638
       
 
       
}

     

       
650
       
639
       
 
       


     

       
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)

     

       
658
       
658
       
-
       
	return err

     

       
659
       
659
       
-
       
}

     

       
660
       
660
       
-
       


     

       
661
       
640
       
 
       
func CloseIssue(e Execer, repoAt syntax.ATURI, issueId int) error {

     

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

     

       
663
       
642
       
 
       
	return err

     

···

       
824
       
824
       
 
       
		return nil

     

       
825
       
825
       
 
       


     

       
826
       
826
       
 
       
	case models.CommitOperationUpdate:

     

       
827
       
827
       
+
       
		// TODO: implement updates

     

       
827
       
827
       
-
       
		raw := json.RawMessage(e.Commit.Record)

     

       
828
       
828
       
-
       
		record := tangled.RepoIssue{}

     

       
829
       
829
       
-
       
		err = json.Unmarshal(raw, &record)

     

       
830
       
830
       
-
       
		if err != nil {

     

       
831
       
831
       
-
       
			l.Error("invalid record", "err", err)

     

       
832
       
832
       
-
       
			return err

     

       
833
       
833
       
-
       
		}

     

       
834
       
834
       
-
       


     

       
835
       
835
       
-
       
		body := ""

     

       
836
       
836
       
-
       
		if record.Body != nil {

     

       
837
       
837
       
-
       
			body = *record.Body

     

       
838
       
838
       
-
       
		}

     

       
839
       
839
       
-
       


     

       
840
       
840
       
-
       
		sanitizer := markup.NewSanitizer()

     

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

     

       
842
       
842
       
-
       
			return fmt.Errorf("title is empty after HTML sanitization")

     

       
843
       
843
       
-
       
		}

     

       
844
       
844
       
-
       
		if sb := strings.TrimSpace(sanitizer.SanitizeDefault(body)); sb == "" {

     

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

     

       
846
       
846
       
-
       
		}

     

       
847
       
847
       
-
       


     

       
848
       
848
       
-
       
		err = db.UpdateIssueByRkey(ddb, did, rkey, record.Title, body)

     

       
849
       
849
       
-
       
		if err != nil {

     

       
850
       
850
       
-
       
			l.Error("failed to update issue", "err", err)

     

       
851
       
851
       
-
       
			return err

     

       
852
       
852
       
-
       
		}

     

       
853
       
853
       
-
       


     

       
854
       
828
       
 
       
		return nil

     

       
855
       
829
       
 
       


     

       
856
       
830
       
 
       
	case models.CommitOperationDelete:

     

       
831
       
831
       
+
       
		// TODO: implement issue deletion

     

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

     

       
858
       
858
       
-
       
			l.Error("failed to delete", "err", err)

     

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

     

       
860
       
860
       
-
       
		}

     

       
861
       
861
       
-
       


     

       
862
       
832
       
 
       
		return nil

     

       
863
       
833
       
 
       
	}

     

       
864
       
834
       
 
       


     
···

       
909
       
879
       
 
       
		return nil

     

       
910
       
880
       
 
       


     

       
911
       
881
       
 
       
	case models.CommitOperationUpdate:

     

       
882
       
882
       
+
       
		// TODO: implement comment updates

     

       
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
       
883
       
 
       
		return nil

     

       
932
       
884
       
 
       


     

       
933
       
885
       
 
       
	case models.CommitOperationDelete:

     

···

       
5726
       
5726
       
 
       
		return err

     

       
5727
       
5727
       
 
       
	}

     

       
5728
       
5728
       
 
       


     

       
5729
       
5729
       
-
       
	// t.Owner (string) (string)

     

       
5730
       
5730
       
-
       
	if len("owner") > 1000000 {

     

       
5731
       
5731
       
-
       
		return xerrors.Errorf("Value in field \"owner\" was too long")

     

       
5732
       
5732
       
-
       
	}

     

       
5733
       
5733
       
-
       


     

       
5734
       
5734
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {

     

       
5735
       
5735
       
-
       
		return err

     

       
5736
       
5736
       
-
       
	}

     

       
5737
       
5737
       
-
       
	if _, err := cw.WriteString(string("owner")); err != nil {

     

       
5738
       
5738
       
-
       
		return err

     

       
5739
       
5739
       
-
       
	}

     

       
5740
       
5740
       
-
       


     

       
5741
       
5741
       
-
       
	if len(t.Owner) > 1000000 {

     

       
5742
       
5742
       
-
       
		return xerrors.Errorf("Value in field t.Owner was too long")

     

       
5743
       
5743
       
-
       
	}

     

       
5744
       
5744
       
-
       


     

       
5745
       
5745
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {

     

       
5746
       
5746
       
-
       
		return err

     

       
5747
       
5747
       
-
       
	}

     

       
5748
       
5748
       
-
       
	if _, err := cw.WriteString(string(t.Owner)); err != nil {

     

       
5749
       
5749
       
-
       
		return err

     

       
5750
       
5750
       
-
       
	}

     

       
5751
       
5751
       
-
       


     

       
5752
       
5729
       
 
       
	// t.Title (string) (string)

     

       
5753
       
5730
       
 
       
	if len("title") > 1000000 {

     

       
5754
       
5731
       
 
       
		return xerrors.Errorf("Value in field \"title\" was too long")

     
···

       
5881
       
5858
       
 
       


     

       
5882
       
5859
       
 
       
				t.LexiconTypeID = string(sval)

     

       
5883
       
5860
       
 
       
			}

     

       
5884
       
5884
       
-
       
			// t.Owner (string) (string)

     

       
5885
       
5885
       
-
       
		case "owner":

     

       
5886
       
5886
       
-
       


     

       
5887
       
5887
       
-
       
			{

     

       
5888
       
5888
       
-
       
				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       
5889
       
5889
       
-
       
				if err != nil {

     

       
5890
       
5890
       
-
       
					return err

     

       
5891
       
5891
       
-
       
				}

     

       
5892
       
5892
       
-
       


     

       
5893
       
5893
       
-
       
				t.Owner = string(sval)

     

       
5894
       
5894
       
-
       
			}

     

       
5895
       
5861
       
 
       
			// t.Title (string) (string)

     

       
5896
       
5862
       
 
       
		case "title":

     

       
5897
       
5863