···

       
5642
       
5642
       
 
       
	}

     

       
5643
       
5643
       
 
       


     

       
5644
       
5644
       
 
       
	cw := cbg.NewCborWriter(w)

     

       
5645
       
5645
       
-
       
	fieldCount := 7

     

       
5645
       
5645
       
+
       
	fieldCount := 5

     

       
5646
       
5646
       
 
       


     

       
5647
       
5647
       
 
       
	if t.Body == nil {

     

       
5648
       
5648
       
 
       
		fieldCount--

     
···

       
5772
       
5772
       
 
       
		return err

     

       
5773
       
5773
       
 
       
	}

     

       
5774
       
5774
       
 
       


     

       
5775
       
5775
       
-
       
	// t.IssueId (int64) (int64)

     

       
5776
       
5776
       
-
       
	if len("issueId") > 1000000 {

     

       
5777
       
5777
       
-
       
		return xerrors.Errorf("Value in field \"issueId\" was too long")

     

       
5778
       
5778
       
-
       
	}

     

       
5779
       
5779
       
-
       


     

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

     

       
5781
       
5781
       
-
       
		return err

     

       
5782
       
5782
       
-
       
	}

     

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

     

       
5784
       
5784
       
-
       
		return err

     

       
5785
       
5785
       
-
       
	}

     

       
5786
       
5786
       
-
       


     

       
5787
       
5787
       
-
       
	if t.IssueId >= 0 {

     

       
5788
       
5788
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {

     

       
5789
       
5789
       
-
       
			return err

     

       
5790
       
5790
       
-
       
		}

     

       
5791
       
5791
       
-
       
	} else {

     

       
5792
       
5792
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {

     

       
5793
       
5793
       
-
       
			return err

     

       
5794
       
5794
       
-
       
		}

     

       
5795
       
5795
       
-
       
	}

     

       
5796
       
5796
       
-
       


     

       
5797
       
5775
       
 
       
	// t.CreatedAt (string) (string)

     

       
5798
       
5776
       
 
       
	if len("createdAt") > 1000000 {

     

       
5799
       
5777
       
 
       
		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

       
5925
       
5903
       
 
       


     

       
5926
       
5904
       
 
       
				t.Title = string(sval)

     

       
5927
       
5905
       
 
       
			}

     

       
5928
       
5928
       
-
       
			// t.IssueId (int64) (int64)

     

       
5929
       
5929
       
-
       
		case "issueId":

     

       
5930
       
5930
       
-
       
			{

     

       
5931
       
5931
       
-
       
				maj, extra, err := cr.ReadHeader()

     

       
5932
       
5932
       
-
       
				if err != nil {

     

       
5933
       
5933
       
-
       
					return err

     

       
5934
       
5934
       
-
       
				}

     

       
5935
       
5935
       
-
       
				var extraI int64

     

       
5936
       
5936
       
-
       
				switch maj {

     

       
5937
       
5937
       
-
       
				case cbg.MajUnsignedInt:

     

       
5938
       
5938
       
-
       
					extraI = int64(extra)

     

       
5939
       
5939
       
-
       
					if extraI < 0 {

     

       
5940
       
5940
       
-
       
						return fmt.Errorf("int64 positive overflow")

     

       
5941
       
5941
       
-
       
					}

     

       
5942
       
5942
       
-
       
				case cbg.MajNegativeInt:

     

       
5943
       
5943
       
-
       
					extraI = int64(extra)

     

       
5944
       
5944
       
-
       
					if extraI < 0 {

     

       
5945
       
5945
       
-
       
						return fmt.Errorf("int64 negative overflow")

     

       
5946
       
5946
       
-
       
					}

     

       
5947
       
5947
       
-
       
					extraI = -1 - extraI

     

       
5948
       
5948
       
-
       
				default:

     

       
5949
       
5949
       
-
       
					return fmt.Errorf("wrong type for int64 field: %d", maj)

     

       
5950
       
5950
       
-
       
				}

     

       
5951
       
5951
       
-
       


     

       
5952
       
5952
       
-
       
				t.IssueId = int64(extraI)

     

       
5953
       
5953
       
-
       
			}

     

       
5954
       
5906
       
 
       
			// t.CreatedAt (string) (string)

     

       
5955
       
5907
       
 
       
		case "createdAt":

     

       
5956
       
5908
       
 
       


     
···

       
5980
       
