Skip to main content

tongbal_api/session/
mod.rs

1pub mod message {
2    pub use tongbal_types::session::*;
3}
4
5mod builder;
6mod response;
7mod types;
8
9pub use builder::GetSession;
10pub use response::{CreateSessionResponse, SessionResponse};
11pub use tongbal_types::subscribed_event::{EventType, SubscribedEvent};
12pub use types::Session;
13
14use std::future::Future;
15
16use crate::{
17    AppClient, BaseClient, Error, Response, UserClient,
18    types::{
19        SessionKey,
20        constants::{
21            AUTH, CHAT, CLIENT, DONATION, EVENTS, SESSION_KEY, SESSIONS, SUBSCRIBE, SUBSCRIPTION,
22            UNSUBSCRIBE,
23        },
24    },
25};
26
27pub trait SessionAPI: BaseClient {
28    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined>
29    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-1>
30    fn create_session(
31        &self,
32    ) -> impl Future<Output = Result<Response<CreateSessionResponse>, Error>> + Send;
33
34    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-3>
35    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-4>
36    fn get_sessions<'a>(&'a self) -> GetSession<'a, Self>
37    where
38        Self: Sized;
39
40    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-5>
41    fn subscribe_chat(
42        &self,
43        session_key: &SessionKey,
44    ) -> impl Future<Output = Result<(), Error>> + Send;
45
46    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-6>
47    fn unsubscribe_chat(
48        &self,
49        session_key: &SessionKey,
50    ) -> impl Future<Output = Result<(), Error>> + Send;
51
52    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-7>
53    fn subscribe_donation(
54        &self,
55        session_key: &SessionKey,
56    ) -> impl Future<Output = Result<(), Error>> + Send;
57
58    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-8>
59    fn unsubscribe_donation(
60        &self,
61        session_key: &SessionKey,
62    ) -> impl Future<Output = Result<(), Error>> + Send;
63
64    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-9>
65    fn subscribe_subscription(
66        &self,
67        session_key: &SessionKey,
68    ) -> impl Future<Output = Result<(), Error>> + Send;
69
70    /// See <https://chzzk.gitbook.io/chzzk/chzzk-api/session#undefined-10>
71    fn unsubscribe_subscription(
72        &self,
73        session_key: &SessionKey,
74    ) -> impl Future<Output = Result<(), Error>> + Send;
75}
76
77impl SessionAPI for AppClient {
78    async fn create_session(&self) -> Result<Response<CreateSessionResponse>, Error> {
79        let mut url = self.base_url();
80
81        url.path_segments_mut()
82            .unwrap()
83            .extend([SESSIONS, AUTH, CLIENT]);
84
85        crate::client::json(self.http_client().get(url)).await
86    }
87
88    fn get_sessions<'a>(&'a self) -> GetSession<'a, Self> {
89        GetSession::new(self, Some(CLIENT))
90    }
91
92    async fn subscribe_chat(&self, session_key: &SessionKey) -> Result<(), Error> {
93        let mut url = self.base_url();
94
95        url.path_segments_mut()
96            .unwrap()
97            .extend([SESSIONS, EVENTS, SUBSCRIBE, CHAT]);
98
99        url.query_pairs_mut()
100            .append_pair(SESSION_KEY, session_key.as_ref());
101
102        crate::client::no_content(self.http_client().post(url)).await?;
103        Ok(())
104    }
105
106    async fn unsubscribe_chat(&self, session_key: &SessionKey) -> Result<(), Error> {
107        let mut url = self.base_url();
108
109        url.path_segments_mut()
110            .unwrap()
111            .extend([SESSIONS, EVENTS, UNSUBSCRIBE, CHAT]);
112
113        url.query_pairs_mut()
114            .append_pair(SESSION_KEY, session_key.as_ref());
115
116        crate::client::no_content(self.http_client().post(url)).await?;
117        Ok(())
118    }
119
120    async fn subscribe_donation(&self, session_key: &SessionKey) -> Result<(), Error> {
121        let mut url = self.base_url();
122
123        url.path_segments_mut()
124            .unwrap()
125            .extend([SESSIONS, EVENTS, SUBSCRIBE, DONATION]);
126
127        url.query_pairs_mut()
128            .append_pair(SESSION_KEY, session_key.as_ref());
129
130        crate::client::no_content(self.http_client().post(url)).await?;
131        Ok(())
132    }
133
134    async fn unsubscribe_donation(&self, session_key: &SessionKey) -> Result<(), Error> {
135        let mut url = self.base_url();
136
137        url.path_segments_mut()
138            .unwrap()
139            .extend([SESSIONS, EVENTS, UNSUBSCRIBE, DONATION]);
140
141        url.query_pairs_mut()
142            .append_pair(SESSION_KEY, session_key.as_ref());
143
144        crate::client::no_content(self.http_client().post(url)).await?;
145        Ok(())
146    }
147
148    async fn subscribe_subscription(&self, session_key: &SessionKey) -> Result<(), Error> {
149        let mut url = self.base_url();
150
151        url.path_segments_mut()
152            .unwrap()
153            .extend([SESSIONS, EVENTS, SUBSCRIBE, SUBSCRIPTION]);
154
155        url.query_pairs_mut()
156            .append_pair(SESSION_KEY, session_key.as_ref());
157
158        crate::client::no_content(self.http_client().post(url)).await?;
159        Ok(())
160    }
161
162    async fn unsubscribe_subscription(&self, session_key: &SessionKey) -> Result<(), Error> {
163        let mut url = self.base_url();
164
165        url.path_segments_mut()
166            .unwrap()
167            .extend(&[SESSIONS, EVENTS, UNSUBSCRIBE, SUBSCRIPTION]);
168
169        url.query_pairs_mut()
170            .append_pair(SESSION_KEY, session_key.as_ref());
171
172        crate::client::no_content(self.http_client().post(url)).await?;
173        Ok(())
174    }
175}
176
177impl SessionAPI for UserClient {
178    async fn create_session(&self) -> Result<Response<CreateSessionResponse>, Error> {
179        let mut url = self.base_url();
180        url.path_segments_mut().unwrap().extend([SESSIONS, AUTH]);
181        crate::client::json(self.http_client().get(url)).await
182    }
183
184    fn get_sessions<'a>(&'a self) -> GetSession<'a, Self> {
185        GetSession::new(self, None)
186    }
187
188    async fn subscribe_chat(&self, session_key: &SessionKey) -> Result<(), Error> {
189        let mut url = self.base_url();
190
191        url.path_segments_mut()
192            .unwrap()
193            .extend([SESSIONS, EVENTS, SUBSCRIBE, CHAT]);
194
195        url.query_pairs_mut()
196            .append_pair(SESSION_KEY, session_key.as_ref());
197
198        crate::client::no_content(self.http_client().post(url)).await?;
199        Ok(())
200    }
201
202    async fn unsubscribe_chat(&self, session_key: &SessionKey) -> Result<(), Error> {
203        let mut url = self.base_url();
204
205        url.path_segments_mut()
206            .unwrap()
207            .extend([SESSIONS, EVENTS, UNSUBSCRIBE, CHAT]);
208
209        url.query_pairs_mut()
210            .append_pair(SESSION_KEY, session_key.as_ref());
211
212        crate::client::no_content(self.http_client().post(url)).await?;
213        Ok(())
214    }
215
216    async fn subscribe_donation(&self, session_key: &SessionKey) -> Result<(), Error> {
217        let mut url = self.base_url();
218
219        url.path_segments_mut()
220            .unwrap()
221            .extend([SESSIONS, EVENTS, SUBSCRIBE, DONATION]);
222
223        url.query_pairs_mut()
224            .append_pair(SESSION_KEY, session_key.as_ref());
225
226        crate::client::no_content(self.http_client().post(url)).await?;
227        Ok(())
228    }
229
230    async fn unsubscribe_donation(&self, session_key: &SessionKey) -> Result<(), Error> {
231        let mut url = self.base_url();
232
233        url.path_segments_mut()
234            .unwrap()
235            .extend([SESSIONS, EVENTS, UNSUBSCRIBE, DONATION]);
236
237        url.query_pairs_mut()
238            .append_pair(SESSION_KEY, session_key.as_ref());
239
240        crate::client::no_content(self.http_client().post(url)).await?;
241        Ok(())
242    }
243
244    async fn subscribe_subscription(&self, session_key: &SessionKey) -> Result<(), Error> {
245        let mut url = self.base_url();
246
247        url.path_segments_mut()
248            .unwrap()
249            .extend([SESSIONS, EVENTS, SUBSCRIBE, SUBSCRIPTION]);
250
251        url.query_pairs_mut()
252            .append_pair(SESSION_KEY, session_key.as_ref());
253
254        crate::client::no_content(self.http_client().post(url)).await?;
255        Ok(())
256    }
257
258    async fn unsubscribe_subscription(&self, session_key: &SessionKey) -> Result<(), Error> {
259        let mut url = self.base_url();
260
261        url.path_segments_mut()
262            .unwrap()
263            .extend(&[SESSIONS, EVENTS, UNSUBSCRIBE, SUBSCRIPTION]);
264
265        url.query_pairs_mut()
266            .append_pair(SESSION_KEY, session_key.as_ref());
267
268        crate::client::no_content(self.http_client().post(url)).await?;
269        Ok(())
270    }
271}