···

       
6
       
 
       
	"fmt"

     

       
7
       
 
       
	"log/slog"

     

       
8
       
 
       
	"strings"

     

       
0
       
 
       

     

       
9
       
 
       
	"time"

     

       
10
       
 
       


     

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

     
···

       
790
       
 
       
	}

     

       
791
       
 
       


     

       
792
       
 
       
	switch e.Commit.Operation {

     

       
793
       
-
       
	case models.CommitOperationCreate:

     

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

     

       
795
       
 
       
		record := tangled.RepoIssue{}

     

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

     
···

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

     

       
815
       
 
       
			return err

     

       
816
       
 
       
		}

     

       
0
       
 
       

     

       
817
       
 
       


     

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

     

       
819
       
 
       
		if err != nil {

     
···

       
821
       
 
       
			return err

     

       
822
       
 
       
		}

     

       
823
       
 
       


     

       
824
       
-
       
		return nil

     

       
825
       
-
       


     

       
826
       
-
       
	case models.CommitOperationUpdate:

     

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

     

       
828
       
-
       
		record := tangled.RepoIssue{}

     

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

     

       
830
       
-
       
		if err != nil {

     

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

     

       
832
       
-
       
			return err

     

       
833
       
-
       
		}

     

       
834
       
-
       


     

       
835
       
-
       
		body := ""

     

       
836
       
-
       
		if record.Body != nil {

     

       
837
       
-
       
			body = *record.Body

     

       
838
       
-
       
		}

     

       
839
       
-
       


     

       
840
       
-
       
		sanitizer := markup.NewSanitizer()

     

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

     

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

     

       
843
       
-
       
		}

     

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

     

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

     

       
846
       
-
       
		}

     

       
847
       
-
       


     

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

     

       
849
       
 
       
		if err != nil {

     

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

     

       
851
       
 
       
			return err

     

       
852
       
 
       
		}

     

       
853
       
 
       


     

       
854
       
 
       
		return nil

     

       
855
       
 
       


     

       
856
       
 
       
	case models.CommitOperationDelete:

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

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

     

       
860
       
 
       
		}

     
···

       
862
       
 
       
		return nil

     

       
863
       
 
       
	}

     

       
864
       
 
       


     

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

     

       
866
       
 
       
}

     

       
867
       
 
       


     

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

     
···

       
880
       
 
       
	}

     

       
881
       
 
       


     

       
882
       
 
       
	switch e.Commit.Operation {

     

       
883
       
-
       
	case models.CommitOperationCreate:

     

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

     

       
885
       
 
       
		record := tangled.RepoIssueComment{}

     

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

     
···

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

     

       
899
       
 
       
		}

     

       
900
       
 
       


     

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

     

       
902
       
 
       
		if err != nil {

     

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

     

       
904
       
 
       
		}

     

       
905
       
 
       


     

       
906
       
 
       
		return nil

     

       
907
       
 
       


     

       
908
       
-
       
	case models.CommitOperationUpdate:

     

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

     

       
910
       
-
       
		record := tangled.RepoIssueComment{}

     

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

     

       
912
       
-
       
		if err != nil {

     

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

     

       
914
       
-
       
		}

     

       
915
       
-
       


     

       
916
       
-
       
		sanitizer := markup.NewSanitizer()

     

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

     

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

     

       
919
       
-
       
		}

     

       
920
       
-
       


     

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

     

       
922
       
-
       
		if err != nil {

     

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

     

       
924
       
-
       
		}

     

       
925
       
-
       


     

       
926
       
-
       
		return nil

     

       
927
       
-
       


     

       
928
       
 
       
	case models.CommitOperationDelete:

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
931
       
 
       
		}

     

       
932
       
 
       


     

       
933
       
 
       
		return nil

     

       
934
       
 
       
	}

     

       
935
       
 
       


     

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

     

       
937
       
 
       
}

     

···

       
6
       
 
       
	"fmt"

     

       
7
       
 
       
	"log/slog"

     

       
8
       
 
       
	"strings"

     

       
9
       
+
       


     

       
10
       
 
       
	"time"

     

       
11
       
 
       


     

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

     
···

       
791
       
 
       
	}

     

       
792
       
 
       


     

       
793
       
 
       
	switch e.Commit.Operation {

     

       
794
       
+
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

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

     

       
796
       
 
       
		record := tangled.RepoIssue{}

     

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

     
···

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

     

       
816
       
 
       
			return err

     

       
817
       
 
       
		}

     

       
818
       
+
       
		defer tx.Rollback()

     

       
819
       
 
       


     

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

     

       
821
       
 
       
		if err != nil {

     
···

       
823
       
 
       
			return err

     

       
824
       
 
       
		}

     

       
825
       
 
       


     

       
826
       
+
       
		err = tx.Commit()

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
827
       
 
       
		if err != nil {

     

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

     

       
829
       
 
       
			return err

     

       
830
       
 
       
		}

     

       
831
       
 
       


     

       
832
       
 
       
		return nil

     

       
833
       
 
       


     

       
834
       
 
       
	case models.CommitOperationDelete:

     

       
835
       
+
       
		if err := db.DeleteIssues(

     

       
836
       
+
       
			ddb,

     

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

     

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

     

       
839
       
+
       
		); err != nil {

     

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

     

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

     

       
842
       
 
       
		}

     
···

       
844
       
 
       
		return nil

     

       
845
       
 
       
	}

     

       
846
       
 
       


     

       
847
       
+
       
	return nil

     

       
848
       
 
       
}

     

       
849
       
 
       


     

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

     
···

       
862
       
 
       
	}

     

       
863
       
 
       


     

       
864
       
 
       
	switch e.Commit.Operation {

     

       
865
       
+
       
	case models.CommitOperationCreate, models.CommitOperationUpdate:

     

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

     

       
867
       
 
       
		record := tangled.RepoIssueComment{}

     

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

     
···

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

     

       
881
       
 
       
		}

     

       
882
       
 
       


     

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

     

       
884
       
 
       
		if err != nil {

     

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

     

       
886
       
 
       
		}

     

       
887
       
 
       


     

       
888
       
 
       
		return nil

     

       
889
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
890
       
 
       
	case models.CommitOperationDelete:

     

       
891
       
+
       
		if err := db.DeleteIssueComments(

     

       
892
       
+
       
			ddb,

     

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

     

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

     

       
895
       
+
       
		); err != nil {

     

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

     

       
897
       
 
       
		}

     

       
898
       
 
       


     

       
899
       
 
       
		return nil

     

       
900
       
 
       
	}

     

       
901
       
 
       


     

       
902
       
+
       
	return nil

     

       
903
       
 
       
}