]>
Commit | Line | Data |
---|---|---|
1 | package request | |
2 | ||
3 | import ( | |
4 | "bytes" | |
5 | "fmt" | |
6 | ||
7 | "github.com/aws/aws-sdk-go/aws/awserr" | |
8 | ) | |
9 | ||
10 | const ( | |
11 | // InvalidParameterErrCode is the error code for invalid parameters errors | |
12 | InvalidParameterErrCode = "InvalidParameter" | |
13 | // ParamRequiredErrCode is the error code for required parameter errors | |
14 | ParamRequiredErrCode = "ParamRequiredError" | |
15 | // ParamMinValueErrCode is the error code for fields with too low of a | |
16 | // number value. | |
17 | ParamMinValueErrCode = "ParamMinValueError" | |
18 | // ParamMinLenErrCode is the error code for fields without enough elements. | |
19 | ParamMinLenErrCode = "ParamMinLenError" | |
20 | ) | |
21 | ||
22 | // Validator provides a way for types to perform validation logic on their | |
23 | // input values that external code can use to determine if a type's values | |
24 | // are valid. | |
25 | type Validator interface { | |
26 | Validate() error | |
27 | } | |
28 | ||
29 | // An ErrInvalidParams provides wrapping of invalid parameter errors found when | |
30 | // validating API operation input parameters. | |
31 | type ErrInvalidParams struct { | |
32 | // Context is the base context of the invalid parameter group. | |
33 | Context string | |
34 | errs []ErrInvalidParam | |
35 | } | |
36 | ||
37 | // Add adds a new invalid parameter error to the collection of invalid | |
38 | // parameters. The context of the invalid parameter will be updated to reflect | |
39 | // this collection. | |
40 | func (e *ErrInvalidParams) Add(err ErrInvalidParam) { | |
41 | err.SetContext(e.Context) | |
42 | e.errs = append(e.errs, err) | |
43 | } | |
44 | ||
45 | // AddNested adds the invalid parameter errors from another ErrInvalidParams | |
46 | // value into this collection. The nested errors will have their nested context | |
47 | // updated and base context to reflect the merging. | |
48 | // | |
49 | // Use for nested validations errors. | |
50 | func (e *ErrInvalidParams) AddNested(nestedCtx string, nested ErrInvalidParams) { | |
51 | for _, err := range nested.errs { | |
52 | err.SetContext(e.Context) | |
53 | err.AddNestedContext(nestedCtx) | |
54 | e.errs = append(e.errs, err) | |
55 | } | |
56 | } | |
57 | ||
58 | // Len returns the number of invalid parameter errors | |
59 | func (e ErrInvalidParams) Len() int { | |
60 | return len(e.errs) | |
61 | } | |
62 | ||
63 | // Code returns the code of the error | |
64 | func (e ErrInvalidParams) Code() string { | |
65 | return InvalidParameterErrCode | |
66 | } | |
67 | ||
68 | // Message returns the message of the error | |
69 | func (e ErrInvalidParams) Message() string { | |
70 | return fmt.Sprintf("%d validation error(s) found.", len(e.errs)) | |
71 | } | |
72 | ||
73 | // Error returns the string formatted form of the invalid parameters. | |
74 | func (e ErrInvalidParams) Error() string { | |
75 | w := &bytes.Buffer{} | |
76 | fmt.Fprintf(w, "%s: %s\n", e.Code(), e.Message()) | |
77 | ||
78 | for _, err := range e.errs { | |
79 | fmt.Fprintf(w, "- %s\n", err.Message()) | |
80 | } | |
81 | ||
82 | return w.String() | |
83 | } | |
84 | ||
85 | // OrigErr returns the invalid parameters as a awserr.BatchedErrors value | |
86 | func (e ErrInvalidParams) OrigErr() error { | |
87 | return awserr.NewBatchError( | |
88 | InvalidParameterErrCode, e.Message(), e.OrigErrs()) | |
89 | } | |
90 | ||
91 | // OrigErrs returns a slice of the invalid parameters | |
92 | func (e ErrInvalidParams) OrigErrs() []error { | |
93 | errs := make([]error, len(e.errs)) | |
94 | for i := 0; i < len(errs); i++ { | |
95 | errs[i] = e.errs[i] | |
96 | } | |
97 | ||
98 | return errs | |
99 | } | |
100 | ||
101 | // An ErrInvalidParam represents an invalid parameter error type. | |
102 | type ErrInvalidParam interface { | |
103 | awserr.Error | |
104 | ||
105 | // Field name the error occurred on. | |
106 | Field() string | |
107 | ||
108 | // SetContext updates the context of the error. | |
109 | SetContext(string) | |
110 | ||
111 | // AddNestedContext updates the error's context to include a nested level. | |
112 | AddNestedContext(string) | |
113 | } | |
114 | ||
115 | type errInvalidParam struct { | |
116 | context string | |
117 | nestedContext string | |
118 | field string | |
119 | code string | |
120 | msg string | |
121 | } | |
122 | ||
123 | // Code returns the error code for the type of invalid parameter. | |
124 | func (e *errInvalidParam) Code() string { | |
125 | return e.code | |
126 | } | |
127 | ||
128 | // Message returns the reason the parameter was invalid, and its context. | |
129 | func (e *errInvalidParam) Message() string { | |
130 | return fmt.Sprintf("%s, %s.", e.msg, e.Field()) | |
131 | } | |
132 | ||
133 | // Error returns the string version of the invalid parameter error. | |
134 | func (e *errInvalidParam) Error() string { | |
135 | return fmt.Sprintf("%s: %s", e.code, e.Message()) | |
136 | } | |
137 | ||
138 | // OrigErr returns nil, Implemented for awserr.Error interface. | |
139 | func (e *errInvalidParam) OrigErr() error { | |
140 | return nil | |
141 | } | |
142 | ||
143 | // Field Returns the field and context the error occurred. | |
144 | func (e *errInvalidParam) Field() string { | |
145 | field := e.context | |
146 | if len(field) > 0 { | |
147 | field += "." | |
148 | } | |
149 | if len(e.nestedContext) > 0 { | |
150 | field += fmt.Sprintf("%s.", e.nestedContext) | |
151 | } | |
152 | field += e.field | |
153 | ||
154 | return field | |
155 | } | |
156 | ||
157 | // SetContext updates the base context of the error. | |
158 | func (e *errInvalidParam) SetContext(ctx string) { | |
159 | e.context = ctx | |
160 | } | |
161 | ||
162 | // AddNestedContext prepends a context to the field's path. | |
163 | func (e *errInvalidParam) AddNestedContext(ctx string) { | |
164 | if len(e.nestedContext) == 0 { | |
165 | e.nestedContext = ctx | |
166 | } else { | |
167 | e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext) | |
168 | } | |
169 | ||
170 | } | |
171 | ||
172 | // An ErrParamRequired represents an required parameter error. | |
173 | type ErrParamRequired struct { | |
174 | errInvalidParam | |
175 | } | |
176 | ||
177 | // NewErrParamRequired creates a new required parameter error. | |
178 | func NewErrParamRequired(field string) *ErrParamRequired { | |
179 | return &ErrParamRequired{ | |
180 | errInvalidParam{ | |
181 | code: ParamRequiredErrCode, | |
182 | field: field, | |
183 | msg: fmt.Sprintf("missing required field"), | |
184 | }, | |
185 | } | |
186 | } | |
187 | ||
188 | // An ErrParamMinValue represents a minimum value parameter error. | |
189 | type ErrParamMinValue struct { | |
190 | errInvalidParam | |
191 | min float64 | |
192 | } | |
193 | ||
194 | // NewErrParamMinValue creates a new minimum value parameter error. | |
195 | func NewErrParamMinValue(field string, min float64) *ErrParamMinValue { | |
196 | return &ErrParamMinValue{ | |
197 | errInvalidParam: errInvalidParam{ | |
198 | code: ParamMinValueErrCode, | |
199 | field: field, | |
200 | msg: fmt.Sprintf("minimum field value of %v", min), | |
201 | }, | |
202 | min: min, | |
203 | } | |
204 | } | |
205 | ||
206 | // MinValue returns the field's require minimum value. | |
207 | // | |
208 | // float64 is returned for both int and float min values. | |
209 | func (e *ErrParamMinValue) MinValue() float64 { | |
210 | return e.min | |
211 | } | |
212 | ||
213 | // An ErrParamMinLen represents a minimum length parameter error. | |
214 | type ErrParamMinLen struct { | |
215 | errInvalidParam | |
216 | min int | |
217 | } | |
218 | ||
219 | // NewErrParamMinLen creates a new minimum length parameter error. | |
220 | func NewErrParamMinLen(field string, min int) *ErrParamMinLen { | |
221 | return &ErrParamMinLen{ | |
222 | errInvalidParam: errInvalidParam{ | |
223 | code: ParamMinValueErrCode, | |
224 | field: field, | |
225 | msg: fmt.Sprintf("minimum field size of %v", min), | |
226 | }, | |
227 | min: min, | |
228 | } | |
229 | } | |
230 | ||
231 | // MinLen returns the field's required minimum length. | |
232 | func (e *ErrParamMinLen) MinLen() int { | |
233 | return e.min | |
234 | } |