this repo has no description
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

labelmaker: fix-ups after rebasing post-lex-refactor

+122 -127
+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
··· 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
··· 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
··· 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
··· 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,