1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package personalizeevents
4
5import (
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/personalizeevents/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	smithyhttp "github.com/aws/smithy-go/transport/http"
17	"io"
18	"io/ioutil"
19	"strings"
20)
21
22type awsRestjson1_deserializeOpPutEvents struct {
23}
24
25func (*awsRestjson1_deserializeOpPutEvents) ID() string {
26	return "OperationDeserializer"
27}
28
29func (m *awsRestjson1_deserializeOpPutEvents) 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	response, ok := out.RawResponse.(*smithyhttp.Response)
38	if !ok {
39		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
40	}
41
42	if response.StatusCode < 200 || response.StatusCode >= 300 {
43		return out, metadata, awsRestjson1_deserializeOpErrorPutEvents(response, &metadata)
44	}
45	output := &PutEventsOutput{}
46	out.Result = output
47
48	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
49		return out, metadata, &smithy.DeserializationError{
50			Err: fmt.Errorf("failed to discard response body, %w", err),
51		}
52	}
53
54	return out, metadata, err
55}
56
57func awsRestjson1_deserializeOpErrorPutEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
58	var errorBuffer bytes.Buffer
59	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
60		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
61	}
62	errorBody := bytes.NewReader(errorBuffer.Bytes())
63
64	errorCode := "UnknownError"
65	errorMessage := errorCode
66
67	code := response.Header.Get("X-Amzn-ErrorType")
68	if len(code) != 0 {
69		errorCode = restjson.SanitizeErrorCode(code)
70	}
71
72	var buff [1024]byte
73	ringBuffer := smithyio.NewRingBuffer(buff[:])
74
75	body := io.TeeReader(errorBody, ringBuffer)
76	decoder := json.NewDecoder(body)
77	decoder.UseNumber()
78	code, message, err := restjson.GetErrorInfo(decoder)
79	if err != nil {
80		var snapshot bytes.Buffer
81		io.Copy(&snapshot, ringBuffer)
82		err = &smithy.DeserializationError{
83			Err:      fmt.Errorf("failed to decode response body, %w", err),
84			Snapshot: snapshot.Bytes(),
85		}
86		return err
87	}
88
89	errorBody.Seek(0, io.SeekStart)
90	if len(code) != 0 {
91		errorCode = restjson.SanitizeErrorCode(code)
92	}
93	if len(message) != 0 {
94		errorMessage = message
95	}
96
97	switch {
98	case strings.EqualFold("InvalidInputException", errorCode):
99		return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
100
101	default:
102		genericError := &smithy.GenericAPIError{
103			Code:    errorCode,
104			Message: errorMessage,
105		}
106		return genericError
107
108	}
109}
110
111type awsRestjson1_deserializeOpPutItems struct {
112}
113
114func (*awsRestjson1_deserializeOpPutItems) ID() string {
115	return "OperationDeserializer"
116}
117
118func (m *awsRestjson1_deserializeOpPutItems) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
119	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
120) {
121	out, metadata, err = next.HandleDeserialize(ctx, in)
122	if err != nil {
123		return out, metadata, err
124	}
125
126	response, ok := out.RawResponse.(*smithyhttp.Response)
127	if !ok {
128		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
129	}
130
131	if response.StatusCode < 200 || response.StatusCode >= 300 {
132		return out, metadata, awsRestjson1_deserializeOpErrorPutItems(response, &metadata)
133	}
134	output := &PutItemsOutput{}
135	out.Result = output
136
137	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
138		return out, metadata, &smithy.DeserializationError{
139			Err: fmt.Errorf("failed to discard response body, %w", err),
140		}
141	}
142
143	return out, metadata, err
144}
145
146func awsRestjson1_deserializeOpErrorPutItems(response *smithyhttp.Response, metadata *middleware.Metadata) error {
147	var errorBuffer bytes.Buffer
148	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
149		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
150	}
151	errorBody := bytes.NewReader(errorBuffer.Bytes())
152
153	errorCode := "UnknownError"
154	errorMessage := errorCode
155
156	code := response.Header.Get("X-Amzn-ErrorType")
157	if len(code) != 0 {
158		errorCode = restjson.SanitizeErrorCode(code)
159	}
160
161	var buff [1024]byte
162	ringBuffer := smithyio.NewRingBuffer(buff[:])
163
164	body := io.TeeReader(errorBody, ringBuffer)
165	decoder := json.NewDecoder(body)
166	decoder.UseNumber()
167	code, message, err := restjson.GetErrorInfo(decoder)
168	if err != nil {
169		var snapshot bytes.Buffer
170		io.Copy(&snapshot, ringBuffer)
171		err = &smithy.DeserializationError{
172			Err:      fmt.Errorf("failed to decode response body, %w", err),
173			Snapshot: snapshot.Bytes(),
174		}
175		return err
176	}
177
178	errorBody.Seek(0, io.SeekStart)
179	if len(code) != 0 {
180		errorCode = restjson.SanitizeErrorCode(code)
181	}
182	if len(message) != 0 {
183		errorMessage = message
184	}
185
186	switch {
187	case strings.EqualFold("InvalidInputException", errorCode):
188		return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
189
190	case strings.EqualFold("ResourceInUseException", errorCode):
191		return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
192
193	case strings.EqualFold("ResourceNotFoundException", errorCode):
194		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
195
196	default:
197		genericError := &smithy.GenericAPIError{
198			Code:    errorCode,
199			Message: errorMessage,
200		}
201		return genericError
202
203	}
204}
205
206type awsRestjson1_deserializeOpPutUsers struct {
207}
208
209func (*awsRestjson1_deserializeOpPutUsers) ID() string {
210	return "OperationDeserializer"
211}
212
213func (m *awsRestjson1_deserializeOpPutUsers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
214	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
215) {
216	out, metadata, err = next.HandleDeserialize(ctx, in)
217	if err != nil {
218		return out, metadata, err
219	}
220
221	response, ok := out.RawResponse.(*smithyhttp.Response)
222	if !ok {
223		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
224	}
225
226	if response.StatusCode < 200 || response.StatusCode >= 300 {
227		return out, metadata, awsRestjson1_deserializeOpErrorPutUsers(response, &metadata)
228	}
229	output := &PutUsersOutput{}
230	out.Result = output
231
232	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
233		return out, metadata, &smithy.DeserializationError{
234			Err: fmt.Errorf("failed to discard response body, %w", err),
235		}
236	}
237
238	return out, metadata, err
239}
240
241func awsRestjson1_deserializeOpErrorPutUsers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
242	var errorBuffer bytes.Buffer
243	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
244		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
245	}
246	errorBody := bytes.NewReader(errorBuffer.Bytes())
247
248	errorCode := "UnknownError"
249	errorMessage := errorCode
250
251	code := response.Header.Get("X-Amzn-ErrorType")
252	if len(code) != 0 {
253		errorCode = restjson.SanitizeErrorCode(code)
254	}
255
256	var buff [1024]byte
257	ringBuffer := smithyio.NewRingBuffer(buff[:])
258
259	body := io.TeeReader(errorBody, ringBuffer)
260	decoder := json.NewDecoder(body)
261	decoder.UseNumber()
262	code, message, err := restjson.GetErrorInfo(decoder)
263	if err != nil {
264		var snapshot bytes.Buffer
265		io.Copy(&snapshot, ringBuffer)
266		err = &smithy.DeserializationError{
267			Err:      fmt.Errorf("failed to decode response body, %w", err),
268			Snapshot: snapshot.Bytes(),
269		}
270		return err
271	}
272
273	errorBody.Seek(0, io.SeekStart)
274	if len(code) != 0 {
275		errorCode = restjson.SanitizeErrorCode(code)
276	}
277	if len(message) != 0 {
278		errorMessage = message
279	}
280
281	switch {
282	case strings.EqualFold("InvalidInputException", errorCode):
283		return awsRestjson1_deserializeErrorInvalidInputException(response, errorBody)
284
285	case strings.EqualFold("ResourceInUseException", errorCode):
286		return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody)
287
288	case strings.EqualFold("ResourceNotFoundException", errorCode):
289		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
290
291	default:
292		genericError := &smithy.GenericAPIError{
293			Code:    errorCode,
294			Message: errorMessage,
295		}
296		return genericError
297
298	}
299}
300
301func awsRestjson1_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
302	output := &types.InvalidInputException{}
303	var buff [1024]byte
304	ringBuffer := smithyio.NewRingBuffer(buff[:])
305
306	body := io.TeeReader(errorBody, ringBuffer)
307	decoder := json.NewDecoder(body)
308	decoder.UseNumber()
309	var shape interface{}
310	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
311		var snapshot bytes.Buffer
312		io.Copy(&snapshot, ringBuffer)
313		err = &smithy.DeserializationError{
314			Err:      fmt.Errorf("failed to decode response body, %w", err),
315			Snapshot: snapshot.Bytes(),
316		}
317		return err
318	}
319
320	err := awsRestjson1_deserializeDocumentInvalidInputException(&output, shape)
321
322	if err != nil {
323		var snapshot bytes.Buffer
324		io.Copy(&snapshot, ringBuffer)
325		err = &smithy.DeserializationError{
326			Err:      fmt.Errorf("failed to decode response body, %w", err),
327			Snapshot: snapshot.Bytes(),
328		}
329		return err
330	}
331
332	errorBody.Seek(0, io.SeekStart)
333
334	return output
335}
336
337func awsRestjson1_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
338	output := &types.ResourceInUseException{}
339	var buff [1024]byte
340	ringBuffer := smithyio.NewRingBuffer(buff[:])
341
342	body := io.TeeReader(errorBody, ringBuffer)
343	decoder := json.NewDecoder(body)
344	decoder.UseNumber()
345	var shape interface{}
346	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
347		var snapshot bytes.Buffer
348		io.Copy(&snapshot, ringBuffer)
349		err = &smithy.DeserializationError{
350			Err:      fmt.Errorf("failed to decode response body, %w", err),
351			Snapshot: snapshot.Bytes(),
352		}
353		return err
354	}
355
356	err := awsRestjson1_deserializeDocumentResourceInUseException(&output, shape)
357
358	if err != nil {
359		var snapshot bytes.Buffer
360		io.Copy(&snapshot, ringBuffer)
361		err = &smithy.DeserializationError{
362			Err:      fmt.Errorf("failed to decode response body, %w", err),
363			Snapshot: snapshot.Bytes(),
364		}
365		return err
366	}
367
368	errorBody.Seek(0, io.SeekStart)
369
370	return output
371}
372
373func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
374	output := &types.ResourceNotFoundException{}
375	var buff [1024]byte
376	ringBuffer := smithyio.NewRingBuffer(buff[:])
377
378	body := io.TeeReader(errorBody, ringBuffer)
379	decoder := json.NewDecoder(body)
380	decoder.UseNumber()
381	var shape interface{}
382	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
383		var snapshot bytes.Buffer
384		io.Copy(&snapshot, ringBuffer)
385		err = &smithy.DeserializationError{
386			Err:      fmt.Errorf("failed to decode response body, %w", err),
387			Snapshot: snapshot.Bytes(),
388		}
389		return err
390	}
391
392	err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape)
393
394	if err != nil {
395		var snapshot bytes.Buffer
396		io.Copy(&snapshot, ringBuffer)
397		err = &smithy.DeserializationError{
398			Err:      fmt.Errorf("failed to decode response body, %w", err),
399			Snapshot: snapshot.Bytes(),
400		}
401		return err
402	}
403
404	errorBody.Seek(0, io.SeekStart)
405
406	return output
407}
408
409func awsRestjson1_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error {
410	if v == nil {
411		return fmt.Errorf("unexpected nil of type %T", v)
412	}
413	if value == nil {
414		return nil
415	}
416
417	shape, ok := value.(map[string]interface{})
418	if !ok {
419		return fmt.Errorf("unexpected JSON type %v", value)
420	}
421
422	var sv *types.InvalidInputException
423	if *v == nil {
424		sv = &types.InvalidInputException{}
425	} else {
426		sv = *v
427	}
428
429	for key, value := range shape {
430		switch key {
431		case "message":
432			if value != nil {
433				jtv, ok := value.(string)
434				if !ok {
435					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
436				}
437				sv.Message = ptr.String(jtv)
438			}
439
440		default:
441			_, _ = key, value
442
443		}
444	}
445	*v = sv
446	return nil
447}
448
449func awsRestjson1_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error {
450	if v == nil {
451		return fmt.Errorf("unexpected nil of type %T", v)
452	}
453	if value == nil {
454		return nil
455	}
456
457	shape, ok := value.(map[string]interface{})
458	if !ok {
459		return fmt.Errorf("unexpected JSON type %v", value)
460	}
461
462	var sv *types.ResourceInUseException
463	if *v == nil {
464		sv = &types.ResourceInUseException{}
465	} else {
466		sv = *v
467	}
468
469	for key, value := range shape {
470		switch key {
471		case "message":
472			if value != nil {
473				jtv, ok := value.(string)
474				if !ok {
475					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
476				}
477				sv.Message = ptr.String(jtv)
478			}
479
480		default:
481			_, _ = key, value
482
483		}
484	}
485	*v = sv
486	return nil
487}
488
489func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
490	if v == nil {
491		return fmt.Errorf("unexpected nil of type %T", v)
492	}
493	if value == nil {
494		return nil
495	}
496
497	shape, ok := value.(map[string]interface{})
498	if !ok {
499		return fmt.Errorf("unexpected JSON type %v", value)
500	}
501
502	var sv *types.ResourceNotFoundException
503	if *v == nil {
504		sv = &types.ResourceNotFoundException{}
505	} else {
506		sv = *v
507	}
508
509	for key, value := range shape {
510		switch key {
511		case "message":
512			if value != nil {
513				jtv, ok := value.(string)
514				if !ok {
515					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
516				}
517				sv.Message = ptr.String(jtv)
518			}
519
520		default:
521			_, _ = key, value
522
523		}
524	}
525	*v = sv
526	return nil
527}
528