misskey_api/endpoint/admin/
abuse_user_reports.rs

1#[cfg(feature = "12-49-0")]
2use crate::model::user::UserOrigin;
3use crate::model::{abuse_user_report::AbuseUserReport, id::Id};
4
5use serde::Serialize;
6use thiserror::Error;
7use typed_builder::TypedBuilder;
8
9#[derive(Serialize, PartialEq, Eq, Clone, Debug, Copy)]
10#[serde(rename_all = "camelCase")]
11pub enum AbuseUserReportState {
12    Resolved,
13    Unresolved,
14}
15
16#[derive(Debug, Error, Clone)]
17#[error("invalid user state")]
18pub struct ParseAbuseUserReportStateError {
19    _priv: (),
20}
21
22impl std::str::FromStr for AbuseUserReportState {
23    type Err = ParseAbuseUserReportStateError;
24
25    fn from_str(s: &str) -> Result<AbuseUserReportState, Self::Err> {
26        match s {
27            "resolved" | "Resolved" => Ok(AbuseUserReportState::Resolved),
28            "unresolved" | "Unresolved" => Ok(AbuseUserReportState::Unresolved),
29            _ => Err(ParseAbuseUserReportStateError { _priv: () }),
30        }
31    }
32}
33
34#[derive(Serialize, Default, Debug, Clone, TypedBuilder)]
35#[serde(rename_all = "camelCase")]
36#[builder(doc)]
37pub struct Request {
38    #[cfg(feature = "12-49-0")]
39    #[cfg_attr(docsrs, doc(cfg(feature = "12-49-0")))]
40    #[serde(skip_serializing_if = "Option::is_none")]
41    #[builder(default, setter(strip_option))]
42    pub state: Option<AbuseUserReportState>,
43    #[cfg(feature = "12-49-0")]
44    #[cfg_attr(docsrs, doc(cfg(feature = "12-49-0")))]
45    #[serde(skip_serializing_if = "Option::is_none")]
46    #[builder(default, setter(strip_option))]
47    pub reporter_origin: Option<UserOrigin>,
48    #[cfg(feature = "12-49-0")]
49    #[cfg_attr(docsrs, doc(cfg(feature = "12-49-0")))]
50    #[serde(skip_serializing_if = "Option::is_none")]
51    #[builder(default, setter(strip_option))]
52    pub target_user_origin: Option<UserOrigin>,
53    /// 1 .. 100
54    #[serde(skip_serializing_if = "Option::is_none")]
55    #[builder(default, setter(strip_option))]
56    pub limit: Option<u8>,
57    #[serde(skip_serializing_if = "Option::is_none")]
58    #[builder(default, setter(strip_option))]
59    pub since_id: Option<Id<AbuseUserReport>>,
60    #[serde(skip_serializing_if = "Option::is_none")]
61    #[builder(default, setter(strip_option))]
62    pub until_id: Option<Id<AbuseUserReport>>,
63}
64
65impl misskey_core::Request for Request {
66    type Response = Vec<AbuseUserReport>;
67    const ENDPOINT: &'static str = "admin/abuse-user-reports";
68}
69
70impl_pagination!(Request, AbuseUserReport);
71
72#[cfg(test)]
73mod tests {
74    #[cfg(feature = "12-49-0")]
75    use super::AbuseUserReportState;
76    use super::Request;
77    use crate::test::{ClientExt, TestClient};
78
79    #[tokio::test]
80    async fn request() {
81        let client = TestClient::new();
82        client.admin.test(Request::default()).await;
83    }
84
85    #[tokio::test]
86    async fn request_with_limit() {
87        let client = TestClient::new();
88
89        client
90            .admin
91            .test(Request {
92                #[cfg(feature = "12-49-0")]
93                state: None,
94                #[cfg(feature = "12-49-0")]
95                reporter_origin: None,
96                #[cfg(feature = "12-49-0")]
97                target_user_origin: None,
98                limit: Some(100),
99                since_id: None,
100                until_id: None,
101            })
102            .await;
103    }
104
105    #[tokio::test]
106    async fn request_with_options() {
107        #[cfg(feature = "12-49-0")]
108        use crate::model::user::UserOrigin;
109
110        let client = TestClient::new();
111
112        client
113            .admin
114            .test(Request {
115                #[cfg(feature = "12-49-0")]
116                state: Some(AbuseUserReportState::Unresolved),
117                #[cfg(feature = "12-49-0")]
118                reporter_origin: Some(UserOrigin::Remote),
119                #[cfg(feature = "12-49-0")]
120                target_user_origin: Some(UserOrigin::Combined),
121                limit: Some(100),
122                since_id: None,
123                until_id: None,
124            })
125            .await;
126
127        client
128            .admin
129            .test(Request {
130                #[cfg(feature = "12-49-0")]
131                state: Some(AbuseUserReportState::Resolved),
132                #[cfg(feature = "12-49-0")]
133                reporter_origin: Some(UserOrigin::Combined),
134                #[cfg(feature = "12-49-0")]
135                target_user_origin: Some(UserOrigin::Local),
136                limit: Some(100),
137                since_id: None,
138                until_id: None,
139            })
140            .await;
141    }
142
143    #[tokio::test]
144    async fn request_paginate() {
145        let client = TestClient::new();
146        let (user, _) = client.admin.create_user().await;
147
148        client
149            .user
150            .test(crate::endpoint::users::report_abuse::Request {
151                user_id: user.id.clone(),
152                comment: "damedesu".to_string(),
153            })
154            .await;
155
156        let reports = client
157            .admin
158            .test(Request {
159                #[cfg(feature = "12-49-0")]
160                state: None,
161                #[cfg(feature = "12-49-0")]
162                reporter_origin: None,
163                #[cfg(feature = "12-49-0")]
164                target_user_origin: None,
165                limit: None,
166                since_id: None,
167                until_id: None,
168            })
169            .await;
170
171        client
172            .admin
173            .test(Request {
174                #[cfg(feature = "12-49-0")]
175                state: None,
176                #[cfg(feature = "12-49-0")]
177                reporter_origin: None,
178                #[cfg(feature = "12-49-0")]
179                target_user_origin: None,
180                limit: None,
181                since_id: Some(reports[0].id.clone()),
182                until_id: Some(reports[0].id.clone()),
183            })
184            .await;
185    }
186}