5932
       
 
       
	}

     

       
5981
       
5933
       
 
       


     

       
5982
       
5934
       
 
       
	cw := cbg.NewCborWriter(w)

     

       
5983
       
5983
       
-
       
	fieldCount := 7

     

       
5984
       
5984
       
-
       


     

       
5985
       
5985
       
-
       
	if t.CommentId == nil {

     

       
5986
       
5986
       
-
       
		fieldCount--

     

       
5987
       
5987
       
-
       
	}

     

       
5935
       
5935
       
+
       
	fieldCount := 6

     

       
5988
       
5936
       
 
       


     

       
5989
       
5937
       
 
       
	if t.Owner == nil {

     

       
5990
       
5938
       
 
       
		fieldCount--

     
···

       
6127
       
6075
       
 
       
		}

     

       
6128
       
6076
       
 
       
	}

     

       
6129
       
6077
       
 
       


     

       
6130
       
6130
       
-
       
	// t.CommentId (int64) (int64)

     

       
6131
       
6131
       
-
       
	if t.CommentId != nil {

     

       
6132
       
6132
       
-
       


     

       
6133
       
6133
       
-
       
		if len("commentId") > 1000000 {

     

       
6134
       
6134
       
-
       
			return xerrors.Errorf("Value in field \"commentId\" was too long")

     

       
6135
       
6135
       
-
       
		}

     

       
6136
       
6136
       
-
       


     

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

     

       
6138
       
6138
       
-
       
			return err

     

       
6139
       
6139
       
-
       
		}

     

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

     

       
6141
       
6141
       
-
       
			return err

     

       
6142
       
6142
       
-
       
		}

     

       
6143
       
6143
       
-
       


     

       
6144
       
6144
       
-
       
		if t.CommentId == nil {

     

       
6145
       
6145
       
-
       
			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       
6146
       
6146
       
-
       
				return err

     

       
6147
       
6147
       
-
       
			}

     

       
6148
       
6148
       
-
       
		} else {

     

       
6149
       
6149
       
-
       
			if *t.CommentId >= 0 {

     

       
6150
       
6150
       
-
       
				if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {

     

       
6151
       
6151
       
-
       
					return err

     

       
6152
       
6152
       
-
       
				}

     

       
6153
       
6153
       
-
       
			} else {

     

       
6154
       
6154
       
-
       
				if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {

     

       
6155
       
6155
       
-
       
					return err

     

       
6156
       
6156
       
-
       
				}

     

       
6157
       
6157
       
-
       
			}

     

       
6158
       
6158
       
-
       
		}

     

       
6159
       
6159
       
-
       


     

       
6160
       
6160
       
-
       
	}

     

       
6161
       
6161
       
-
       


     

       
6162
       
6078
       
 
       
	// t.CreatedAt (string) (string)

     

       
6163
       
6079
       
 
       
	if len("createdAt") > 1000000 {

     

       
6164
       
6080
       
 
       
		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

       
6298
       
6214
       
 
       
					}

     

       
6299
       
6215
       
 
       


     

       
6300
       
6216
       
 
       
					t.Owner = (*string)(&sval)

     

       
6301
       
6301
       
-
       
				}

     

       
6302
       
6302
       
-
       
			}

     

       
6303
       
6303
       
-
       
			// t.CommentId (int64) (int64)

     

       
6304
       
6304
       
-
       
		case "commentId":

     

       
6305
       
6305
       
