]>
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 | // ParamMaxLenErrCode is the error code for value being too long. | |
21 | ParamMaxLenErrCode = "ParamMaxLenError" | |
22 | ||
23 | // ParamFormatErrCode is the error code for a field with invalid | |
24 | // format or characters. | |
25 | ParamFormatErrCode = "ParamFormatInvalidError" | |
26 | ) | |
27 | ||
28 | // Validator provides a way for types to perform validation logic on their | |
29 | // input values that external code can use to determine if a type's values | |
30 | // are valid. | |
31 | type Validator interface { | |
32 | Validate() error | |
33 | } | |
34 | ||
35 | // An ErrInvalidParams provides wrapping of invalid parameter errors found when | |
36 | // validating API operation input parameters. | |
37 | type ErrInvalidParams struct { | |
38 | // Context is the base context of the invalid parameter group. | |
39 | Context string | |
40 | errs []ErrInvalidParam | |
41 | } | |
42 | ||
43 | // Add adds a new invalid parameter error to the collection of invalid | |
44 | // parameters. The context of the invalid parameter will be updated to reflect | |
45 | // this collection. | |
46 | func (e *ErrInvalidParams) Add(err ErrInvalidParam) { | |
47 | err.SetContext(e.Context) | |
48 | e.errs = append(e.errs, err) | |
49 | } | |
50 | ||
51 | // AddNested adds the invalid parameter errors from another ErrInvalidParams | |
52 | // value into this collection. The nested errors will have their nested context | |
53 | // updated and base context to reflect the merging. | |
54 | // | |
55 | // Use for nested validations errors. | |
56 | func (e *ErrInvalidParams) AddNested(nestedCtx string, nested ErrInvalidParams) { | |
57 | for _, err := range nested.errs { | |
58 | err.SetContext(e.Context) | |
59 | err.AddNestedContext(nestedCtx) | |
60 | e.errs = append(e.errs, err) | |
61 | } | |
62 | } | |
63 | ||
64 | // Len returns the number of invalid parameter errors | |
65 | func (e ErrInvalidParams) Len() int { | |
66 | return len(e.errs) | |
67 | } | |
68 | ||
69 | // Code returns the code of the error | |
70 | func (e ErrInvalidParams) Code() string { | |
71 | return InvalidParameterErrCode | |
72 | } | |
73 | ||
74 | // Message returns the message of the error | |
75 | func (e ErrInvalidParams) Message() string { | |
76 | return fmt.Sprintf("%d validation error(s) found.", len(e.errs)) | |
77 | } | |
78 | ||
79 | // Error returns the string formatted form of the invalid parameters. | |
80 | func (e ErrInvalidParams) Error() string { | |
81 | w := &bytes.Buffer{} | |
82 | fmt.Fprintf(w, "%s: %s\n", e.Code(), e.Message()) | |
83 | ||
84 | for _, err := range e.errs { | |
85 | fmt.Fprintf(w, "- %s\n", err.Message()) | |
86 | } | |
87 | ||
88 | return w.String() | |
89 | } | |
90 | ||
91 | // OrigErr returns the invalid parameters as a awserr.BatchedErrors value | |
92 | func (e ErrInvalidParams) OrigErr() error { | |
93 | return awserr.NewBatchError( | |
94 | InvalidParameterErrCode, e.Message(), e.OrigErrs()) | |
95 | } | |
96 | ||
97 | // OrigErrs returns a slice of the invalid parameters | |
98 | func (e ErrInvalidParams) OrigErrs() []error { | |
99 | errs := make([]error, len(e.errs)) | |
100 | for i := 0; i < len(errs); i++ { | |
101 | errs[i] = e.errs[i] | |
102 | } | |
103 | ||
104 | return errs | |
105 | } | |
106 | ||
107 | // An ErrInvalidParam represents an invalid parameter error type. | |
108 | type ErrInvalidParam interface { | |
109 | awserr.Error | |
110 | ||
111 | // Field name the error occurred on. | |
112 | Field() string | |
113 | ||
114 | // SetContext updates the context of the error. | |
115 | SetContext(string) | |
116 | ||
117 | // AddNestedContext updates the error's context to include a nested level. | |
118 | AddNestedContext(string) | |
119 | } | |
120 | ||
121 | type errInvalidParam struct { | |
122 | context string | |
123 | nestedContext string | |
124 | field string | |
125 | code string | |
126 | msg string | |
127 | } | |
128 | ||
129 | // Code returns the error code for the type of invalid parameter. | |
130 | func (e *errInvalidParam) Code() string { | |
131 | return e.code | |
132 | } | |
133 | ||
134 | // Message returns the reason the parameter was invalid, and its context. | |
135 | func (e *errInvalidParam) Message() string { | |
136 | return fmt.Sprintf("%s, %s.", e.msg, e.Field()) | |
137 | } | |
138 | ||
139 | // Error returns the string version of the invalid parameter error. | |
140 | func (e *errInvalidParam) Error() string { | |
141 | return fmt.Sprintf("%s: %s", e.code, e.Message()) | |
142 | } | |
143 | ||
144 | // OrigErr returns nil, Implemented for awserr.Error interface. | |
145 | func (e *errInvalidParam) OrigErr() error { | |
146 | return nil | |
147 | } | |
148 | ||
149 | // Field Returns the field and context the error occurred. | |
150 | func (e *errInvalidParam) Field() string { | |
151 | field := e.context | |
152 | if len(field) > 0 { | |
153 | field += "." | |
154 | } | |
155 | if len(e.nestedContext) > 0 { | |
156 | field += fmt.Sprintf("%s.", e.nestedContext) | |
157 | } | |
158 | field += e.field | |
159 | ||
160 | return field | |
161 | } | |
162 | ||
163 | // SetContext updates the base context of the error. | |
164 | func (e *errInvalidParam) SetContext(ctx string) { | |
165 | e.context = ctx | |
166 | } | |
167 | ||
168 | // AddNestedContext prepends a context to the field's path. | |
169 | func (e *errInvalidParam) AddNestedContext(ctx string) { | |
170 | if len(e.nestedContext) == 0 { | |
171 | e.nestedContext = ctx | |
172 | } else { | |
173 | e.nestedContext = fmt.Sprintf("%s.%s", ctx, e.nestedContext) | |
174 | } | |
175 | ||
176 | } | |
177 | ||
178 | // An ErrParamRequired represents an required parameter error. | |
179 | type ErrParamRequired struct { | |
180 | errInvalidParam | |
181 | } | |
182 | ||
183 | // NewErrParamRequired creates a new required parameter error. | |
184 | func NewErrParamRequired(field string) *ErrParamRequired { | |
185 | return &ErrParamRequired{ | |
186 | errInvalidParam{ | |
187 | code: ParamRequiredErrCode, | |
188 | field: field, | |
189 | msg: fmt.Sprintf("missing required field"), | |
190 | }, | |
191 | } | |
192 | } | |
193 | ||
194 | // An ErrParamMinValue represents a minimum value parameter error. | |
195 | type ErrParamMinValue struct { | |
196 | errInvalidParam | |
197 | min float64 | |
198 | } | |
199 | ||
200 | // NewErrParamMinValue creates a new minimum value parameter error. | |
201 | func NewErrParamMinValue(field string, min float64) *ErrParamMinValue { | |
202 | return &ErrParamMinValue{ | |
203 | errInvalidParam: errInvalidParam{ | |
204 | code: ParamMinValueErrCode, | |
205 | field: field, | |
206 | msg: fmt.Sprintf("minimum field value of %v", min), | |
207 | }, | |
208 | min: min, | |
209 | } | |
210 | } | |
211 | ||
212 | // MinValue returns the field's require minimum value. | |
213 | // | |
214 | // float64 is returned for both int and float min values. | |
215 | func (e *ErrParamMinValue) MinValue() float64 { | |
216 | return e.min | |
217 | } | |
218 | ||
219 | // An ErrParamMinLen represents a minimum length parameter error. | |
220 | type ErrParamMinLen struct { | |
221 | errInvalidParam | |
222 | min int | |
223 | } | |
224 | ||
225 | // NewErrParamMinLen creates a new minimum length parameter error. | |
226 | func NewErrParamMinLen(field string, min int) *ErrParamMinLen { | |
227 | return &ErrParamMinLen{ | |
228 | errInvalidParam: errInvalidParam{ | |
229 | code: ParamMinLenErrCode, | |
230 | field: field, | |
231 | msg: fmt.Sprintf("minimum field size of %v", min), | |
232 | }, | |
233 | min: min, | |
234 | } | |
235 | } | |
236 | ||
237 | // MinLen returns the field's required minimum length. | |
238 | func (e *ErrParamMinLen) MinLen() int { | |
239 | return e.min | |
240 | } | |
241 | ||
242 | // An ErrParamMaxLen represents a maximum length parameter error. | |
243 | type ErrParamMaxLen struct { | |
244 | errInvalidParam | |
245 | max int | |
246 | } | |
247 | ||
248 | // NewErrParamMaxLen creates a new maximum length parameter error. | |
249 | func NewErrParamMaxLen(field string, max int, value string) *ErrParamMaxLen { | |
250 | return &ErrParamMaxLen{ | |
251 | errInvalidParam: errInvalidParam{ | |
252 | code: ParamMaxLenErrCode, | |
253 | field: field, | |
254 | msg: fmt.Sprintf("maximum size of %v, %v", max, value), | |
255 | }, | |
256 | max: max, | |
257 | } | |
258 | } | |
259 | ||
260 | // MaxLen returns the field's required minimum length. | |
261 | func (e *ErrParamMaxLen) MaxLen() int { | |
262 | return e.max | |
263 | } | |
264 | ||
265 | // An ErrParamFormat represents a invalid format parameter error. | |
266 | type ErrParamFormat struct { | |
267 | errInvalidParam | |
268 | format string | |
269 | } | |
270 | ||
271 | // NewErrParamFormat creates a new invalid format parameter error. | |
272 | func NewErrParamFormat(field string, format, value string) *ErrParamFormat { | |
273 | return &ErrParamFormat{ | |
274 | errInvalidParam: errInvalidParam{ | |
275 | code: ParamFormatErrCode, | |
276 | field: field, | |
277 | msg: fmt.Sprintf("format %v, %v", format, value), | |
278 | }, | |
279 | format: format, | |
280 | } | |
281 | } | |
282 | ||
283 | // Format returns the field's required format. | |
284 | func (e *ErrParamFormat) Format() string { | |
285 | return e.format | |
286 | } |