misskey_api/endpoint/notes/
global_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    /// 1 .. 100
15    #[serde(skip_serializing_if = "Option::is_none")]
16    #[builder(default, setter(strip_option))]
17    pub limit: Option<u8>,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    #[builder(default, setter(strip_option))]
20    pub since_id: Option<Id<Note>>,
21    #[serde(skip_serializing_if = "Option::is_none")]
22    #[builder(default, setter(strip_option))]
23    pub until_id: Option<Id<Note>>,
24    #[serde(
25        skip_serializing_if = "Option::is_none",
26        with = "ts_milliseconds_option"
27    )]
28    #[builder(default, setter(strip_option, into))]
29    pub since_date: Option<DateTime<Utc>>,
30    #[serde(
31        skip_serializing_if = "Option::is_none",
32        with = "ts_milliseconds_option"
33    )]
34    #[builder(default, setter(strip_option, into))]
35    pub until_date: Option<DateTime<Utc>>,
36}
37
38impl misskey_core::Request for Request {
39    type Response = Vec<Note>;
40    const ENDPOINT: &'static str = "notes/global-timeline";
41}
42
43impl_pagination!(Request, Note);
44
45#[cfg(test)]
46mod tests {
47    use super::Request;
48    use crate::test::{ClientExt, TestClient};
49
50    #[tokio::test]
51    async fn request() {
52        let client = TestClient::new();
53        client.test(Request::default()).await;
54    }
55
56    #[tokio::test]
57    async fn request_with_option() {
58        let client = TestClient::new();
59        client
60            .test(Request {
61                with_files: Some(true),
62                limit: None,
63                since_id: None,
64                until_id: None,
65                since_date: None,
66                until_date: None,
67            })
68            .await;
69    }
70
71    #[tokio::test]
72    async fn request_with_limit() {
73        let client = TestClient::new();
74        client
75            .test(Request {
76                with_files: None,
77                limit: Some(100),
78                since_id: None,
79                until_id: None,
80                since_date: None,
81                until_date: None,
82            })
83            .await;
84    }
85
86    #[tokio::test]
87    async fn request_paginate() {
88        let client = TestClient::new();
89        let note = client.create_note(Some("test"), None, None).await;
90
91        client
92            .test(Request {
93                with_files: None,
94                limit: None,
95                since_id: Some(note.id.clone()),
96                until_id: Some(note.id.clone()),
97                since_date: None,
98                until_date: None,
99            })
100            .await;
101    }
102
103    #[tokio::test]
104    async fn request_with_date() {
105        let client = TestClient::new();
106        let now = chrono::Utc::now();
107
108        client
109            .test(Request {
110                with_files: None,
111                limit: None,
112                since_id: None,
113                until_id: None,
114                since_date: Some(now),
115                until_date: Some(now),
116            })
117            .await;
118    }
119}