servicemanager/internal/discoverserviceapi/discoverserviceapi-client.gen.go

   1 // Package discoverserviceapi provides primitives to interact with the openapi HTTP API.
   2 //
   3 // Code generated by github.com/deepmap/oapi-codegen version v1.10.1 DO NOT EDIT.
   4 package discoverserviceapi
   5
   6 import (
   7         "context"
   8         "encoding/json"
   9         "fmt"
  10         "io/ioutil"
  11         "net/http"
  12         "net/url"
  13         "strings"
  14
  15         "github.com/deepmap/oapi-codegen/pkg/runtime"
  16 )
  17
  18 // RequestEditorFn  is the function signature for the RequestEditor callback function
  19 type RequestEditorFn func(ctx context.Context, req *http.Request) error
  20
  21 // Doer performs HTTP requests.
  22 //
  23 // The standard http.Client implements this interface.
  24 type HttpRequestDoer interface {
  25         Do(req *http.Request) (*http.Response, error)
  26 }
  27
  28 // Client which conforms to the OpenAPI3 specification for this service.
  29 type Client struct {
  30         // The endpoint of the server conforming to this interface, with scheme,
  31         // https://api.deepmap.com for example. This can contain a path relative
  32         // to the server, such as https://api.deepmap.com/dev-test, and all the
  33         // paths in the swagger spec will be appended to the server.
  34         Server string
  35
  36         // Doer for performing requests, typically a *http.Client with any
  37         // customized settings, such as certificate chains.
  38         Client HttpRequestDoer
  39
  40         // A list of callbacks for modifying requests which are generated before sending over
  41         // the network.
  42         RequestEditors []RequestEditorFn
  43 }
  44
  45 // ClientOption allows setting custom parameters during construction
  46 type ClientOption func(*Client) error
  47
  48 // Creates a new Client, with reasonable defaults
  49 func NewClient(server string, opts ...ClientOption) (*Client, error) {
  50         // create a client with sane default values
  51         client := Client{
  52                 Server: server,
  53         }
  54         // mutate client and add all optional params
  55         for _, o := range opts {
  56                 if err := o(&client); err != nil {
  57                         return nil, err
  58                 }
  59         }
  60         // ensure the server URL always has a trailing slash
  61         if !strings.HasSuffix(client.Server, "/") {
  62                 client.Server += "/"
  63         }
  64         // create httpClient, if not already present
  65         if client.Client == nil {
  66                 client.Client = &http.Client{}
  67         }
  68         return &client, nil
  69 }
  70
  71 // WithHTTPClient allows overriding the default Doer, which is
  72 // automatically created using http.Client. This is useful for tests.
  73 func WithHTTPClient(doer HttpRequestDoer) ClientOption {
  74         return func(c *Client) error {
  75                 c.Client = doer
  76                 return nil
  77         }
  78 }
  79
  80 // WithRequestEditorFn allows setting up a callback function, which will be
  81 // called right before sending the request. This can be used to mutate the request.
  82 func WithRequestEditorFn(fn RequestEditorFn) ClientOption {
  83         return func(c *Client) error {
  84                 c.RequestEditors = append(c.RequestEditors, fn)
  85                 return nil
  86         }
  87 }
  88
  89 // The interface specification for the client above.
  90 type ClientInterface interface {
  91         // GetAllServiceAPIs request
  92         GetAllServiceAPIs(ctx context.Context, params *GetAllServiceAPIsParams, reqEditors ...RequestEditorFn) (*http.Response, error)
  93 }
  94
  95 func (c *Client) GetAllServiceAPIs(ctx context.Context, params *GetAllServiceAPIsParams, reqEditors ...RequestEditorFn) (*http.Response, error) {
  96         req, err := NewGetAllServiceAPIsRequest(c.Server, params)
  97         if err != nil {
  98                 return nil, err
  99         }
 100         req = req.WithContext(ctx)
 101         if err := c.applyEditors(ctx, req, reqEditors); err != nil {
 102                 return nil, err
 103         }
 104         return c.Client.Do(req)
 105 }
 106
 107 // NewGetAllServiceAPIsRequest generates requests for GetAllServiceAPIs
 108 func NewGetAllServiceAPIsRequest(server string, params *GetAllServiceAPIsParams) (*http.Request, error) {
 109         var err error
 110
 111         serverURL, err := url.Parse(server)
 112         if err != nil {
 113                 return nil, err
 114         }
 115
 116         operationPath := fmt.Sprintf("/allServiceAPIs")
 117         if operationPath[0] == '/' {
 118                 operationPath = "." + operationPath
 119         }
 120
 121         queryURL, err := serverURL.Parse(operationPath)
 122         if err != nil {
 123                 return nil, err
 124         }
 125
 126         queryValues := queryURL.Query()
 127
 128         if queryFrag, err := runtime.StyleParamWithLocation("form", true, "api-invoker-id", runtime.ParamLocationQuery, params.ApiInvokerId); err != nil {
 129                 return nil, err
 130         } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 131                 return nil, err
 132         } else {
 133                 for k, v := range parsed {
 134                         for _, v2 := range v {
 135                                 queryValues.Add(k, v2)
 136                         }
 137                 }
 138         }
 139
 140         if params.ApiName != nil {
 141
 142                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "api-name", runtime.ParamLocationQuery, *params.ApiName); err != nil {
 143                         return nil, err
 144                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 145                         return nil, err
 146                 } else {
 147                         for k, v := range parsed {
 148                                 for _, v2 := range v {
 149                                         queryValues.Add(k, v2)
 150                                 }
 151                         }
 152                 }
 153
 154         }
 155
 156         if params.ApiVersion != nil {
 157
 158                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "api-version", runtime.ParamLocationQuery, *params.ApiVersion); err != nil {
 159                         return nil, err
 160                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 161                         return nil, err
 162                 } else {
 163                         for k, v := range parsed {
 164                                 for _, v2 := range v {
 165                                         queryValues.Add(k, v2)
 166                                 }
 167                         }
 168                 }
 169
 170         }
 171
 172         if params.CommType != nil {
 173
 174                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "comm-type", runtime.ParamLocationQuery, *params.CommType); err != nil {
 175                         return nil, err
 176                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 177                         return nil, err
 178                 } else {
 179                         for k, v := range parsed {
 180                                 for _, v2 := range v {
 181                                         queryValues.Add(k, v2)
 182                                 }
 183                         }
 184                 }
 185
 186         }
 187
 188         if params.Protocol != nil {
 189
 190                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "protocol", runtime.ParamLocationQuery, *params.Protocol); err != nil {
 191                         return nil, err
 192                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 193                         return nil, err
 194                 } else {
 195                         for k, v := range parsed {
 196                                 for _, v2 := range v {
 197                                         queryValues.Add(k, v2)
 198                                 }
 199                         }
 200                 }
 201
 202         }
 203
 204         if params.AefId != nil {
 205
 206                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "aef-id", runtime.ParamLocationQuery, *params.AefId); err != nil {
 207                         return nil, err
 208                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 209                         return nil, err
 210                 } else {
 211                         for k, v := range parsed {
 212                                 for _, v2 := range v {
 213                                         queryValues.Add(k, v2)
 214                                 }
 215                         }
 216                 }
 217
 218         }
 219
 220         if params.DataFormat != nil {
 221
 222                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "data-format", runtime.ParamLocationQuery, *params.DataFormat); err != nil {
 223                         return nil, err
 224                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 225                         return nil, err
 226                 } else {
 227                         for k, v := range parsed {
 228                                 for _, v2 := range v {
 229                                         queryValues.Add(k, v2)
 230                                 }
 231                         }
 232                 }
 233
 234         }
 235
 236         if params.ApiCat != nil {
 237
 238                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "api-cat", runtime.ParamLocationQuery, *params.ApiCat); err != nil {
 239                         return nil, err
 240                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 241                         return nil, err
 242                 } else {
 243                         for k, v := range parsed {
 244                                 for _, v2 := range v {
 245                                         queryValues.Add(k, v2)
 246                                 }
 247                         }
 248                 }
 249
 250         }
 251
 252         if params.PreferredAefLoc != nil {
 253
 254                 if queryParamBuf, err := json.Marshal(*params.PreferredAefLoc); err != nil {
 255                         return nil, err
 256                 } else {
 257                         queryValues.Add("preferred-aef-loc", string(queryParamBuf))
 258                 }
 259
 260         }
 261
 262         if params.SupportedFeatures != nil {
 263
 264                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "supported-features", runtime.ParamLocationQuery, *params.SupportedFeatures); err != nil {
 265                         return nil, err
 266                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 267                         return nil, err
 268                 } else {
 269                         for k, v := range parsed {
 270                                 for _, v2 := range v {
 271                                         queryValues.Add(k, v2)
 272                                 }
 273                         }
 274                 }
 275
 276         }
 277
 278         if params.ApiSupportedFeatures != nil {
 279
 280                 if queryFrag, err := runtime.StyleParamWithLocation("form", true, "api-supported-features", runtime.ParamLocationQuery, *params.ApiSupportedFeatures); err != nil {
 281                         return nil, err
 282                 } else if parsed, err := url.ParseQuery(queryFrag); err != nil {
 283                         return nil, err
 284                 } else {
 285                         for k, v := range parsed {
 286                                 for _, v2 := range v {
 287                                         queryValues.Add(k, v2)
 288                                 }
 289                         }
 290                 }
 291
 292         }
 293
 294         queryURL.RawQuery = queryValues.Encode()
 295
 296         req, err := http.NewRequest("GET", queryURL.String(), nil)
 297         if err != nil {
 298                 return nil, err
 299         }
 300
 301         return req, nil
 302 }
 303
 304 func (c *Client) applyEditors(ctx context.Context, req *http.Request, additionalEditors []RequestEditorFn) error {
 305         for _, r := range c.RequestEditors {
 306                 if err := r(ctx, req); err != nil {
 307                         return err
 308                 }
 309         }
 310         for _, r := range additionalEditors {
 311                 if err := r(ctx, req); err != nil {
 312                         return err
 313                 }
 314         }
 315         return nil
 316 }
 317
 318 // ClientWithResponses builds on ClientInterface to offer response payloads
 319 type ClientWithResponses struct {
 320         ClientInterface
 321 }
 322
 323 // NewClientWithResponses creates a new ClientWithResponses, which wraps
 324 // Client with return type handling
 325 func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
 326         client, err := NewClient(server, opts...)
 327         if err != nil {
 328                 return nil, err
 329         }
 330         return &ClientWithResponses{client}, nil
 331 }
 332
 333 // WithBaseURL overrides the baseURL.
 334 func WithBaseURL(baseURL string) ClientOption {
 335         return func(c *Client) error {
 336                 newBaseURL, err := url.Parse(baseURL)
 337                 if err != nil {
 338                         return err
 339                 }
 340                 c.Server = newBaseURL.String()
 341                 return nil
 342         }
 343 }
 344
 345 // ClientWithResponsesInterface is the interface specification for the client with responses above.
 346 type ClientWithResponsesInterface interface {
 347         // GetAllServiceAPIs request
 348         GetAllServiceAPIsWithResponse(ctx context.Context, params *GetAllServiceAPIsParams, reqEditors ...RequestEditorFn) (*GetAllServiceAPIsResponse, error)
 349 }
 350
 351 type GetAllServiceAPIsResponse struct {
 352         Body         []byte
 353         HTTPResponse *http.Response
 354         JSON200      *DiscoveredAPIs
 355 }
 356
 357 // Status returns HTTPResponse.Status
 358 func (r GetAllServiceAPIsResponse) Status() string {
 359         if r.HTTPResponse != nil {
 360                 return r.HTTPResponse.Status
 361         }
 362         return http.StatusText(0)
 363 }
 364
 365 // StatusCode returns HTTPResponse.StatusCode
 366 func (r GetAllServiceAPIsResponse) StatusCode() int {
 367         if r.HTTPResponse != nil {
 368                 return r.HTTPResponse.StatusCode
 369         }
 370         return 0
 371 }
 372
 373 // GetAllServiceAPIsWithResponse request returning *GetAllServiceAPIsResponse
 374 func (c *ClientWithResponses) GetAllServiceAPIsWithResponse(ctx context.Context, params *GetAllServiceAPIsParams, reqEditors ...RequestEditorFn) (*GetAllServiceAPIsResponse, error) {
 375         rsp, err := c.GetAllServiceAPIs(ctx, params, reqEditors...)
 376         if err != nil {
 377                 return nil, err
 378         }
 379         return ParseGetAllServiceAPIsResponse(rsp)
 380 }
 381
 382 // ParseGetAllServiceAPIsResponse parses an HTTP response from a GetAllServiceAPIsWithResponse call
 383 func ParseGetAllServiceAPIsResponse(rsp *http.Response) (*GetAllServiceAPIsResponse, error) {
 384         bodyBytes, err := ioutil.ReadAll(rsp.Body)
 385         defer func() { _ = rsp.Body.Close() }()
 386         if err != nil {
 387                 return nil, err
 388         }
 389
 390         response := &GetAllServiceAPIsResponse{
 391                 Body:         bodyBytes,
 392                 HTTPResponse: rsp,
 393         }
 394
 395         switch {
 396         case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
 397                 var dest DiscoveredAPIs
 398                 if err := json.Unmarshal(bodyBytes, &dest); err != nil {
 399                         return nil, err
 400                 }
 401                 response.JSON200 = &dest
 402
 403         }
 404
 405         return response, nil
 406 }