1
10
11 package abe
12
13 import (
14 "bytes"
15 "context"
16 "encoding/json"
17 "encoding/xml"
18 "errors"
19 "fmt"
20 "io"
21 "mime/multipart"
22 "net/http"
23 "net/url"
24 "os"
25 "path/filepath"
26 "reflect"
27 "regexp"
28 "strconv"
29 "strings"
30 "time"
31 "unicode/utf8"
32
33 "golang.org/x/oauth2"
34 )
35
36 var (
37 jsonCheck = regexp.MustCompile("(?i:[application|text]/json)")
38 xmlCheck = regexp.MustCompile("(?i:[application|text]/xml)")
39 )
40
41
42
43 type APIClient struct {
44 cfg *Configuration
45 common service
46
47
48
49 ABitOfEverythingServiceApi *ABitOfEverythingServiceApiService
50
51 CamelCaseServiceNameApi *CamelCaseServiceNameApiService
52
53 EchoRpcApi *EchoRpcApiService
54 }
55
56 type service struct {
57 client *APIClient
58 }
59
60
61
62 func NewAPIClient(cfg *Configuration) *APIClient {
63 if cfg.HTTPClient == nil {
64 cfg.HTTPClient = http.DefaultClient
65 }
66
67 c := &APIClient{}
68 c.cfg = cfg
69 c.common.client = c
70
71
72 c.ABitOfEverythingServiceApi = (*ABitOfEverythingServiceApiService)(&c.common)
73 c.CamelCaseServiceNameApi = (*CamelCaseServiceNameApiService)(&c.common)
74 c.EchoRpcApi = (*EchoRpcApiService)(&c.common)
75
76 return c
77 }
78
79 func atoi(in string) (int, error) {
80 return strconv.Atoi(in)
81 }
82
83
84 func selectHeaderContentType(contentTypes []string) string {
85 if len(contentTypes) == 0 {
86 return ""
87 }
88 if contains(contentTypes, "application/json") {
89 return "application/json"
90 }
91 return contentTypes[0]
92 }
93
94
95 func selectHeaderAccept(accepts []string) string {
96 if len(accepts) == 0 {
97 return ""
98 }
99
100 if contains(accepts, "application/json") {
101 return "application/json"
102 }
103
104 return strings.Join(accepts, ",")
105 }
106
107
108 func contains(haystack []string, needle string) bool {
109 for _, a := range haystack {
110 if strings.ToLower(a) == strings.ToLower(needle) {
111 return true
112 }
113 }
114 return false
115 }
116
117
118 func typeCheckParameter(obj interface{}, expected string, name string) error {
119
120 if obj == nil {
121 return nil
122 }
123
124
125 if reflect.TypeOf(obj).String() != expected {
126 return fmt.Errorf("Expected %s to be of type %s but received %s.", name, expected, reflect.TypeOf(obj).String())
127 }
128 return nil
129 }
130
131
132 func parameterToString(obj interface{}, collectionFormat string) string {
133 var delimiter string
134
135 switch collectionFormat {
136 case "pipes":
137 delimiter = "|"
138 case "ssv":
139 delimiter = " "
140 case "tsv":
141 delimiter = "\t"
142 case "csv":
143 delimiter = ","
144 }
145
146 if reflect.TypeOf(obj).Kind() == reflect.Slice {
147 return strings.Trim(strings.Replace(fmt.Sprint(obj), " ", delimiter, -1), "[]")
148 }
149
150 return fmt.Sprintf("%v", obj)
151 }
152
153
154 func (c *APIClient) callAPI(request *http.Request) (*http.Response, error) {
155 return c.cfg.HTTPClient.Do(request)
156 }
157
158
159 func (c *APIClient) ChangeBasePath(path string) {
160 c.cfg.BasePath = path
161 }
162
163
164 func (c *APIClient) prepareRequest(
165 ctx context.Context,
166 path string, method string,
167 postBody interface{},
168 headerParams map[string]string,
169 queryParams url.Values,
170 formParams url.Values,
171 fileName string,
172 fileBytes []byte) (localVarRequest *http.Request, err error) {
173
174 var body *bytes.Buffer
175
176
177 if postBody != nil {
178 contentType := headerParams["Content-Type"]
179 if contentType == "" {
180 contentType = detectContentType(postBody)
181 headerParams["Content-Type"] = contentType
182 }
183
184 body, err = setBody(postBody, contentType)
185 if err != nil {
186 return nil, err
187 }
188 }
189
190
191 if len(formParams) > 0 || (len(fileBytes) > 0 && fileName != "") {
192 if body != nil {
193 return nil, errors.New("Cannot specify postBody and multipart form at the same time.")
194 }
195 body = &bytes.Buffer{}
196 w := multipart.NewWriter(body)
197
198 for k, v := range formParams {
199 for _, iv := range v {
200 if strings.HasPrefix(k, "@") {
201 err = addFile(w, k[1:], iv)
202 if err != nil {
203 return nil, err
204 }
205 } else {
206 w.WriteField(k, iv)
207 }
208 }
209 }
210 if len(fileBytes) > 0 && fileName != "" {
211 w.Boundary()
212
213 part, err := w.CreateFormFile("file", filepath.Base(fileName))
214 if err != nil {
215 return nil, err
216 }
217 _, err = part.Write(fileBytes)
218 if err != nil {
219 return nil, err
220 }
221
222 headerParams["Content-Type"] = w.FormDataContentType()
223 }
224
225
226 headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
227 w.Close()
228 }
229
230
231 url, err := url.Parse(path)
232 if err != nil {
233 return nil, err
234 }
235
236
237 query := url.Query()
238 for k, v := range queryParams {
239 for _, iv := range v {
240 query.Add(k, iv)
241 }
242 }
243
244
245 url.RawQuery = query.Encode()
246
247
248 if body != nil {
249 localVarRequest, err = http.NewRequest(method, url.String(), body)
250 } else {
251 localVarRequest, err = http.NewRequest(method, url.String(), nil)
252 }
253 if err != nil {
254 return nil, err
255 }
256
257
258 if len(headerParams) > 0 {
259 headers := http.Header{}
260 for h, v := range headerParams {
261 headers.Set(h, v)
262 }
263 localVarRequest.Header = headers
264 }
265
266
267 if c.cfg.Host != "" {
268 localVarRequest.Host = c.cfg.Host
269 }
270
271
272 localVarRequest.Header.Add("User-Agent", c.cfg.UserAgent)
273
274 if ctx != nil {
275
276 localVarRequest = localVarRequest.WithContext(ctx)
277
278
279
280
281 if tok, ok := ctx.Value(ContextOAuth2).(oauth2.TokenSource); ok {
282
283 var latestToken *oauth2.Token
284 if latestToken, err = tok.Token(); err != nil {
285 return nil, err
286 }
287
288 latestToken.SetAuthHeader(localVarRequest)
289 }
290
291
292 if auth, ok := ctx.Value(ContextBasicAuth).(BasicAuth); ok {
293 localVarRequest.SetBasicAuth(auth.UserName, auth.Password)
294 }
295
296
297 if auth, ok := ctx.Value(ContextAccessToken).(string); ok {
298 localVarRequest.Header.Add("Authorization", "Bearer "+auth)
299 }
300 }
301
302 for header, value := range c.cfg.DefaultHeader {
303 localVarRequest.Header.Add(header, value)
304 }
305
306 return localVarRequest, nil
307 }
308
309 func (c *APIClient) decode(v interface{}, b []byte, contentType string) (err error) {
310 if strings.Contains(contentType, "application/xml") {
311 if err = xml.Unmarshal(b, v); err != nil {
312 return err
313 }
314 return nil
315 } else if strings.Contains(contentType, "application/json") {
316 if err = json.Unmarshal(b, v); err != nil {
317 return err
318 }
319 return nil
320 }
321 return errors.New("undefined response type")
322 }
323
324
325 func addFile(w *multipart.Writer, fieldName, path string) error {
326 file, err := os.Open(path)
327 if err != nil {
328 return err
329 }
330 defer file.Close()
331
332 part, err := w.CreateFormFile(fieldName, filepath.Base(path))
333 if err != nil {
334 return err
335 }
336 _, err = io.Copy(part, file)
337
338 return err
339 }
340
341
342 func reportError(format string, a ...interface{}) error {
343 return fmt.Errorf(format, a...)
344 }
345
346
347 func setBody(body interface{}, contentType string) (bodyBuf *bytes.Buffer, err error) {
348 if bodyBuf == nil {
349 bodyBuf = &bytes.Buffer{}
350 }
351
352 if reader, ok := body.(io.Reader); ok {
353 _, err = bodyBuf.ReadFrom(reader)
354 } else if b, ok := body.([]byte); ok {
355 _, err = bodyBuf.Write(b)
356 } else if s, ok := body.(string); ok {
357 _, err = bodyBuf.WriteString(s)
358 } else if s, ok := body.(*string); ok {
359 _, err = bodyBuf.WriteString(*s)
360 } else if jsonCheck.MatchString(contentType) {
361 err = json.NewEncoder(bodyBuf).Encode(body)
362 } else if xmlCheck.MatchString(contentType) {
363 xml.NewEncoder(bodyBuf).Encode(body)
364 }
365
366 if err != nil {
367 return nil, err
368 }
369
370 if bodyBuf.Len() == 0 {
371 err = fmt.Errorf("Invalid body type %s\n", contentType)
372 return nil, err
373 }
374 return bodyBuf, nil
375 }
376
377
378 func detectContentType(body interface{}) string {
379 contentType := "text/plain; charset=utf-8"
380 kind := reflect.TypeOf(body).Kind()
381
382 switch kind {
383 case reflect.Struct, reflect.Map, reflect.Ptr:
384 contentType = "application/json; charset=utf-8"
385 case reflect.String:
386 contentType = "text/plain; charset=utf-8"
387 default:
388 if b, ok := body.([]byte); ok {
389 contentType = http.DetectContentType(b)
390 } else if kind == reflect.Slice {
391 contentType = "application/json; charset=utf-8"
392 }
393 }
394
395 return contentType
396 }
397
398
399 type cacheControl map[string]string
400
401 func parseCacheControl(headers http.Header) cacheControl {
402 cc := cacheControl{}
403 ccHeader := headers.Get("Cache-Control")
404 for _, part := range strings.Split(ccHeader, ",") {
405 part = strings.Trim(part, " ")
406 if part == "" {
407 continue
408 }
409 if strings.ContainsRune(part, '=') {
410 keyval := strings.Split(part, "=")
411 cc[strings.Trim(keyval[0], " ")] = strings.Trim(keyval[1], ",")
412 } else {
413 cc[part] = ""
414 }
415 }
416 return cc
417 }
418
419
420 func CacheExpires(r *http.Response) time.Time {
421
422 var expires time.Time
423 now, err := time.Parse(time.RFC1123, r.Header.Get("date"))
424 if err != nil {
425 return time.Now()
426 }
427 respCacheControl := parseCacheControl(r.Header)
428
429 if maxAge, ok := respCacheControl["max-age"]; ok {
430 lifetime, err := time.ParseDuration(maxAge + "s")
431 if err != nil {
432 expires = now
433 }
434 expires = now.Add(lifetime)
435 } else {
436 expiresHeader := r.Header.Get("Expires")
437 if expiresHeader != "" {
438 expires, err = time.Parse(time.RFC1123, expiresHeader)
439 if err != nil {
440 expires = now
441 }
442 }
443 }
444 return expires
445 }
446
447 func strlen(s string) int {
448 return utf8.RuneCountInString(s)
449 }
450
451
452 type GenericSwaggerError struct {
453 body []byte
454 error string
455 model interface{}
456 }
457
458
459 func (e GenericSwaggerError) Error() string {
460 return e.error
461 }
462
463
464 func (e GenericSwaggerError) Body() []byte {
465 return e.body
466 }
467
468
469 func (e GenericSwaggerError) Model() interface{} {
470 return e.model
471 }
View as plain text