aws_sdk_lexruntime/protocol_serde/
shape_post_text.rs1#[allow(clippy::unnecessary_wraps)]
3pub fn de_post_text_http_error(
4 _response_status: u16,
5 _response_headers: &::aws_smithy_runtime_api::http::Headers,
6 _response_body: &[u8],
7) -> std::result::Result<crate::operation::post_text::PostTextOutput, crate::operation::post_text::PostTextError> {
8 #[allow(unused_mut)]
9 let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
10 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
11 generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
12 let generic = generic_builder.build();
13 let error_code = match generic.code() {
14 Some(code) => code,
15 None => return Err(crate::operation::post_text::PostTextError::unhandled(generic)),
16 };
17
18 let _error_message = generic.message().map(|msg| msg.to_owned());
19 Err(match error_code {
20 "BadGatewayException" => crate::operation::post_text::PostTextError::BadGatewayException({
21 #[allow(unused_mut)]
22 let mut tmp = {
23 #[allow(unused_mut)]
24 let mut output = crate::types::error::builders::BadGatewayExceptionBuilder::default();
25 output = crate::protocol_serde::shape_bad_gateway_exception::de_bad_gateway_exception_json_err(_response_body, output)
26 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
27 let output = output.meta(generic);
28 output.build()
29 };
30 if tmp.message.is_none() {
31 tmp.message = _error_message;
32 }
33 tmp
34 }),
35 "BadRequestException" => crate::operation::post_text::PostTextError::BadRequestException({
36 #[allow(unused_mut)]
37 let mut tmp = {
38 #[allow(unused_mut)]
39 let mut output = crate::types::error::builders::BadRequestExceptionBuilder::default();
40 output = crate::protocol_serde::shape_bad_request_exception::de_bad_request_exception_json_err(_response_body, output)
41 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
42 let output = output.meta(generic);
43 output.build()
44 };
45 if tmp.message.is_none() {
46 tmp.message = _error_message;
47 }
48 tmp
49 }),
50 "ConflictException" => crate::operation::post_text::PostTextError::ConflictException({
51 #[allow(unused_mut)]
52 let mut tmp = {
53 #[allow(unused_mut)]
54 let mut output = crate::types::error::builders::ConflictExceptionBuilder::default();
55 output = crate::protocol_serde::shape_conflict_exception::de_conflict_exception_json_err(_response_body, output)
56 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
57 let output = output.meta(generic);
58 output.build()
59 };
60 if tmp.message.is_none() {
61 tmp.message = _error_message;
62 }
63 tmp
64 }),
65 "DependencyFailedException" => crate::operation::post_text::PostTextError::DependencyFailedException({
66 #[allow(unused_mut)]
67 let mut tmp = {
68 #[allow(unused_mut)]
69 let mut output = crate::types::error::builders::DependencyFailedExceptionBuilder::default();
70 output = crate::protocol_serde::shape_dependency_failed_exception::de_dependency_failed_exception_json_err(_response_body, output)
71 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
72 let output = output.meta(generic);
73 output.build()
74 };
75 if tmp.message.is_none() {
76 tmp.message = _error_message;
77 }
78 tmp
79 }),
80 "InternalFailureException" => crate::operation::post_text::PostTextError::InternalFailureException({
81 #[allow(unused_mut)]
82 let mut tmp = {
83 #[allow(unused_mut)]
84 let mut output = crate::types::error::builders::InternalFailureExceptionBuilder::default();
85 output = crate::protocol_serde::shape_internal_failure_exception::de_internal_failure_exception_json_err(_response_body, output)
86 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
87 let output = output.meta(generic);
88 output.build()
89 };
90 if tmp.message.is_none() {
91 tmp.message = _error_message;
92 }
93 tmp
94 }),
95 "LimitExceededException" => crate::operation::post_text::PostTextError::LimitExceededException({
96 #[allow(unused_mut)]
97 let mut tmp = {
98 #[allow(unused_mut)]
99 let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
100 output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
101 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
102 output = output.set_retry_after_seconds(
103 crate::protocol_serde::shape_limit_exceeded_exception::de_retry_after_seconds_header(_response_headers).map_err(|_| {
104 crate::operation::post_text::PostTextError::unhandled("Failed to parse retryAfterSeconds from header `Retry-After")
105 })?,
106 );
107 let output = output.meta(generic);
108 output.build()
109 };
110 if tmp.message.is_none() {
111 tmp.message = _error_message;
112 }
113 tmp
114 }),
115 "LoopDetectedException" => crate::operation::post_text::PostTextError::LoopDetectedException({
116 #[allow(unused_mut)]
117 let mut tmp = {
118 #[allow(unused_mut)]
119 let mut output = crate::types::error::builders::LoopDetectedExceptionBuilder::default();
120 output = crate::protocol_serde::shape_loop_detected_exception::de_loop_detected_exception_json_err(_response_body, output)
121 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
122 let output = output.meta(generic);
123 output.build()
124 };
125 if tmp.message.is_none() {
126 tmp.message = _error_message;
127 }
128 tmp
129 }),
130 "NotFoundException" => crate::operation::post_text::PostTextError::NotFoundException({
131 #[allow(unused_mut)]
132 let mut tmp = {
133 #[allow(unused_mut)]
134 let mut output = crate::types::error::builders::NotFoundExceptionBuilder::default();
135 output = crate::protocol_serde::shape_not_found_exception::de_not_found_exception_json_err(_response_body, output)
136 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
137 let output = output.meta(generic);
138 output.build()
139 };
140 if tmp.message.is_none() {
141 tmp.message = _error_message;
142 }
143 tmp
144 }),
145 _ => crate::operation::post_text::PostTextError::generic(generic),
146 })
147}
148
149#[allow(clippy::unnecessary_wraps)]
150pub fn de_post_text_http_response(
151 _response_status: u16,
152 _response_headers: &::aws_smithy_runtime_api::http::Headers,
153 _response_body: &[u8],
154) -> std::result::Result<crate::operation::post_text::PostTextOutput, crate::operation::post_text::PostTextError> {
155 Ok({
156 #[allow(unused_mut)]
157 let mut output = crate::operation::post_text::builders::PostTextOutputBuilder::default();
158 output = crate::protocol_serde::shape_post_text::de_post_text(_response_body, output)
159 .map_err(crate::operation::post_text::PostTextError::unhandled)?;
160 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
161 output.build()
162 })
163}
164
165pub fn ser_post_text_input(
166 input: &crate::operation::post_text::PostTextInput,
167) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
168 let mut out = String::new();
169 let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
170 crate::protocol_serde::shape_post_text_input::ser_post_text_input_input(&mut object, input)?;
171 object.finish();
172 Ok(::aws_smithy_types::body::SdkBody::from(out))
173}
174
175pub(crate) fn de_post_text(
176 _value: &[u8],
177 mut builder: crate::operation::post_text::builders::PostTextOutputBuilder,
178) -> ::std::result::Result<crate::operation::post_text::builders::PostTextOutputBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
179 let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
180 let tokens = &mut tokens_owned;
181 ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
182 loop {
183 match tokens.next().transpose()? {
184 Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
185 Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
186 "activeContexts" => {
187 builder = builder.set_active_contexts(crate::protocol_serde::shape_active_contexts_list::de_active_contexts_list(
188 tokens, _value,
189 )?);
190 }
191 "alternativeIntents" => {
192 builder = builder.set_alternative_intents(crate::protocol_serde::shape_intent_list::de_intent_list(tokens, _value)?);
193 }
194 "botVersion" => {
195 builder = builder.set_bot_version(
196 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
197 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
198 .transpose()?,
199 );
200 }
201 "dialogState" => {
202 builder = builder.set_dialog_state(
203 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
204 .map(|s| s.to_unescaped().map(|u| crate::types::DialogState::from(u.as_ref())))
205 .transpose()?,
206 );
207 }
208 "intentName" => {
209 builder = builder.set_intent_name(
210 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
211 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
212 .transpose()?,
213 );
214 }
215 "message" => {
216 builder = builder.set_message(
217 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
218 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
219 .transpose()?,
220 );
221 }
222 "messageFormat" => {
223 builder = builder.set_message_format(
224 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
225 .map(|s| s.to_unescaped().map(|u| crate::types::MessageFormatType::from(u.as_ref())))
226 .transpose()?,
227 );
228 }
229 "nluIntentConfidence" => {
230 builder =
231 builder.set_nlu_intent_confidence(crate::protocol_serde::shape_intent_confidence::de_intent_confidence(tokens, _value)?);
232 }
233 "responseCard" => {
234 builder = builder.set_response_card(crate::protocol_serde::shape_response_card::de_response_card(tokens, _value)?);
235 }
236 "sentimentResponse" => {
237 builder = builder.set_sentiment_response(crate::protocol_serde::shape_sentiment_response::de_sentiment_response(tokens, _value)?);
238 }
239 "sessionAttributes" => {
240 builder = builder.set_session_attributes(crate::protocol_serde::shape_string_map::de_string_map(tokens, _value)?);
241 }
242 "sessionId" => {
243 builder = builder.set_session_id(
244 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
245 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
246 .transpose()?,
247 );
248 }
249 "slotToElicit" => {
250 builder = builder.set_slot_to_elicit(
251 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
252 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
253 .transpose()?,
254 );
255 }
256 "slots" => {
257 builder = builder.set_slots(crate::protocol_serde::shape_string_map::de_string_map(tokens, _value)?);
258 }
259 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
260 },
261 other => {
262 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
263 "expected object key or end object, found: {other:?}"
264 )))
265 }
266 }
267 }
268 if tokens.next().is_some() {
269 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
270 "found more JSON tokens after completing parsing",
271 ));
272 }
273 Ok(builder)
274}