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