twilight_http/request/channel/thread/
create_thread_from_message.rs1#[cfg(not(target_os = "wasi"))]
2use crate::response::{Response, ResponseFuture};
3use crate::{
4 client::Client,
5 error::Error,
6 request::{Request, TryIntoRequest},
7 routing::Route,
8};
9use serde::Serialize;
10use std::future::IntoFuture;
11use twilight_model::{
12 channel::{Channel, thread::AutoArchiveDuration},
13 id::{
14 Id,
15 marker::{ChannelMarker, MessageMarker},
16 },
17};
18use twilight_validate::channel::{ChannelValidationError, name as validate_name};
19
20#[derive(Serialize)]
21struct CreateThreadFromMessageFields<'a> {
22 #[serde(skip_serializing_if = "Option::is_none")]
23 auto_archive_duration: Option<AutoArchiveDuration>,
24 name: &'a str,
25}
26
27#[must_use = "requests must be configured and executed"]
47pub struct CreateThreadFromMessage<'a> {
48 channel_id: Id<ChannelMarker>,
49 fields: Result<CreateThreadFromMessageFields<'a>, ChannelValidationError>,
50 http: &'a Client,
51 message_id: Id<MessageMarker>,
52}
53
54impl<'a> CreateThreadFromMessage<'a> {
55 pub(crate) fn new(
56 http: &'a Client,
57 channel_id: Id<ChannelMarker>,
58 message_id: Id<MessageMarker>,
59 name: &'a str,
60 ) -> Self {
61 let fields = Ok(CreateThreadFromMessageFields {
62 auto_archive_duration: None,
63 name,
64 })
65 .and_then(|fields| {
66 validate_name(name)?;
67
68 Ok(fields)
69 });
70
71 Self {
72 channel_id,
73 fields,
74 http,
75 message_id,
76 }
77 }
78
79 pub const fn auto_archive_duration(
84 mut self,
85 auto_archive_duration: AutoArchiveDuration,
86 ) -> Self {
87 if let Ok(fields) = self.fields.as_mut() {
88 fields.auto_archive_duration = Some(auto_archive_duration);
89 }
90
91 self
92 }
93}
94
95#[cfg(not(target_os = "wasi"))]
96impl IntoFuture for CreateThreadFromMessage<'_> {
97 type Output = Result<Response<Channel>, Error>;
98
99 type IntoFuture = ResponseFuture<Channel>;
100
101 fn into_future(self) -> Self::IntoFuture {
102 let http = self.http;
103
104 match self.try_into_request() {
105 Ok(request) => http.request(request),
106 Err(source) => ResponseFuture::error(source),
107 }
108 }
109}
110
111impl TryIntoRequest for CreateThreadFromMessage<'_> {
112 fn try_into_request(self) -> Result<Request, Error> {
113 let fields = self.fields.map_err(Error::validation)?;
114
115 Request::builder(&Route::CreateThreadFromMessage {
116 channel_id: self.channel_id.get(),
117 message_id: self.message_id.get(),
118 })
119 .json(&fields)
120 .build()
121 }
122}