1use crate::error::HttpError;
2use crate::HttpClient;
3use serde::Serialize;
4use titanium_model::{Channel, CreateMessage, Message, Snowflake};
5
6impl HttpClient {
7 pub async fn get_channel(&self, channel_id: Snowflake) -> Result<Channel<'static>, HttpError> {
13 let route = format!("/channels/{}", channel_id);
14 self.get(&route).await
15 }
16
17 pub async fn delete_channel(
19 &self,
20 channel_id: Snowflake,
21 reason: Option<&str>,
22 ) -> Result<Channel<'static>, HttpError> {
23 let route = format!("/channels/{}", channel_id);
24
25 let headers = reason.map(|r| {
26 let mut h = reqwest::header::HeaderMap::new();
27 h.insert(
28 "X-Audit-Log-Reason",
29 reqwest::header::HeaderValue::from_str(r).unwrap(),
30 );
31 h
32 });
33
34 self.delete_with_headers(&route, headers).await
35 }
36
37 pub async fn create_channel(
39 &self,
40 guild_id: Snowflake,
41 params: &titanium_model::builder::CreateChannel<'_>,
42 ) -> Result<Channel<'static>, HttpError> {
43 let route = format!("/guilds/{}/channels", guild_id);
44 self.post(&route, params).await
45 }
46
47 pub async fn get_message(
53 &self,
54 channel_id: Snowflake,
55 message_id: Snowflake,
56 ) -> Result<Message<'static>, HttpError> {
57 let route = format!("/channels/{}/messages/{}", channel_id, message_id);
58 self.get(&route).await
59 }
60
61 pub async fn create_message_struct(
65 &self,
66 channel_id: Snowflake,
67 message: &CreateMessage<'_>,
68 ) -> Result<Message<'static>, HttpError> {
69 let route = format!("/channels/{}/messages", channel_id);
70 self.post(&route, message).await
71 }
72
73 pub async fn send_message(
75 &self,
76 channel_id: Snowflake,
77 content: impl Into<String>,
78 ) -> Result<Message<'static>, HttpError> {
79 #[derive(Serialize)]
80 struct SimpleMessage {
81 content: String,
82 }
83
84 let route = format!("/channels/{}/messages", channel_id);
85 self.post(
86 &route,
87 SimpleMessage {
88 content: content.into(),
89 },
90 )
91 .await
92 }
93
94 pub async fn edit_message(
96 &self,
97 channel_id: Snowflake,
98 message_id: Snowflake,
99 content: impl Into<String>,
100 ) -> Result<Message<'static>, HttpError> {
101 #[derive(Serialize)]
102 struct EditMessage {
103 content: String,
104 }
105
106 let route = format!("/channels/{}/messages/{}", channel_id, message_id);
107 self.patch(
108 &route,
109 EditMessage {
110 content: content.into(),
111 },
112 )
113 .await
114 }
115
116 pub async fn delete_message(
118 &self,
119 channel_id: Snowflake,
120 message_id: Snowflake,
121 reason: Option<&str>,
122 ) -> Result<(), HttpError> {
123 let route = format!("/channels/{}/messages/{}", channel_id, message_id);
124
125 let headers = reason.map(|r| {
126 let mut h = reqwest::header::HeaderMap::new();
127 h.insert(
128 "X-Audit-Log-Reason",
129 reqwest::header::HeaderValue::from_str(r).unwrap(),
130 );
131 h
132 });
133
134 self.delete_with_headers(&route, headers).await
135 }
136
137 pub async fn delete_messages_bulk(
141 &self,
142 channel_id: Snowflake,
143 messages: Vec<Snowflake>,
144 ) -> Result<(), HttpError> {
145 #[derive(Serialize)]
146 struct BulkDelete {
147 messages: Vec<Snowflake>,
148 }
149
150 let route = format!("/channels/{}/messages/bulk-delete", channel_id);
151 self.post(&route, BulkDelete { messages }).await
152 }
153}