deserializers.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package signin
4
5 import (
6 "bytes"
7 "context"
8 "encoding/json"
9 "fmt"
10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
11 "github.com/aws/aws-sdk-go-v2/service/signin/types"
12 smithy "github.com/aws/smithy-go"
13 smithyio "github.com/aws/smithy-go/io"
14 "github.com/aws/smithy-go/middleware"
15 "github.com/aws/smithy-go/ptr"
16 "github.com/aws/smithy-go/tracing"
17 smithyhttp "github.com/aws/smithy-go/transport/http"
18 "io"
19 "strings"
20 )
21
22 type awsRestjson1_deserializeOpCreateOAuth2Token struct {
23 }
24
25 func (*awsRestjson1_deserializeOpCreateOAuth2Token) ID() string {
26 return "OperationDeserializer"
27 }
28
29 func (m *awsRestjson1_deserializeOpCreateOAuth2Token) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
31 ) {
32 out, metadata, err = next.HandleDeserialize(ctx, in)
33 if err != nil {
34 return out, metadata, err
35 }
36
37 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
38 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
39 defer endTimer()
40 defer span.End()
41 response, ok := out.RawResponse.(*smithyhttp.Response)
42 if !ok {
43 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
44 }
45
46 if response.StatusCode < 200 || response.StatusCode >= 300 {
47 return out, metadata, awsRestjson1_deserializeOpErrorCreateOAuth2Token(response, &metadata)
48 }
49 output := &CreateOAuth2TokenOutput{}
50 out.Result = output
51
52 var buff [1024]byte
53 ringBuffer := smithyio.NewRingBuffer(buff[:])
54
55 body := io.TeeReader(response.Body, ringBuffer)
56
57 decoder := json.NewDecoder(body)
58 decoder.UseNumber()
59 var shape interface{}
60 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
61 var snapshot bytes.Buffer
62 io.Copy(&snapshot, ringBuffer)
63 err = &smithy.DeserializationError{
64 Err: fmt.Errorf("failed to decode response body, %w", err),
65 Snapshot: snapshot.Bytes(),
66 }
67 return out, metadata, err
68 }
69
70 err = awsRestjson1_deserializeDocumentCreateOAuth2TokenResponseBody(&output.TokenOutput, shape)
71 if err != nil {
72 var snapshot bytes.Buffer
73 io.Copy(&snapshot, ringBuffer)
74 return out, metadata, &smithy.DeserializationError{
75 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
76 Snapshot: snapshot.Bytes(),
77 }
78 }
79
80 span.End()
81 return out, metadata, err
82 }
83
84 func awsRestjson1_deserializeOpErrorCreateOAuth2Token(response *smithyhttp.Response, metadata *middleware.Metadata) error {
85 var errorBuffer bytes.Buffer
86 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
87 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
88 }
89 errorBody := bytes.NewReader(errorBuffer.Bytes())
90
91 errorCode := "UnknownError"
92 errorMessage := errorCode
93
94 headerCode := response.Header.Get("X-Amzn-ErrorType")
95 if len(headerCode) != 0 {
96 errorCode = restjson.SanitizeErrorCode(headerCode)
97 }
98
99 var buff [1024]byte
100 ringBuffer := smithyio.NewRingBuffer(buff[:])
101
102 body := io.TeeReader(errorBody, ringBuffer)
103 decoder := json.NewDecoder(body)
104 decoder.UseNumber()
105 jsonCode, message, err := restjson.GetErrorInfo(decoder)
106 if err != nil {
107 var snapshot bytes.Buffer
108 io.Copy(&snapshot, ringBuffer)
109 err = &smithy.DeserializationError{
110 Err: fmt.Errorf("failed to decode response body, %w", err),
111 Snapshot: snapshot.Bytes(),
112 }
113 return err
114 }
115
116 errorBody.Seek(0, io.SeekStart)
117 if len(headerCode) == 0 && len(jsonCode) != 0 {
118 errorCode = restjson.SanitizeErrorCode(jsonCode)
119 }
120 if len(message) != 0 {
121 errorMessage = message
122 }
123
124 switch {
125 case strings.EqualFold("AccessDeniedException", errorCode):
126 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
127
128 case strings.EqualFold("InternalServerException", errorCode):
129 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
130
131 case strings.EqualFold("TooManyRequestsError", errorCode):
132 return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
133
134 case strings.EqualFold("ValidationException", errorCode):
135 return awsRestjson1_deserializeErrorValidationException(response, errorBody)
136
137 default:
138 genericError := &smithy.GenericAPIError{
139 Code: errorCode,
140 Message: errorMessage,
141 }
142 return genericError
143
144 }
145 }
146
147 func awsRestjson1_deserializeOpDocumentCreateOAuth2TokenOutput(v **CreateOAuth2TokenOutput, value interface{}) error {
148 if v == nil {
149 return fmt.Errorf("unexpected nil of type %T", v)
150 }
151 if value == nil {
152 return nil
153 }
154
155 shape, ok := value.(map[string]interface{})
156 if !ok {
157 return fmt.Errorf("unexpected JSON type %v", value)
158 }
159
160 var sv *CreateOAuth2TokenOutput
161 if *v == nil {
162 sv = &CreateOAuth2TokenOutput{}
163 } else {
164 sv = *v
165 }
166
167 for key, value := range shape {
168 switch key {
169 case "tokenOutput":
170 if err := awsRestjson1_deserializeDocumentCreateOAuth2TokenResponseBody(&sv.TokenOutput, value); err != nil {
171 return err
172 }
173
174 default:
175 _, _ = key, value
176
177 }
178 }
179 *v = sv
180 return nil
181 }
182
183 func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
184 output := &types.AccessDeniedException{}
185 var buff [1024]byte
186 ringBuffer := smithyio.NewRingBuffer(buff[:])
187
188 body := io.TeeReader(errorBody, ringBuffer)
189 decoder := json.NewDecoder(body)
190 decoder.UseNumber()
191 var shape interface{}
192 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
193 var snapshot bytes.Buffer
194 io.Copy(&snapshot, ringBuffer)
195 err = &smithy.DeserializationError{
196 Err: fmt.Errorf("failed to decode response body, %w", err),
197 Snapshot: snapshot.Bytes(),
198 }
199 return err
200 }
201
202 err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
203
204 if err != nil {
205 var snapshot bytes.Buffer
206 io.Copy(&snapshot, ringBuffer)
207 err = &smithy.DeserializationError{
208 Err: fmt.Errorf("failed to decode response body, %w", err),
209 Snapshot: snapshot.Bytes(),
210 }
211 return err
212 }
213
214 errorBody.Seek(0, io.SeekStart)
215
216 return output
217 }
218
219 func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
220 output := &types.InternalServerException{}
221 var buff [1024]byte
222 ringBuffer := smithyio.NewRingBuffer(buff[:])
223
224 body := io.TeeReader(errorBody, ringBuffer)
225 decoder := json.NewDecoder(body)
226 decoder.UseNumber()
227 var shape interface{}
228 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
229 var snapshot bytes.Buffer
230 io.Copy(&snapshot, ringBuffer)
231 err = &smithy.DeserializationError{
232 Err: fmt.Errorf("failed to decode response body, %w", err),
233 Snapshot: snapshot.Bytes(),
234 }
235 return err
236 }
237
238 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape)
239
240 if err != nil {
241 var snapshot bytes.Buffer
242 io.Copy(&snapshot, ringBuffer)
243 err = &smithy.DeserializationError{
244 Err: fmt.Errorf("failed to decode response body, %w", err),
245 Snapshot: snapshot.Bytes(),
246 }
247 return err
248 }
249
250 errorBody.Seek(0, io.SeekStart)
251
252 return output
253 }
254
255 func awsRestjson1_deserializeErrorTooManyRequestsError(response *smithyhttp.Response, errorBody *bytes.Reader) error {
256 output := &types.TooManyRequestsError{}
257 var buff [1024]byte
258 ringBuffer := smithyio.NewRingBuffer(buff[:])
259
260 body := io.TeeReader(errorBody, ringBuffer)
261 decoder := json.NewDecoder(body)
262 decoder.UseNumber()
263 var shape interface{}
264 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
265 var snapshot bytes.Buffer
266 io.Copy(&snapshot, ringBuffer)
267 err = &smithy.DeserializationError{
268 Err: fmt.Errorf("failed to decode response body, %w", err),
269 Snapshot: snapshot.Bytes(),
270 }
271 return err
272 }
273
274 err := awsRestjson1_deserializeDocumentTooManyRequestsError(&output, shape)
275
276 if err != nil {
277 var snapshot bytes.Buffer
278 io.Copy(&snapshot, ringBuffer)
279 err = &smithy.DeserializationError{
280 Err: fmt.Errorf("failed to decode response body, %w", err),
281 Snapshot: snapshot.Bytes(),
282 }
283 return err
284 }
285
286 errorBody.Seek(0, io.SeekStart)
287
288 return output
289 }
290
291 func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
292 output := &types.ValidationException{}
293 var buff [1024]byte
294 ringBuffer := smithyio.NewRingBuffer(buff[:])
295
296 body := io.TeeReader(errorBody, ringBuffer)
297 decoder := json.NewDecoder(body)
298 decoder.UseNumber()
299 var shape interface{}
300 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
301 var snapshot bytes.Buffer
302 io.Copy(&snapshot, ringBuffer)
303 err = &smithy.DeserializationError{
304 Err: fmt.Errorf("failed to decode response body, %w", err),
305 Snapshot: snapshot.Bytes(),
306 }
307 return err
308 }
309
310 err := awsRestjson1_deserializeDocumentValidationException(&output, shape)
311
312 if err != nil {
313 var snapshot bytes.Buffer
314 io.Copy(&snapshot, ringBuffer)
315 err = &smithy.DeserializationError{
316 Err: fmt.Errorf("failed to decode response body, %w", err),
317 Snapshot: snapshot.Bytes(),
318 }
319 return err
320 }
321
322 errorBody.Seek(0, io.SeekStart)
323
324 return output
325 }
326
327 func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
328 if v == nil {
329 return fmt.Errorf("unexpected nil of type %T", v)
330 }
331 if value == nil {
332 return nil
333 }
334
335 shape, ok := value.(map[string]interface{})
336 if !ok {
337 return fmt.Errorf("unexpected JSON type %v", value)
338 }
339
340 var sv *types.AccessDeniedException
341 if *v == nil {
342 sv = &types.AccessDeniedException{}
343 } else {
344 sv = *v
345 }
346
347 for key, value := range shape {
348 switch key {
349 case "error":
350 if value != nil {
351 jtv, ok := value.(string)
352 if !ok {
353 return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
354 }
355 sv.Error_ = types.OAuth2ErrorCode(jtv)
356 }
357
358 case "message", "Message":
359 if value != nil {
360 jtv, ok := value.(string)
361 if !ok {
362 return fmt.Errorf("expected String to be of type string, got %T instead", value)
363 }
364 sv.Message = ptr.String(jtv)
365 }
366
367 default:
368 _, _ = key, value
369
370 }
371 }
372 *v = sv
373 return nil
374 }
375
376 func awsRestjson1_deserializeDocumentAccessToken(v **types.AccessToken, value interface{}) error {
377 if v == nil {
378 return fmt.Errorf("unexpected nil of type %T", v)
379 }
380 if value == nil {
381 return nil
382 }
383
384 shape, ok := value.(map[string]interface{})
385 if !ok {
386 return fmt.Errorf("unexpected JSON type %v", value)
387 }
388
389 var sv *types.AccessToken
390 if *v == nil {
391 sv = &types.AccessToken{}
392 } else {
393 sv = *v
394 }
395
396 for key, value := range shape {
397 switch key {
398 case "accessKeyId":
399 if value != nil {
400 jtv, ok := value.(string)
401 if !ok {
402 return fmt.Errorf("expected String to be of type string, got %T instead", value)
403 }
404 sv.AccessKeyId = ptr.String(jtv)
405 }
406
407 case "secretAccessKey":
408 if value != nil {
409 jtv, ok := value.(string)
410 if !ok {
411 return fmt.Errorf("expected String to be of type string, got %T instead", value)
412 }
413 sv.SecretAccessKey = ptr.String(jtv)
414 }
415
416 case "sessionToken":
417 if value != nil {
418 jtv, ok := value.(string)
419 if !ok {
420 return fmt.Errorf("expected String to be of type string, got %T instead", value)
421 }
422 sv.SessionToken = ptr.String(jtv)
423 }
424
425 default:
426 _, _ = key, value
427
428 }
429 }
430 *v = sv
431 return nil
432 }
433
434 func awsRestjson1_deserializeDocumentCreateOAuth2TokenResponseBody(v **types.CreateOAuth2TokenResponseBody, value interface{}) error {
435 if v == nil {
436 return fmt.Errorf("unexpected nil of type %T", v)
437 }
438 if value == nil {
439 return nil
440 }
441
442 shape, ok := value.(map[string]interface{})
443 if !ok {
444 return fmt.Errorf("unexpected JSON type %v", value)
445 }
446
447 var sv *types.CreateOAuth2TokenResponseBody
448 if *v == nil {
449 sv = &types.CreateOAuth2TokenResponseBody{}
450 } else {
451 sv = *v
452 }
453
454 for key, value := range shape {
455 switch key {
456 case "accessToken":
457 if err := awsRestjson1_deserializeDocumentAccessToken(&sv.AccessToken, value); err != nil {
458 return err
459 }
460
461 case "expiresIn":
462 if value != nil {
463 jtv, ok := value.(json.Number)
464 if !ok {
465 return fmt.Errorf("expected ExpiresIn to be json.Number, got %T instead", value)
466 }
467 i64, err := jtv.Int64()
468 if err != nil {
469 return err
470 }
471 sv.ExpiresIn = ptr.Int32(int32(i64))
472 }
473
474 case "idToken":
475 if value != nil {
476 jtv, ok := value.(string)
477 if !ok {
478 return fmt.Errorf("expected IdToken to be of type string, got %T instead", value)
479 }
480 sv.IdToken = ptr.String(jtv)
481 }
482
483 case "refreshToken":
484 if value != nil {
485 jtv, ok := value.(string)
486 if !ok {
487 return fmt.Errorf("expected RefreshToken to be of type string, got %T instead", value)
488 }
489 sv.RefreshToken = ptr.String(jtv)
490 }
491
492 case "tokenType":
493 if value != nil {
494 jtv, ok := value.(string)
495 if !ok {
496 return fmt.Errorf("expected TokenType to be of type string, got %T instead", value)
497 }
498 sv.TokenType = ptr.String(jtv)
499 }
500
501 default:
502 _, _ = key, value
503
504 }
505 }
506 *v = sv
507 return nil
508 }
509
510 func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error {
511 if v == nil {
512 return fmt.Errorf("unexpected nil of type %T", v)
513 }
514 if value == nil {
515 return nil
516 }
517
518 shape, ok := value.(map[string]interface{})
519 if !ok {
520 return fmt.Errorf("unexpected JSON type %v", value)
521 }
522
523 var sv *types.InternalServerException
524 if *v == nil {
525 sv = &types.InternalServerException{}
526 } else {
527 sv = *v
528 }
529
530 for key, value := range shape {
531 switch key {
532 case "error":
533 if value != nil {
534 jtv, ok := value.(string)
535 if !ok {
536 return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
537 }
538 sv.Error_ = types.OAuth2ErrorCode(jtv)
539 }
540
541 case "message", "Message":
542 if value != nil {
543 jtv, ok := value.(string)
544 if !ok {
545 return fmt.Errorf("expected String to be of type string, got %T instead", value)
546 }
547 sv.Message = ptr.String(jtv)
548 }
549
550 default:
551 _, _ = key, value
552
553 }
554 }
555 *v = sv
556 return nil
557 }
558
559 func awsRestjson1_deserializeDocumentTooManyRequestsError(v **types.TooManyRequestsError, value interface{}) error {
560 if v == nil {
561 return fmt.Errorf("unexpected nil of type %T", v)
562 }
563 if value == nil {
564 return nil
565 }
566
567 shape, ok := value.(map[string]interface{})
568 if !ok {
569 return fmt.Errorf("unexpected JSON type %v", value)
570 }
571
572 var sv *types.TooManyRequestsError
573 if *v == nil {
574 sv = &types.TooManyRequestsError{}
575 } else {
576 sv = *v
577 }
578
579 for key, value := range shape {
580 switch key {
581 case "error":
582 if value != nil {
583 jtv, ok := value.(string)
584 if !ok {
585 return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
586 }
587 sv.Error_ = types.OAuth2ErrorCode(jtv)
588 }
589
590 case "message", "Message":
591 if value != nil {
592 jtv, ok := value.(string)
593 if !ok {
594 return fmt.Errorf("expected String to be of type string, got %T instead", value)
595 }
596 sv.Message = ptr.String(jtv)
597 }
598
599 default:
600 _, _ = key, value
601
602 }
603 }
604 *v = sv
605 return nil
606 }
607
608 func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error {
609 if v == nil {
610 return fmt.Errorf("unexpected nil of type %T", v)
611 }
612 if value == nil {
613 return nil
614 }
615
616 shape, ok := value.(map[string]interface{})
617 if !ok {
618 return fmt.Errorf("unexpected JSON type %v", value)
619 }
620
621 var sv *types.ValidationException
622 if *v == nil {
623 sv = &types.ValidationException{}
624 } else {
625 sv = *v
626 }
627
628 for key, value := range shape {
629 switch key {
630 case "error":
631 if value != nil {
632 jtv, ok := value.(string)
633 if !ok {
634 return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
635 }
636 sv.Error_ = types.OAuth2ErrorCode(jtv)
637 }
638
639 case "message", "Message":
640 if value != nil {
641 jtv, ok := value.(string)
642 if !ok {
643 return fmt.Errorf("expected String to be of type string, got %T instead", value)
644 }
645 sv.Message = ptr.String(jtv)
646 }
647
648 default:
649 _, _ = key, value
650
651 }
652 }
653 *v = sv
654 return nil
655 }
656