this repo has no description
labelmaker: fix-ups after rebasing post-lex-refactor
+122
-127
+45
-45
labeling/admin.go
+45
-45
labeling/admin.go
···
12
12
)
13
13
14
14
// This is probably only a temporary method
15
-
func (s *Server) hydrateRepoView(ctx context.Context, did, indexedAt string) *comatproto.AdminRepo_View {
16
-
return &comatproto.AdminRepo_View{
15
+
func (s *Server) hydrateRepoView(ctx context.Context, did, indexedAt string) *comatproto.AdminDefs_RepoView {
16
+
return &comatproto.AdminDefs_RepoView{
17
17
// TODO(bnewbold): populate more, or more correctly, from some backend?
18
-
Account: nil,
19
18
Did: did,
19
+
Email: nil,
20
20
Handle: "TODO",
21
21
IndexedAt: indexedAt,
22
22
Moderation: nil,
···
25
25
}
26
26
27
27
// This is probably only a temporary method
28
-
func (s *Server) hydrateRecordView(ctx context.Context, did string, uri, cid *string, indexedAt string) *comatproto.AdminRecord_View {
28
+
func (s *Server) hydrateRecordView(ctx context.Context, did string, uri, cid *string, indexedAt string) *comatproto.AdminDefs_RecordView {
29
29
repoView := s.hydrateRepoView(ctx, did, indexedAt)
30
30
// TODO(bnewbold): populate more, or more correctly, from some backend?
31
-
recordView := comatproto.AdminRecord_View{
31
+
recordView := comatproto.AdminDefs_RecordView{
32
32
BlobCids: []string{},
33
33
IndexedAt: indexedAt,
34
34
Moderation: nil,
35
35
Repo: repoView,
36
36
// XXX: replace with actual record
37
-
Value: lexutil.LexiconTypeDecoder{&appbsky.FeedPost{}},
37
+
Value: &lexutil.LexiconTypeDecoder{&appbsky.FeedPost{}},
38
38
}
39
39
if uri != nil {
40
40
recordView.Uri = *uri
···
45
45
return &recordView
46
46
}
47
47
48
-
func (s *Server) hydrateModerationActions(ctx context.Context, rows []models.ModerationAction) ([]*comatproto.AdminModerationAction_View, error) {
48
+
func (s *Server) hydrateModerationActions(ctx context.Context, rows []models.ModerationAction) ([]*comatproto.AdminDefs_ActionView, error) {
49
49
50
-
var out []*comatproto.AdminModerationAction_View
50
+
var out []*comatproto.AdminDefs_ActionView
51
51
52
52
for _, row := range rows {
53
53
// TODO(bnewbold): resolve these
54
54
resolvedReportIds := []int64{}
55
55
subjectBlobCIDs := []string{}
56
56
57
-
var reversal *comatproto.AdminModerationAction_Reversal
57
+
var reversal *comatproto.AdminDefs_ActionReversal
58
58
if row.ReversedAt != nil {
59
-
reversal = &comatproto.AdminModerationAction_Reversal{
59
+
reversal = &comatproto.AdminDefs_ActionReversal{
60
60
CreatedAt: row.ReversedAt.Format(time.RFC3339),
61
61
CreatedBy: *row.ReversedByDid,
62
62
Reason: *row.ReversedReason,
63
63
}
64
64
}
65
-
var subj *comatproto.AdminModerationAction_View_Subject
65
+
var subj *comatproto.AdminDefs_ActionView_Subject
66
66
switch row.SubjectType {
67
67
case "com.atproto.repo.repoRef":
68
-
subj = &comatproto.AdminModerationAction_View_Subject{
69
-
RepoRepoRef: &comatproto.RepoRepoRef{
68
+
subj = &comatproto.AdminDefs_ActionView_Subject{
69
+
AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
70
70
LexiconTypeID: "com.atproto.repo.repoRef",
71
71
Did: row.SubjectDid,
72
72
},
73
73
}
74
74
case "com.atproto.repo.recordRef":
75
-
subj = &comatproto.AdminModerationAction_View_Subject{
75
+
subj = &comatproto.AdminDefs_ActionView_Subject{
76
76
RepoStrongRef: &comatproto.RepoStrongRef{
77
77
LexiconTypeID: "com.atproto.repo.strongRef",
78
78
Uri: *row.SubjectUri,
···
83
83
return nil, fmt.Errorf("unsupported moderation SubjectType: %v", row.SubjectType)
84
84
}
85
85
86
-
view := &comatproto.AdminModerationAction_View{
86
+
view := &comatproto.AdminDefs_ActionView{
87
87
Action: &row.Action,
88
88
CreatedAt: row.CreatedAt.Format(time.RFC3339),
89
89
CreatedBy: row.CreatedByDid,
···
99
99
return out, nil
100
100
}
101
101
102
-
func (s *Server) hydrateModerationActionDetails(ctx context.Context, rows []models.ModerationAction) ([]*comatproto.AdminModerationAction_ViewDetail, error) {
102
+
func (s *Server) hydrateModerationActionDetails(ctx context.Context, rows []models.ModerationAction) ([]*comatproto.AdminDefs_ActionViewDetail, error) {
103
103
104
-
var out []*comatproto.AdminModerationAction_ViewDetail
104
+
var out []*comatproto.AdminDefs_ActionViewDetail
105
105
for _, row := range rows {
106
106
107
107
// TODO(bnewbold): resolve these
108
-
resolvedReports := []*comatproto.AdminModerationReport_View{}
109
-
subjectBlobs := []*comatproto.AdminBlob_View{}
108
+
resolvedReports := []*comatproto.AdminDefs_ReportView{}
109
+
subjectBlobs := []*comatproto.AdminDefs_BlobView{}
110
110
111
-
var reversal *comatproto.AdminModerationAction_Reversal
111
+
var reversal *comatproto.AdminDefs_ActionReversal
112
112
if row.ReversedAt != nil {
113
-
reversal = &comatproto.AdminModerationAction_Reversal{
113
+
reversal = &comatproto.AdminDefs_ActionReversal{
114
114
CreatedAt: row.ReversedAt.Format(time.RFC3339),
115
115
CreatedBy: *row.ReversedByDid,
116
116
Reason: *row.ReversedReason,
117
117
}
118
118
}
119
-
var subj *comatproto.AdminModerationAction_ViewDetail_Subject
119
+
var subj *comatproto.AdminDefs_ActionViewDetail_Subject
120
120
switch row.SubjectType {
121
121
case "com.atproto.repo.repoRef":
122
-
subj = &comatproto.AdminModerationAction_ViewDetail_Subject{
123
-
AdminRepo_View: s.hydrateRepoView(ctx, row.SubjectDid, row.CreatedAt.Format(time.RFC3339)),
122
+
subj = &comatproto.AdminDefs_ActionViewDetail_Subject{
123
+
AdminDefs_RepoView: s.hydrateRepoView(ctx, row.SubjectDid, row.CreatedAt.Format(time.RFC3339)),
124
124
}
125
125
case "com.atproto.repo.recordRef":
126
-
subj = &comatproto.AdminModerationAction_ViewDetail_Subject{
127
-
AdminRecord_View: s.hydrateRecordView(ctx, row.SubjectDid, row.SubjectUri, row.SubjectCid, row.CreatedAt.Format(time.RFC3339)),
126
+
subj = &comatproto.AdminDefs_ActionViewDetail_Subject{
127
+
AdminDefs_RecordView: s.hydrateRecordView(ctx, row.SubjectDid, row.SubjectUri, row.SubjectCid, row.CreatedAt.Format(time.RFC3339)),
128
128
}
129
129
default:
130
130
return nil, fmt.Errorf("unsupported moderation SubjectType: %v", row.SubjectType)
131
131
}
132
132
133
-
viewDetail := &comatproto.AdminModerationAction_ViewDetail{
133
+
viewDetail := &comatproto.AdminDefs_ActionViewDetail{
134
134
Action: &row.Action,
135
135
CreatedAt: row.CreatedAt.Format(time.RFC3339),
136
136
CreatedBy: row.CreatedByDid,
···
146
146
return out, nil
147
147
}
148
148
149
-
func (s *Server) hydrateModerationReports(ctx context.Context, rows []models.ModerationReport) ([]*comatproto.AdminModerationReport_View, error) {
149
+
func (s *Server) hydrateModerationReports(ctx context.Context, rows []models.ModerationReport) ([]*comatproto.AdminDefs_ReportView, error) {
150
150
151
-
var out []*comatproto.AdminModerationReport_View
151
+
var out []*comatproto.AdminDefs_ReportView
152
152
for _, row := range rows {
153
153
// TODO(bnewbold): fetch these IDs
154
154
var resolvedByActionIds []int64
155
155
156
-
var subj *comatproto.AdminModerationReport_View_Subject
156
+
var subj *comatproto.AdminDefs_ReportView_Subject
157
157
switch row.SubjectType {
158
158
case "com.atproto.repo.repoRef":
159
-
subj = &comatproto.AdminModerationReport_View_Subject{
160
-
RepoRepoRef: &comatproto.RepoRepoRef{
159
+
subj = &comatproto.AdminDefs_ReportView_Subject{
160
+
AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
161
161
LexiconTypeID: "com.atproto.repo.repoRef",
162
162
Did: row.SubjectDid,
163
163
},
164
164
}
165
165
case "com.atproto.repo.recordRef":
166
-
subj = &comatproto.AdminModerationReport_View_Subject{
166
+
subj = &comatproto.AdminDefs_ReportView_Subject{
167
167
RepoStrongRef: &comatproto.RepoStrongRef{
168
168
LexiconTypeID: "com.atproto.repo.strongRef",
169
169
Uri: *row.SubjectUri,
···
174
174
return nil, fmt.Errorf("unsupported moderation SubjectType: %v", row.SubjectType)
175
175
}
176
176
177
-
view := &comatproto.AdminModerationReport_View{
177
+
view := &comatproto.AdminDefs_ReportView{
178
178
Id: int64(row.ID),
179
179
ReasonType: &row.ReasonType,
180
180
Subject: subj,
181
-
ReportedByDid: row.ReportedByDid,
181
+
ReportedBy: row.ReportedByDid,
182
182
CreatedAt: row.CreatedAt.Format(time.RFC3339),
183
183
ResolvedByActionIds: resolvedByActionIds,
184
184
}
···
187
187
return out, nil
188
188
}
189
189
190
-
func (s *Server) hydrateModerationReportDetails(ctx context.Context, rows []models.ModerationReport) ([]*comatproto.AdminModerationReport_ViewDetail, error) {
190
+
func (s *Server) hydrateModerationReportDetails(ctx context.Context, rows []models.ModerationReport) ([]*comatproto.AdminDefs_ReportViewDetail, error) {
191
191
192
-
var out []*comatproto.AdminModerationReport_ViewDetail
192
+
var out []*comatproto.AdminDefs_ReportViewDetail
193
193
for _, row := range rows {
194
194
// TODO(bnewbold): fetch these objects
195
-
var resolvedByActions []*comatproto.AdminModerationAction_View
195
+
var resolvedByActions []*comatproto.AdminDefs_ActionView
196
196
197
-
var subj *comatproto.AdminModerationReport_ViewDetail_Subject
197
+
var subj *comatproto.AdminDefs_ReportViewDetail_Subject
198
198
switch row.SubjectType {
199
199
case "com.atproto.repo.repoRef":
200
-
subj = &comatproto.AdminModerationReport_ViewDetail_Subject{
201
-
AdminRepo_View: s.hydrateRepoView(ctx, row.SubjectDid, row.CreatedAt.Format(time.RFC3339)),
200
+
subj = &comatproto.AdminDefs_ReportViewDetail_Subject{
201
+
AdminDefs_RepoView: s.hydrateRepoView(ctx, row.SubjectDid, row.CreatedAt.Format(time.RFC3339)),
202
202
}
203
203
case "com.atproto.repo.recordRef":
204
-
subj = &comatproto.AdminModerationReport_ViewDetail_Subject{
205
-
AdminRecord_View: s.hydrateRecordView(ctx, row.SubjectDid, row.SubjectUri, row.SubjectCid, row.CreatedAt.Format(time.RFC3339)),
204
+
subj = &comatproto.AdminDefs_ReportViewDetail_Subject{
205
+
AdminDefs_RecordView: s.hydrateRecordView(ctx, row.SubjectDid, row.SubjectUri, row.SubjectCid, row.CreatedAt.Format(time.RFC3339)),
206
206
}
207
207
default:
208
208
return nil, fmt.Errorf("unsupported moderation SubjectType: %v", row.SubjectType)
209
209
}
210
210
211
-
viewDetail := &comatproto.AdminModerationReport_ViewDetail{
211
+
viewDetail := &comatproto.AdminDefs_ReportViewDetail{
212
212
Id: int64(row.ID),
213
213
ReasonType: &row.ReasonType,
214
214
Subject: subj,
215
-
ReportedByDid: row.ReportedByDid,
215
+
ReportedBy: row.ReportedByDid,
216
216
CreatedAt: row.CreatedAt.Format(time.RFC3339),
217
217
ResolvedByActions: resolvedByActions,
218
218
}
+29
-30
labeling/moderation_test.go
+29
-30
labeling/moderation_test.go
···
22
22
// create and read back a basic repo report
23
23
rt := "spam"
24
24
reportedDid := "did:plc:123"
25
-
report := comatproto.ReportCreate_Input{
25
+
report := comatproto.ModerationCreateReport_Input{
26
26
//Reason
27
27
ReasonType: &rt,
28
-
Subject: &comatproto.ReportCreate_Input_Subject{
29
-
RepoRepoRef: &comatproto.RepoRepoRef{
28
+
Subject: &comatproto.ModerationCreateReport_Input_Subject{
29
+
AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
30
30
Did: reportedDid,
31
31
},
32
32
},
···
44
44
// TODO: "Created" / 201
45
45
assert.Equal(t, 200, recorder.Code)
46
46
47
-
var out comatproto.ReportCreate_Output
47
+
var out comatproto.ModerationCreateReport_Output
48
48
if err := json.Unmarshal([]byte(recorder.Body.String()), &out); err != nil {
49
49
t.Fatal(err)
50
50
}
51
51
assert.Equal(t, report.ReasonType, out.ReasonType)
52
-
assert.Equal(t, report.Subject.RepoRepoRef, out.Subject.RepoRepoRef)
52
+
assert.Equal(t, report.Subject.AdminDefs_RepoRef, out.Subject.AdminDefs_RepoRef)
53
53
reportId := out.Id
54
54
55
55
// read it back
···
60
60
c = e.NewContext(req, recorder)
61
61
assert.NoError(t, lm.HandleComAtprotoAdminGetModerationReport(c))
62
62
assert.Equal(t, 200, recorder.Code)
63
-
var vd comatproto.AdminModerationReport_ViewDetail
63
+
var vd comatproto.AdminDefs_ReportViewDetail
64
64
if err := json.Unmarshal([]byte(recorder.Body.String()), &vd); err != nil {
65
65
t.Fatal(err)
66
66
}
67
67
assert.Equal(t, vd.Id, reportId, vd.Id)
68
68
assert.Equal(t, vd.ReasonType, report.ReasonType)
69
69
assert.Nil(t, vd.Reason)
70
-
assert.Equal(t, vd.Subject.AdminRepo_View.Did, reportedDid)
71
-
assert.Nil(t, vd.Subject.AdminRecord_View)
72
-
// TODO: additional AdminRecord_View fields
70
+
assert.Equal(t, vd.Subject.AdminDefs_RepoView.Did, reportedDid)
71
+
assert.Nil(t, vd.Subject.AdminDefs_RecordView)
72
+
// TODO: additional AdminDefs_RecordView fields
73
73
74
74
// read back via get multi
75
75
req = httptest.NewRequest(http.MethodGet, "/xrpc/com.atproto.admin.getModerationReports", nil)
···
102
102
103
103
for _, row := range table {
104
104
105
-
report := comatproto.ReportCreate_Input{
105
+
report := comatproto.ModerationCreateReport_Input{
106
106
//Reason
107
107
ReasonType: &row.rType,
108
-
Subject: &comatproto.ReportCreate_Input_Subject{
109
-
RepoRepoRef: &comatproto.RepoRepoRef{
108
+
Subject: &comatproto.ModerationCreateReport_Input_Subject{
109
+
AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
110
110
Did: row.rDid,
111
111
},
112
112
},
···
137
137
reason := "I just don't like it!"
138
138
uri := "at://did:plc:123/com.example.record/bcd234"
139
139
cid := "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454"
140
-
report := comatproto.ReportCreate_Input{
140
+
report := comatproto.ModerationCreateReport_Input{
141
141
Reason: &reason,
142
142
ReasonType: &rt,
143
-
Subject: &comatproto.ReportCreate_Input_Subject{
144
-
RepoRecordRef: &comatproto.RepoRecordRef{
145
-
//com.atproto.repo.recordRef
143
+
Subject: &comatproto.ModerationCreateReport_Input_Subject{
144
+
RepoStrongRef: &comatproto.RepoStrongRef{
145
+
//com.atproto.repo.strongRef
146
146
Uri: uri,
147
-
Cid: &cid,
147
+
Cid: cid,
148
148
},
149
149
},
150
150
}
···
161
161
// TODO: "Created" / 201
162
162
assert.Equal(t, 200, recorder.Code)
163
163
164
-
var out comatproto.ReportCreate_Output
164
+
var out comatproto.ModerationCreateReport_Output
165
165
if err := json.Unmarshal([]byte(recorder.Body.String()), &out); err != nil {
166
166
t.Fatal(err)
167
167
}
168
168
assert.Equal(t, report.ReasonType, out.ReasonType)
169
-
assert.Equal(t, report.Subject.RepoRepoRef, out.Subject.RepoRepoRef)
169
+
assert.Equal(t, report.Subject.AdminDefs_RepoRef, out.Subject.AdminDefs_RepoRef)
170
170
reportId := out.Id
171
171
172
172
// read it back
···
177
177
c = e.NewContext(req, recorder)
178
178
assert.NoError(t, lm.HandleComAtprotoAdminGetModerationReport(c))
179
179
assert.Equal(t, 200, recorder.Code)
180
-
var vd comatproto.AdminModerationReport_ViewDetail
180
+
var vd comatproto.AdminDefs_ReportViewDetail
181
181
if err := json.Unmarshal([]byte(recorder.Body.String()), &vd); err != nil {
182
182
t.Fatal(err)
183
183
}
···
196
196
table := []struct {
197
197
rType string
198
198
rUri string
199
-
rCid *string
199
+
rCid string
200
200
statusCode int
201
201
}{
202
-
{"spam", uriStr, &cidStr, 200},
203
-
{"spam", uriStr, nil, 400},
204
-
{"", uriStr, &cidStr, 400},
205
-
{"spam", "", &cidStr, 400},
206
-
{"spam", uriStr, &emptyStr, 400},
202
+
{"spam", uriStr, cidStr, 200},
203
+
{"", uriStr, cidStr, 400},
204
+
{"spam", "", cidStr, 400},
205
+
{"spam", uriStr, emptyStr, 400},
207
206
}
208
207
209
208
for _, row := range table {
210
209
211
-
report := comatproto.ReportCreate_Input{
210
+
report := comatproto.ModerationCreateReport_Input{
212
211
ReasonType: &row.rType,
213
-
Subject: &comatproto.ReportCreate_Input_Subject{
214
-
RepoRecordRef: &comatproto.RepoRecordRef{
215
-
//com.atproto.repo.recordRef
212
+
Subject: &comatproto.ModerationCreateReport_Input_Subject{
213
+
RepoStrongRef: &comatproto.RepoStrongRef{
214
+
//com.atproto.repo.strongRef
216
215
Uri: row.rUri,
217
216
Cid: row.rCid,
218
217
},
-3
labeling/service.go
-3
labeling/service.go
···
9
9
"net/http"
10
10
"net/url"
11
11
"strings"
12
-
"time"
13
12
14
13
"github.com/bluesky-social/indigo/api"
15
14
comatproto "github.com/bluesky-social/indigo/api/atproto"
···
27
26
util "github.com/bluesky-social/indigo/util"
28
27
cbg "github.com/whyrusleeping/cbor-gen"
29
28
30
-
"github.com/ipfs/go-cid"
31
29
logging "github.com/ipfs/go-log"
32
30
"github.com/labstack/echo/v4"
33
31
"github.com/labstack/echo/v4/middleware"
34
32
"github.com/whyrusleeping/go-did"
35
33
"gorm.io/gorm"
36
-
"gorm.io/gorm/clause"
37
34
)
38
35
39
36
var log = logging.Logger("labelmaker")
+15
-16
labeling/xrpc_endpoints.go
+15
-16
labeling/xrpc_endpoints.go
···
17
17
e.GET("/xrpc/com.atproto.server.describeServer", s.HandleComAtprotoServerDescribeServer)
18
18
// TODO: session create/refresh/delete?
19
19
20
-
21
20
// minimal moderation reporting/actioning
22
21
e.GET("/xrpc/com.atproto.admin.getModerationAction", s.HandleComAtprotoAdminGetModerationAction)
23
22
e.GET("/xrpc/com.atproto.admin.getModerationActions", s.HandleComAtprotoAdminGetModerationActions)
···
102
101
defer span.End()
103
102
var out *atproto.ServerDescribeServer_Output
104
103
var handleErr error
105
-
// func (s *Server) handleComAtprotoServerGetAccountsConfig(ctx context.Context) (*atproto.ServerGetAccountsConfig_Output, error)
106
-
out, handleErr = s.handleComAtprotoServerGetAccountsConfig(ctx)
104
+
// func (s *Server) handleComAtprotoServerDescribeServer(ctx context.Context) (*atproto.ServerDescribeServer_Output, error)
105
+
out, handleErr = s.handleComAtprotoServerDescribeServer(ctx)
107
106
if handleErr != nil {
108
107
return handleErr
109
108
}
···
147
146
if err != nil {
148
147
return err
149
148
}
150
-
var out *atproto.AdminModerationAction_ViewDetail
149
+
var out *atproto.AdminDefs_ActionViewDetail
151
150
var handleErr error
152
-
// func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context,id int) (*atproto.AdminModerationAction_ViewDetail, error)
151
+
// func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context,id int) (*atproto.AdminDefs_ActionViewDetail, error)
153
152
out, handleErr = s.handleComAtprotoAdminGetModerationAction(ctx, id)
154
153
if handleErr != nil {
155
154
return handleErr
···
191
190
if err != nil {
192
191
return err
193
192
}
194
-
var out *atproto.AdminModerationReport_ViewDetail
193
+
var out *atproto.AdminDefs_ReportViewDetail
195
194
var handleErr error
196
-
// func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context,id int) (*atproto.AdminModerationReport_ViewDetail, error)
195
+
// func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context,id int) (*atproto.AdminDefs_ReportViewDetail, error)
197
196
out, handleErr = s.handleComAtprotoAdminGetModerationReport(ctx, id)
198
197
if handleErr != nil {
199
198
return handleErr
···
244
243
if err := c.Bind(&body); err != nil {
245
244
return err
246
245
}
247
-
var out *atproto.AdminModerationAction_View
246
+
var out *atproto.AdminDefs_ActionView
248
247
var handleErr error
249
-
// func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context,body *atproto.AdminResolveModerationReports_Input) (*atproto.AdminModerationAction_View, error)
248
+
// func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context,body *atproto.AdminResolveModerationReports_Input) (*atproto.AdminDefs_ActionView, error)
250
249
out, handleErr = s.handleComAtprotoAdminResolveModerationReports(ctx, &body)
251
250
if handleErr != nil {
252
251
return handleErr
···
262
261
if err := c.Bind(&body); err != nil {
263
262
return err
264
263
}
265
-
var out *atproto.AdminModerationAction_View
264
+
var out *atproto.AdminDefs_ActionView
266
265
var handleErr error
267
-
// func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context,body *atproto.AdminReverseModerationAction_Input) (*atproto.AdminModerationAction_View, error)
266
+
// func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context,body *atproto.AdminReverseModerationAction_Input) (*atproto.AdminDefs_ActionView, error)
268
267
out, handleErr = s.handleComAtprotoAdminReverseModerationAction(ctx, &body)
269
268
if handleErr != nil {
270
269
return handleErr
···
280
279
if err := c.Bind(&body); err != nil {
281
280
return err
282
281
}
283
-
var out *atproto.AdminModerationAction_View
282
+
var out *atproto.AdminDefs_ActionView
284
283
var handleErr error
285
-
// func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context,body *atproto.AdminTakeModerationAction_Input) (*atproto.AdminModerationAction_View, error)
284
+
// func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context,body *atproto.AdminTakeModerationAction_Input) (*atproto.AdminDefs_ActionView, error)
286
285
out, handleErr = s.handleComAtprotoAdminTakeModerationAction(ctx, &body)
287
286
if handleErr != nil {
288
287
return handleErr
···
294
293
ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoReportCreate")
295
294
defer span.End()
296
295
297
-
var body atproto.ReportCreate_Input
296
+
var body atproto.ModerationCreateReport_Input
298
297
if err := c.Bind(&body); err != nil {
299
298
return err
300
299
}
301
-
var out *atproto.ReportCreate_Output
300
+
var out *atproto.ModerationCreateReport_Output
302
301
var handleErr error
303
-
// func (s *Server) handleComAtprotoReportCreate(ctx context.Context,body *atproto.ReportCreate_Input) (*atproto.ReportCreate_Output, error)
302
+
// func (s *Server) handleComAtprotoReportCreate(ctx context.Context,body *atproto.ModerationCreateReport_Input) (*atproto.ModerationCreateReport_Output, error)
304
303
out, handleErr = s.handleComAtprotoReportCreate(ctx, &body)
305
304
if handleErr != nil {
306
305
return handleErr
+33
-33
labeling/xrpc_handlers.go
+33
-33
labeling/xrpc_handlers.go
···
31
31
}
32
32
33
33
func (s *Server) handleComAtprotoRepoDescribeRepo(ctx context.Context, repo string) (*atproto.RepoDescribeRepo_Output, error) {
34
-
if user == s.user.Did || user == s.user.Handle {
35
-
return &atproto.RepoDescribe_Output{
34
+
if repo == s.user.Did || repo == s.user.Handle {
35
+
return &atproto.RepoDescribeRepo_Output{
36
36
Collections: []string{},
37
37
Did: s.user.Did,
38
38
//DidDoc
···
40
40
HandleIsCorrect: true,
41
41
}, nil
42
42
}
43
-
if user == "" {
44
-
return nil, echo.NewHTTPError(400, "empty user parameter")
43
+
if repo == "" {
44
+
return nil, echo.NewHTTPError(400, "empty repo parameter")
45
45
} else {
46
-
return nil, echo.NewHTTPError(404, "user not found")
46
+
return nil, echo.NewHTTPError(404, "repo not found")
47
47
}
48
48
}
49
49
···
188
188
return &out, nil
189
189
}
190
190
191
-
func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context, id int) (*atproto.AdminModerationAction_ViewDetail, error) {
191
+
func (s *Server) handleComAtprotoAdminGetModerationAction(ctx context.Context, id int) (*atproto.AdminDefs_ActionViewDetail, error) {
192
192
193
193
var row models.ModerationAction
194
194
result := s.db.First(&row, id)
···
250
250
return &out, nil
251
251
}
252
252
253
-
func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context, id int) (*atproto.AdminModerationReport_ViewDetail, error) {
253
+
func (s *Server) handleComAtprotoAdminGetModerationReport(ctx context.Context, id int) (*atproto.AdminDefs_ReportViewDetail, error) {
254
254
255
255
var row models.ModerationReport
256
256
result := s.db.First(&row, id)
···
307
307
// TODO: a bit inefficient to do this filter after hydration. could do it
308
308
// in the SQL query instead, but this was faster to implement right now
309
309
if resolved != nil {
310
-
var filtered []*atproto.AdminModerationReport_View
310
+
var filtered []*atproto.AdminDefs_ReportView
311
311
for _, obj := range reportObjs {
312
312
if *resolved == true && len(obj.ResolvedByActionIds) > 0 {
313
313
filtered = append(filtered, obj)
···
328
328
return &out, nil
329
329
}
330
330
331
-
func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context, body *atproto.AdminResolveModerationReports_Input) (*atproto.AdminModerationAction_View, error) {
331
+
func (s *Server) handleComAtprotoAdminResolveModerationReports(ctx context.Context, body *atproto.AdminResolveModerationReports_Input) (*atproto.AdminDefs_ActionView, error) {
332
332
333
333
if body.CreatedBy == "" {
334
334
return nil, echo.NewHTTPError(400, "createdBy param must be non-empty")
···
354
354
}
355
355
356
356
// helper for endpoints that return a partially hydrated moderation action
357
-
func (s *Server) fetchSingleModerationAction(ctx context.Context, actionId int64) (*atproto.AdminModerationAction_View, error) {
357
+
func (s *Server) fetchSingleModerationAction(ctx context.Context, actionId int64) (*atproto.AdminDefs_ActionView, error) {
358
358
var actionRow models.ModerationAction
359
359
result := s.db.First(&actionRow, actionId)
360
360
if result.Error != nil {
···
368
368
return actionObjs[0], nil
369
369
}
370
370
371
-
func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context, body *atproto.AdminReverseModerationAction_Input) (*atproto.AdminModerationAction_View, error) {
371
+
func (s *Server) handleComAtprotoAdminReverseModerationAction(ctx context.Context, body *atproto.AdminReverseModerationAction_Input) (*atproto.AdminDefs_ActionView, error) {
372
372
373
373
if body.CreatedBy == "" {
374
374
return nil, echo.NewHTTPError(400, "createBy param must be non-empty")
···
404
404
return s.fetchSingleModerationAction(ctx, body.Id)
405
405
}
406
406
407
-
func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context, body *atproto.AdminTakeModerationAction_Input) (*atproto.AdminModerationAction_View, error) {
407
+
func (s *Server) handleComAtprotoAdminTakeModerationAction(ctx context.Context, body *atproto.AdminTakeModerationAction_Input) (*atproto.AdminDefs_ActionView, error) {
408
408
409
409
// XXX: check that Action, CreatedBy, and Reason are all non-empty
410
410
···
415
415
CreatedByDid: body.CreatedBy,
416
416
}
417
417
418
-
var outSubj atproto.AdminModerationAction_View_Subject
419
-
if body.Subject.RepoRepoRef != nil {
418
+
var outSubj atproto.AdminDefs_ActionView_Subject
419
+
if body.Subject.AdminDefs_RepoRef != nil {
420
420
row.SubjectType = "com.atproto.repo.repoRef"
421
-
row.SubjectDid = body.Subject.RepoRepoRef.Did
422
-
outSubj.RepoRepoRef = &atproto.RepoRepoRef{
421
+
row.SubjectDid = body.Subject.AdminDefs_RepoRef.Did
422
+
outSubj.AdminDefs_RepoRef = &atproto.AdminDefs_RepoRef{
423
423
LexiconTypeID: "com.atproto.repo.repoRef",
424
424
Did: row.SubjectDid,
425
425
}
426
-
} else if body.Subject.RepoRecordRef != nil {
427
-
if body.Subject.RepoRecordRef.Cid == nil {
426
+
} else if body.Subject.RepoStrongRef != nil {
427
+
if body.Subject.RepoStrongRef.Cid == "" {
428
428
return nil, echo.NewHTTPError(400, "this implementation requires a strong record ref (aka, with CID) in reports")
429
429
}
430
430
row.SubjectType = "com.atproto.repo.recordRef"
431
431
// TODO: row.SubjectDid from URI?
432
-
row.SubjectUri = &body.Subject.RepoRecordRef.Uri
433
-
row.SubjectCid = body.Subject.RepoRecordRef.Cid
432
+
row.SubjectUri = &body.Subject.RepoStrongRef.Uri
433
+
row.SubjectCid = &body.Subject.RepoStrongRef.Cid
434
434
outSubj.RepoStrongRef = &atproto.RepoStrongRef{
435
435
LexiconTypeID: "com.atproto.repo.strongRef",
436
436
Uri: *row.SubjectUri,
···
445
445
return nil, result.Error
446
446
}
447
447
448
-
out := atproto.AdminModerationAction_View{
448
+
out := atproto.AdminDefs_ActionView{
449
449
Id: int64(row.ID),
450
450
Action: &row.Action,
451
451
Reason: row.Reason,
···
457
457
return &out, nil
458
458
}
459
459
460
-
func (s *Server) handleComAtprotoReportCreate(ctx context.Context, body *atproto.ReportCreate_Input) (*atproto.ReportCreate_Output, error) {
460
+
func (s *Server) handleComAtprotoReportCreate(ctx context.Context, body *atproto.ModerationCreateReport_Input) (*atproto.ModerationCreateReport_Output, error) {
461
461
462
462
if body.ReasonType == nil || *body.ReasonType == "" {
463
463
return nil, echo.NewHTTPError(400, "reasonType is required")
···
472
472
// TODO(bnewbold): from auth, via context? as a new lexicon field?
473
473
ReportedByDid: "did:plc:FAKE",
474
474
}
475
-
var outSubj atproto.ReportCreate_Output_Subject
476
-
if body.Subject.RepoRepoRef != nil {
477
-
if body.Subject.RepoRepoRef.Did == "" {
475
+
var outSubj atproto.ModerationCreateReport_Output_Subject
476
+
if body.Subject.AdminDefs_RepoRef != nil {
477
+
if body.Subject.AdminDefs_RepoRef.Did == "" {
478
478
return nil, echo.NewHTTPError(400, "DID is required for repo reports")
479
479
}
480
480
row.SubjectType = "com.atproto.repo.repoRef"
481
-
row.SubjectDid = body.Subject.RepoRepoRef.Did
482
-
outSubj.RepoRepoRef = &atproto.RepoRepoRef{
481
+
row.SubjectDid = body.Subject.AdminDefs_RepoRef.Did
482
+
outSubj.AdminDefs_RepoRef = &atproto.AdminDefs_RepoRef{
483
483
LexiconTypeID: "com.atproto.repo.repoRef",
484
484
Did: row.SubjectDid,
485
485
}
486
-
} else if body.Subject.RepoRecordRef != nil {
487
-
if body.Subject.RepoRecordRef.Uri == "" {
486
+
} else if body.Subject.RepoStrongRef != nil {
487
+
if body.Subject.RepoStrongRef.Uri == "" {
488
488
return nil, echo.NewHTTPError(400, "URI required for record reports")
489
489
}
490
-
if body.Subject.RepoRecordRef.Cid == nil || *body.Subject.RepoRecordRef.Cid == "" {
490
+
if body.Subject.RepoStrongRef.Cid == "" {
491
491
return nil, echo.NewHTTPError(400, "this implementation requires a strong record ref (aka, with CID) in reports")
492
492
}
493
493
row.SubjectType = "com.atproto.repo.recordRef"
494
494
// TODO: row.SubjectDid from URI?
495
-
row.SubjectUri = &body.Subject.RepoRecordRef.Uri
496
-
row.SubjectCid = body.Subject.RepoRecordRef.Cid
495
+
row.SubjectUri = &body.Subject.RepoStrongRef.Uri
496
+
row.SubjectCid = &body.Subject.RepoStrongRef.Cid
497
497
outSubj.RepoStrongRef = &atproto.RepoStrongRef{
498
498
LexiconTypeID: "com.atproto.repo.strongRef",
499
499
Uri: *row.SubjectUri,
···
508
508
return nil, result.Error
509
509
}
510
510
511
-
out := atproto.ReportCreate_Output{
511
+
out := atproto.ModerationCreateReport_Output{
512
512
Id: int64(row.ID),
513
513
CreatedAt: row.CreatedAt.Format(time.RFC3339),
514
514
Reason: row.Reason,