misskey_api/endpoint/notes/
timeline.rs

1use crate::model::{id::Id, note::Note};
2
3use chrono::{serde::ts_milliseconds_option, DateTime, Utc};
4use serde::Serialize;
5use typed_builder::TypedBuilder;
6
7#[derive(Serialize, Default, Debug, Clone, TypedBuilder)]
8#[serde(rename_all = "camelCase")]
9#[builder(doc)]
10pub struct Request {
11    #[serde(skip_serializing_if = "Option::is_none")]
12    #[builder(default, setter(strip_option))]
13    pub with_files: Option<bool>,
14    #[serde(skip_serializing_if = "Option::is_none")]
15    #[builder(default, setter(strip_option))]
16    pub include_my_renotes: Option<bool>,
17    #[serde(skip_serializing_if = "Option::is_none")]
18    #[builder(default, setter(strip_option))]
19    pub include_renoted_my_notes: Option<bool>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    #[builder(default, setter(strip_option))]
22    pub include_local_renotes: Option<bool>,
23    /// 1 .. 100
24    #[serde(skip_serializing_if = "Option::is_none")]
25    #[builder(default, setter(strip_option))]
26    pub limit: Option<u8>,
27    #[serde(skip_serializing_if = "Option::is_none")]
28    #[builder(default, setter(strip_option))]
29    pub since_id: Option<Id<Note>>,
30    #[serde(skip_serializing_if = "Option::is_none")]
31    #[builder(default, setter(strip_option))]
32    pub until_id: Option<Id<Note>>,
33    #[serde(
34        skip_serializing_if = "Option::is_none",
35        with = "ts_milliseconds_option"
36    )]
37    #[builder(default, setter(strip_option, into))]
38    pub since_date: Option<DateTime<Utc>>,
39    #[serde(
40        skip_serializing_if = "Option::is_none",
41        with = "ts_milliseconds_option"
42    )]
43    #[builder(default, setter(strip_option, into))]
44    pub until_date: Option<DateTime<Utc>>,
45}
46
47impl misskey_core::Request for Request {
48    type Response = Vec<Note>;
49    const ENDPOINT: &'static str = "notes/timeline";
50}
51
52impl_pagination!(Request, Note);
53
54#[cfg(test)]
55mod tests {
56    use super::Request;
57    use crate::test::{ClientExt, TestClient};
58
59    #[tokio::test]
60    async fn request() {
61        let client = TestClient::new();
62        client.test(Request::default()).await;
63    }
64
65    #[tokio::test]
66    async fn request_with_options() {
67        let client = TestClient::new();
68        client
69            .test(Request {
70                with_files: Some(true),
71                include_my_renotes: Some(false),
72                include_renoted_my_notes: Some(false),
73                include_local_renotes: Some(false),
74                limit: None,
75                since_id: None,
76                until_id: None,
77                since_date: None,
78                until_date: None,
79            })
80            .await;
81    }
82
83    #[tokio::test]
84    async fn request_with_limit() {
85        let client = TestClient::new();
86        client
87            .test(Request {
88                with_files: None,
89                include_my_renotes: None,
90                include_renoted_my_notes: None,
91                include_local_renotes: None,
92                limit: Some(100),
93                since_id: None,
94                until_id: None,
95                since_date: None,
96                until_date: None,
97            })
98            .await;
99    }
100
101    #[tokio::test]
102    async fn request_paginate() {
103        let client = TestClient::new();
104        let note = client.create_note(Some("test"), None, None).await;
105
106        client
107            .test(Request {
108                with_files: None,
109                include_my_renotes: None,
110                include_renoted_my_notes: None,
111                include_local_renotes: None,
112                limit: None,
113                since_id: Some(note.id.clone()),
114                until_id: Some(note.id.clone()),
115                since_date: None,
116                until_date: None,
117            })
118            .await;
119    }
120
121    #[tokio::test]
122    async fn request_with_date() {
123        let client = TestClient::new();
124        let now = chrono::Utc::now();
125
126        client
127            .test(Request {
128                with_files: None,
129                include_my_renotes: None,
130                include_renoted_my_notes: None,
131                include_local_renotes: None,
132                limit: None,
133                since_id: None,
134                until_id: None,
135                since_date: Some(now),
136                until_date: Some(now),
137            })
138            .await;
139    }
140}