-
       
			{

     

       
6306
       
6306
       
-
       


     

       
6307
       
6307
       
-
       
				b, err := cr.ReadByte()

     

       
6308
       
6308
       
-
       
				if err != nil {

     

       
6309
       
6309
       
-
       
					return err

     

       
6310
       
6310
       
-
       
				}

     

       
6311
       
6311
       
-
       
				if b != cbg.CborNull[0] {

     

       
6312
       
6312
       
-
       
					if err := cr.UnreadByte(); err != nil {

     

       
6313
       
6313
       
-
       
						return err

     

       
6314
       
6314
       
-
       
					}

     

       
6315
       
6315
       
-
       
					maj, extra, err := cr.ReadHeader()

     

       
6316
       
6316
       
-
       
					if err != nil {

     

       
6317
       
6317
       
-
       
						return err

     

       
6318
       
6318
       
-
       
					}

     

       
6319
       
6319
       
-
       
					var extraI int64

     

       
6320
       
6320
       
-
       
					switch maj {

     

       
6321
       
6321
       
-
       
					case cbg.MajUnsignedInt:

     

       
6322
       
6322
       
-
       
						extraI = int64(extra)

     

       
6323
       
6323
       
-
       
						if extraI < 0 {

     

       
6324
       
6324
       
-
       
							return fmt.Errorf("int64 positive overflow")

     

       
6325
       
6325
       
-
       
						}

     

       
6326
       
6326
       
-
       
					case cbg.MajNegativeInt:

     

       
6327
       
6327
       
-
       
						extraI = int64(extra)

     

       
6328
       
6328
       
-
       
						if extraI < 0 {

     

       
6329
       
6329
       
-
       
							return fmt.Errorf("int64 negative overflow")

     

       
6330
       
6330
       
-
       
						}

     

       
6331
       
6331
       
-
       
						extraI = -1 - extraI

     

       
6332
       
6332
       
-
       
					default:

     

       
6333
       
6333
       
-
       
						return fmt.Errorf("wrong type for int64 field: %d", maj)

     

       
6334
       
6334
       
-
       
					}

     

       
6335
       
6335
       
-
       


     

       
6336
       
6336
       
-
       
					t.CommentId = (*int64)(&extraI)

     

       
6337
       
6217
       
 
       
				}

     

       
6338
       
6218
       
 
       
			}

     

       
6339
       
6219
       
 
       
			// t.CreatedAt (string) (string)

     

···

       
19
       
19
       
 
       
type RepoIssueComment struct {

     

       
20
       
20
       
 
       
	LexiconTypeID string  `json:"$type,const=sh.tangled.repo.issue.comment" cborgen:"$type,const=sh.tangled.repo.issue.comment"`

     

       
21
       
21
       
 
       
	Body          string  `json:"body" cborgen:"body"`

     

       
22
       
22
       
-
       
	CommentId     *int64  `json:"commentId,omitempty" cborgen:"commentId,omitempty"`

     

       
23
       
22
       
 
       
	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       
24
       
23
       
 
       
	Issue         string  `json:"issue" cborgen:"issue"`

     

       
25
       
24
       
 
       
	Owner         *string `json:"owner,omitempty" cborgen:"owner,omitempty"`

     

···

       
20
       
20
       
 
       
	LexiconTypeID string  `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"`

     

       
21
       
21
       
 
       
	Body          *string `json:"body,omitempty" cborgen:"body,omitempty"`

     

       
22
       
22
       
 
       
	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       
23
       
23
       
-
       
	IssueId       int64   `json:"issueId" cborgen:"issueId"`

     

       
24
       
24
       
-
       
	Owner         string  `json:"owner" cborgen:"owner"`

     

       
25
       
23
       
 
       
	Repo          string  `json:"repo" cborgen:"repo"`

     

       
26
       
24
       
 
       
	Title         string  `json:"title" cborgen:"title"`

     

       
27
       
25
       
 
       
}

     

···

       
278
       
278
       
 
       
		}

     

       
279
       
279
       
 
       


     

       
280
       
280
       
 
       
		createdAt := time.Now().Format(time.RFC3339)

     

       
281
       
281
       
-
       
		commentIdInt64 := int64(commentId)

     

       
282
       
281
       
 
       
		ownerDid := user.Did

     

       
283
       
282
       
 
       
		issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt)

     

       
284
       
