1use crate::client::HingeClient;
2use crate::errors::HingeError;
3use crate::models::{
4 ExportChatInput, ExportChatResult, SendMessagePayload, SendbirdChannelHandle,
5 SendbirdChannelsResponse, SendbirdCloseRequest, SendbirdGetMessagesInput, SendbirdGroupChannel,
6 SendbirdMessage, SendbirdMessagesResponse, SendbirdReadResponse,
7};
8use crate::storage::Storage;
9use crate::ws::SendbirdWsSubscription;
10
11pub struct ChatApi<'a, S: Storage + Clone> {
12 pub(super) client: &'a mut HingeClient<S>,
13}
14
15impl<S: Storage + Clone> ChatApi<'_, S> {
16 pub async fn init_flow(&mut self) -> Result<serde_json::Value, HingeError> {
17 self.client.sendbird_init_flow().await
18 }
19
20 pub async fn credentials(&mut self) -> Result<serde_json::Value, HingeError> {
21 self.client.sendbird_creds().await
22 }
23
24 pub async fn channels_raw(
25 &mut self,
26 user_id: &str,
27 limit: usize,
28 ) -> Result<serde_json::Value, HingeError> {
29 self.client
30 .sendbird_list_my_group_channels(user_id, limit)
31 .await
32 }
33
34 pub async fn channels(&mut self, limit: usize) -> Result<SendbirdChannelsResponse, HingeError> {
35 self.client.sendbird_list_channels_typed(limit).await
36 }
37
38 pub async fn channel_raw(
39 &mut self,
40 channel_url: &str,
41 ) -> Result<serde_json::Value, HingeError> {
42 self.client.sendbird_get_channel(channel_url).await
43 }
44
45 pub async fn channel(&mut self, channel_url: &str) -> Result<SendbirdGroupChannel, HingeError> {
46 self.client.sendbird_get_channel_typed(channel_url).await
47 }
48
49 pub async fn messages(
50 &mut self,
51 input: SendbirdGetMessagesInput,
52 ) -> Result<SendbirdMessagesResponse, HingeError> {
53 let message_ts = input.message_ts.parse::<i64>().unwrap_or(0);
54 self.client
55 .sendbird_get_messages(&input.channel_url, message_ts, input.prev_limit as usize)
56 .await
57 }
58
59 pub async fn full_messages(
60 &mut self,
61 channel_url: &str,
62 ) -> Result<Vec<SendbirdMessage>, HingeError> {
63 self.client.sendbird_get_full_messages(channel_url).await
64 }
65
66 pub async fn export_chat(
67 &mut self,
68 input: ExportChatInput,
69 ) -> Result<ExportChatResult, HingeError> {
70 self.client.export_chat(input).await
71 }
72
73 pub async fn create_distinct_dm(
74 &mut self,
75 self_user_id: &str,
76 peer_user_id: &str,
77 data_mm: i32,
78 ) -> Result<serde_json::Value, HingeError> {
79 self.client
80 .sendbird_create_distinct_dm(self_user_id, peer_user_id, data_mm)
81 .await
82 }
83
84 pub async fn get_or_create_dm_channel(
85 &mut self,
86 self_user_id: &str,
87 peer_user_id: &str,
88 ) -> Result<String, HingeError> {
89 self.client
90 .sendbird_get_or_create_dm_channel(self_user_id, peer_user_id)
91 .await
92 }
93
94 pub async fn ensure_dm_with(
95 &mut self,
96 partner_id: &str,
97 ) -> Result<SendbirdChannelHandle, HingeError> {
98 self.client.ensure_sendbird_channel_with(partner_id).await
99 }
100
101 pub async fn send_message(
102 &self,
103 payload: SendMessagePayload,
104 ) -> Result<serde_json::Value, HingeError> {
105 self.client.send_message(payload).await
106 }
107
108 pub async fn subscribe(
109 &mut self,
110 ) -> Result<
111 (
112 tokio::sync::mpsc::UnboundedSender<String>,
113 tokio::sync::broadcast::Receiver<String>,
114 ),
115 HingeError,
116 > {
117 self.client.sendbird_ws_subscribe().await
118 }
119
120 pub async fn subscribe_events(&mut self) -> Result<SendbirdWsSubscription, HingeError> {
121 let (commands, raw) = self.client.sendbird_ws_subscribe().await?;
122 Ok(SendbirdWsSubscription::new(commands, raw))
123 }
124
125 pub async fn send_ws_command(&mut self, command: String) -> Result<(), HingeError> {
126 self.client.sendbird_ws_send_command(command).await
127 }
128
129 pub async fn mark_read(
130 &mut self,
131 channel_url: &str,
132 ) -> Result<SendbirdReadResponse, HingeError> {
133 self.client
134 .sendbird_ws_send_read_and_wait(channel_url)
135 .await
136 }
137
138 pub async fn mark_read_fire_and_forget(&mut self, channel_url: &str) -> Result<(), HingeError> {
139 self.client.sendbird_ws_send_read(channel_url).await
140 }
141
142 pub async fn ping(&mut self) -> Result<(), HingeError> {
143 self.client.sendbird_ws_send_ping().await
144 }
145
146 pub async fn typing_start(&mut self, channel_url: &str) -> Result<(), HingeError> {
147 self.client.sendbird_ws_send_typing_start(channel_url).await
148 }
149
150 pub async fn typing_end(&mut self, channel_url: &str) -> Result<(), HingeError> {
151 self.client.sendbird_ws_send_typing_end(channel_url).await
152 }
153
154 pub async fn enter_channel(&mut self, channel_url: &str) -> Result<(), HingeError> {
155 self.client
156 .sendbird_ws_send_enter_channel(channel_url)
157 .await
158 }
159
160 pub async fn exit_channel(&mut self, channel_url: &str) -> Result<(), HingeError> {
161 self.client.sendbird_ws_send_exit_channel(channel_url).await
162 }
163
164 pub async fn ack_message(
165 &mut self,
166 channel_url: &str,
167 message_id: &str,
168 ) -> Result<(), HingeError> {
169 self.client
170 .sendbird_ws_send_message_ack(channel_url, message_id)
171 .await
172 }
173
174 pub async fn close_ws(&mut self, request: SendbirdCloseRequest) -> Result<(), HingeError> {
175 self.client
176 .sendbird_ws_close(request.code, request.reason)
177 .await
178 }
179
180 pub async fn ensure_ws_connected(&mut self) -> Result<bool, HingeError> {
181 self.client.sendbird_ws_ensure_connected().await
182 }
183}