···

       
6
       
6
       
 
       
	"fmt"

     

       
7
       
7
       
 
       
	"log/slog"

     

       
8
       
8
       
 
       
	"strings"

     

       
9
       
9
       
+
       


     

       
9
       
10
       
 
       
	"time"

     

       
10
       
11
       
 
       


     

       
11
       
12
       
 
       
	"github.com/bluesky-social/indigo/atproto/syntax"

     
···

       
790
       
791
       
 
       
	}

     

       
791
       
792
       
 
       


     

       
792
       
793
       
 
       
	switch e.Commit.Operation {

     

       
793
       
793
       
-
       
	case models.CommitOperationCreate:

     

       
794
       
794
       
+
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

       
794
       
795
       
 
       
		raw := json.RawMessage(e.Commit.Record)

     

       
795
       
796
       
 
       
		record := tangled.RepoIssue{}

     

       
796
       
797
       
 
       
		err = json.Unmarshal(raw, &record)

     
···

       
814
       
815
       
 
       
			l.Error("failed to begin transaction", "err", err)

     

       
815
       
816
       
 
       
			return err

     

       
816
       
817
       
 
       
		}

     

       
818
       
818
       
+
       
		defer tx.Rollback()

     

       
817
       
819
       
 
       


     

       
818
       
820
       
 
       
		err = db.NewIssue(tx, &issue)

     

       
819
       
821
       
 
       
		if err != nil {

     
···

       
821
       
823
       
 
       
			return err

     

       
822
       
824
       
 
       
		}

     

       
823
       
825
       
 
       


     

       
824
       
824
       
-
       
		return nil

     

       
825
       
825
       
-
       


     

       
826
       
826
       
-
       
	case models.CommitOperationUpdate:

     

       
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)

     

       
826
       
826
       
+
       
		err = tx.Commit()

     

       
849
       
827
       
 
       
		if err != nil {

     

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

     

       
828
       
828
       
+
       
			l.Error("failed to commit txn", "err", err)

     

       
851
       
829
       
 
       
			return err

     

       
852
       
830
       
 
       
		}

     

       
853
       
831
       
 
       


     

       
854
       
832
       
 
       
		return nil

     

       
855
       
833
       
 
       


     

       
856
       
834
       
 
       
	case models.CommitOperationDelete:

     

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

     

       
835
       
835
       
+
       
		if err := db.DeleteIssues(

     

       
836
       
836
       
+
       
			ddb,

     

       
837
       
837
       
+
       
			db.FilterEq("did", did),

     

       
838
       
838
       
+
       
			db.FilterEq("rkey", rkey),

     

       
839
       
839
       
+
       
		); err != nil {

     

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

     

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

     

       
860
       
842
       
 
       
		}

     
···

       
862
       
844
       
 
       
		return nil

     

       
863
       
845
       
 
       
	}

     

       
864
       
846
       
 
       


     

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

     

       
847
       
847
       
+
       
	return nil

     

       
866
       
848
       
 
       
}

     

       
867
       
849
       
 
       


     

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

     
···

       
880
       
862
       
 
       
	}

     

       
881
       
863
       
 
       


     

       
882
       
864
       
 
       
	switch e.Commit.Operation {

     

       
883
       
883
       
-
       
	case models.CommitOperationCreate:

     

       
865
       
865
       
+
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

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

     

       
885
       
867
       
 
       
		record := tangled.RepoIssueComment{}

     

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

     
···

       
898
       
880
       
 
       
			return fmt.Errorf("body is empty after HTML sanitization")

     

       
899
       
881
       
 
       
		}

     

       
900
       
882
       
 
       


     

       
901
       
901
       
-
       
		err = db.NewIssueComment(ddb, &comment)

     

       
883
       
883
       
+
       
		_, err = db.AddIssueComment(ddb, *comment)

     

       
902
       
884
       
 
       
		if err != nil {

     

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

     

       
904
       
886
       
 
       
		}

     

       
905
       
887
       
 
       


     

       
906
       
888
       
 
       
		return nil

     

       
907
       
889
       
 
       


     

       
908
       
908
       
-
       
	case models.CommitOperationUpdate:

     

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

     

       
910
       
910
       
-
       
		record := tangled.RepoIssueComment{}

     

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

     

       
912
       
912
       
-
       
		if err != nil {

     

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

     

       
914
       
914
       
-
       
		}

     

       
915
       
915
       
-
       


     

       
916
       
916
       
-
       
		sanitizer := markup.NewSanitizer()

     

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

     

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

     

       
919
       
919
       
-
       
		}

     

       
920
       
920
       
-
       


     

       
921
       
921
       
-
       
		err = db.UpdateCommentByRkey(ddb, did, rkey, record.Body)

     

       
922
       
922
       
-
       
		if err != nil {

     

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

     

       
924
       
924
       
-
       
		}

     

       
925
       
925
       
-
       


     

       
926
       
926
       
-
       
		return nil

     

       
927
       
927
       
-
       


     

       
928
       
890
       
 
       
	case models.CommitOperationDelete:

     

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

     

       
891
       
891
       
+
       
		if err := db.DeleteIssueComments(

     

       
892
       
892
       
+
       
			ddb,

     

       
893
       
893
       
+
       
			db.FilterEq("did", did),

     

       
894
       
894
       
+
       
			db.FilterEq("rkey", rkey),

     

       
895
       
895
       
+
       
		); err != nil {

     

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

     

       
931
       
897
       
 
       
		}

     

       
932
       
898
       
 
       


     

       
933
       
899
       
 
       
		return nil

     

       
934
       
900
       
 
       
	}

     

       
935
       
901
       
 
       


     

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

     

       
902
       
902
       
+
       
	return nil

     

       
937
       
903
       
 
       
}