283
       
 
       
		if err != nil {

     
···

       
302
       
301
       
 
       
				Val: &tangled.RepoIssueComment{

     

       
303
       
302
       
 
       
					Repo:      &atUri,

     

       
304
       
303
       
 
       
					Issue:     issueAt,

     

       
305
       
305
       
-
       
					CommentId: &commentIdInt64,

     

       
306
       
304
       
 
       
					Owner:     &ownerDid,

     

       
307
       
305
       
 
       
					Body:      body,

     

       
308
       
306
       
 
       
					CreatedAt: createdAt,

     
···

       
451
       
449
       
 
       
			repoAt := record["repo"].(string)

     

       
452
       
450
       
 
       
			issueAt := record["issue"].(string)

     

       
453
       
451
       
 
       
			createdAt := record["createdAt"].(string)

     

       
454
       
454
       
-
       
			commentIdInt64 := int64(commentIdInt)

     

       
455
       
452
       
 
       


     

       
456
       
453
       
 
       
			_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       
457
       
454
       
 
       
				Collection: tangled.RepoIssueCommentNSID,

     
···

       
462
       
459
       
 
       
					Val: &tangled.RepoIssueComment{

     

       
463
       
460
       
 
       
						Repo:      &repoAt,

     

       
464
       
461
       
 
       
						Issue:     issueAt,

     

       
465
       
465
       
-
       
						CommentId: &commentIdInt64,

     

       
466
       
462
       
 
       
						Owner:     &comment.OwnerDid,

     

       
467
       
463
       
 
       
						Body:      newBody,

     

       
468
       
464
       
 
       
						CreatedAt: createdAt,

     
···

       
687
       
683
       
 
       
			Rkey:       issue.Rkey,

     

       
688
       
684
       
 
       
			Record: &lexutil.LexiconTypeDecoder{

     

       
689
       
685
       
 
       
				Val: &tangled.RepoIssue{

     

       
690
       
690
       
-
       
					Repo:    atUri,

     

       
691
       
691
       
-
       
					Title:   title,

     

       
692
       
692
       
-
       
					Body:    &body,

     

       
693
       
693
       
-
       
					Owner:   user.Did,

     

       
694
       
694
       
-
       
					IssueId: int64(issue.IssueId),

     

       
686
       
686
       
+
       
					Repo:  atUri,

     

       
687
       
687
       
+
       
					Title: title,

     

       
688
       
688
       
+
       
					Body:  &body,

     

       
689
       
689
       
+
       
					Owner: user.Did,

     

       
695
       
690
       
 
       
				},

     

       
696
       
691
       
 
       
			},

     

       
697
       
692
       
 
       
		})

     

···

       
9
       
9
       
 
       
      "key": "tid",

     

       
10
       
10
       
 
       
      "record": {

     

       
11
       
11
       
 
       
        "type": "object",

     

       
12
       
12
       
-
       
        "required": [

     

       
13
       
13
       
-
       
          "issue",

     

       
14
       
14
       
-
       
          "body",

     

       
15
       
15
       
-
       
          "createdAt"

     

       
16
       
16
       
-
       
        ],

     

       
12
       
12
       
+
       
        "required": ["issue", "body", "createdAt"],

     

       
17
       
13
       
 
       
        "properties": {

     

       
18
       
14
       
 
       
          "issue": {

     

       
19
       
15
       
 
       
            "type": "string",

     
···

       
22
       
18
       
 
       
          "repo": {

     

       
23
       
19
       
 
       
            "type": "string",

     

       
24
       
20
       
 
       
            "format": "at-uri"

     

       
25
       
25
       
-
       
          },

     

       
26
       
26
       
-
       
          "commentId": {

     

       
27
       
27
       
-
       
            "type": "integer"

     

       
28
       
21
       
 
       
          },

     

       
29
       
22
       
 
       
          "owner": {

     

       
30
       
23
       
 
       
            "type": "string",

     

···

       
9
       
9
       
 
       
      "key": "tid",

     

       
10
       
10
       
 
       
      "record": {

     

       
11
       
11
       
 
       
        "type": "object",

     

       
12
       
12
       
-
       
        "required": [

     

       
13
       
13
       
-
       
          "repo",

     

       
14
       
14
       
-
       
          "issueId",

     

       
15
       
15
       
-
       
          "owner",

     

       
16
       
16
       
-
       
          "title",

     

       
17
       
17
       
-
       
          "createdAt"

     

       
18
       
18
       
-
       
        ],

     

       
12
       
12
       
+
       
        "required": ["repo", "title", "createdAt"],

     

       
19
       
13
       
 
       
        "properties": {

     

       
20
       
14
       
 
       
          "repo": {

     

       
21
       
15
       
 
       
            "type": "string",

     

       
22
       
16
       
 
       
            "format": "at-uri"

     

       
23
       
23
       
-
       
          },

     

       
24
       
24
       
-
       
          "issueId": {

     

       
25
       
25
       
-
       
            "type": "integer"

     

       
26
       
26
       
-
       
          },

     

       
27
       
27
       
-
       
          "owner": {

     

       
28
       
28
       
-
       
            "type": "string",

     

       
29
       
29
       
-
       
            "format": "did"

     

       
30
       
17
       
 
       
          },

     

       
31
       
18
       
 
       
          "title": {

     

       
32
       
19
       
 
       
            "type": "string"