github.com/launchdarkly/api-client-go@v5.3.0+incompatible/api_feature_flags.go (about) 1 2 /* 3 * LaunchDarkly REST API 4 * 5 * Build custom integrations with the LaunchDarkly REST API 6 * 7 * API version: 5.3.0 8 * Contact: support@launchdarkly.com 9 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git) 10 */ 11 12 package ldapi 13 14 import ( 15 "context" 16 "io/ioutil" 17 "net/http" 18 "net/url" 19 "strings" 20 "fmt" 21 "github.com/antihax/optional" 22 ) 23 24 // Linger please 25 var ( 26 _ context.Context 27 ) 28 29 type FeatureFlagsApiService service 30 31 /* 32 FeatureFlagsApiService Copies the feature flag configuration from one environment to the same feature flag in another environment. 33 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 34 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 35 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 36 * @param featureFlagCopyBody Copy feature flag configurations between environments. 37 38 @return FeatureFlag 39 */ 40 func (a *FeatureFlagsApiService) CopyFeatureFlag(ctx context.Context, projectKey string, featureFlagKey string, featureFlagCopyBody FeatureFlagCopyBody) (FeatureFlag, *http.Response, error) { 41 var ( 42 localVarHttpMethod = strings.ToUpper("Post") 43 localVarPostBody interface{} 44 localVarFileName string 45 localVarFileBytes []byte 46 localVarReturnValue FeatureFlag 47 ) 48 49 // create path and map variables 50 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{featureFlagKey}/copy" 51 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 52 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 53 54 localVarHeaderParams := make(map[string]string) 55 localVarQueryParams := url.Values{} 56 localVarFormParams := url.Values{} 57 58 // to determine the Content-Type header 59 localVarHttpContentTypes := []string{"application/json"} 60 61 // set Content-Type header 62 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 63 if localVarHttpContentType != "" { 64 localVarHeaderParams["Content-Type"] = localVarHttpContentType 65 } 66 67 // to determine the Accept header 68 localVarHttpHeaderAccepts := []string{"application/json"} 69 70 // set Accept header 71 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 72 if localVarHttpHeaderAccept != "" { 73 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 74 } 75 // body params 76 localVarPostBody = &featureFlagCopyBody 77 if ctx != nil { 78 // API Key Authentication 79 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 80 var key string 81 if auth.Prefix != "" { 82 key = auth.Prefix + " " + auth.Key 83 } else { 84 key = auth.Key 85 } 86 localVarHeaderParams["Authorization"] = key 87 88 } 89 } 90 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 91 if err != nil { 92 return localVarReturnValue, nil, err 93 } 94 95 localVarHttpResponse, err := a.client.callAPI(r) 96 if err != nil || localVarHttpResponse == nil { 97 return localVarReturnValue, localVarHttpResponse, err 98 } 99 100 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 101 localVarHttpResponse.Body.Close() 102 if err != nil { 103 return localVarReturnValue, localVarHttpResponse, err 104 } 105 106 if localVarHttpResponse.StatusCode < 300 { 107 // If we succeed, return the data, otherwise pass on to decode error. 108 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 109 return localVarReturnValue, localVarHttpResponse, err 110 } 111 112 if localVarHttpResponse.StatusCode >= 300 { 113 newErr := GenericSwaggerError{ 114 body: localVarBody, 115 error: localVarHttpResponse.Status, 116 } 117 118 if localVarHttpResponse.StatusCode == 201 { 119 var v FeatureFlag 120 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 121 if err != nil { 122 newErr.error = err.Error() 123 return localVarReturnValue, localVarHttpResponse, newErr 124 } 125 newErr.model = v 126 return localVarReturnValue, localVarHttpResponse, newErr 127 } 128 129 return localVarReturnValue, localVarHttpResponse, newErr 130 } 131 132 return localVarReturnValue, localVarHttpResponse, nil 133 } 134 135 /* 136 FeatureFlagsApiService Delete an approval request for a feature flag config 137 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 138 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 139 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 140 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 141 * @param approvalRequestId The approval request ID 142 * @param optional nil or *FeatureFlagsApiDeleteApprovalRequestOpts - Optional Parameters: 143 * @param "ApprovalRequestConfigBody" (optional.Interface of ApprovalRequestConfigBody) - Create a new approval request 144 145 146 */ 147 148 type FeatureFlagsApiDeleteApprovalRequestOpts struct { 149 ApprovalRequestConfigBody optional.Interface 150 } 151 152 func (a *FeatureFlagsApiService) DeleteApprovalRequest(ctx context.Context, projectKey string, environmentKey string, featureFlagKey string, approvalRequestId string, localVarOptionals *FeatureFlagsApiDeleteApprovalRequestOpts) (*http.Response, error) { 153 var ( 154 localVarHttpMethod = strings.ToUpper("Delete") 155 localVarPostBody interface{} 156 localVarFileName string 157 localVarFileBytes []byte 158 159 ) 160 161 // create path and map variables 162 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}" 163 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 164 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 165 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 166 localVarPath = strings.Replace(localVarPath, "{"+"approvalRequestId"+"}", fmt.Sprintf("%v", approvalRequestId), -1) 167 168 localVarHeaderParams := make(map[string]string) 169 localVarQueryParams := url.Values{} 170 localVarFormParams := url.Values{} 171 172 // to determine the Content-Type header 173 localVarHttpContentTypes := []string{"application/json"} 174 175 // set Content-Type header 176 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 177 if localVarHttpContentType != "" { 178 localVarHeaderParams["Content-Type"] = localVarHttpContentType 179 } 180 181 // to determine the Accept header 182 localVarHttpHeaderAccepts := []string{"application/json"} 183 184 // set Accept header 185 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 186 if localVarHttpHeaderAccept != "" { 187 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 188 } 189 // body params 190 if localVarOptionals != nil && localVarOptionals.ApprovalRequestConfigBody.IsSet() { 191 192 localVarOptionalApprovalRequestConfigBody, localVarOptionalApprovalRequestConfigBodyok := localVarOptionals.ApprovalRequestConfigBody.Value().(ApprovalRequestConfigBody) 193 if !localVarOptionalApprovalRequestConfigBodyok { 194 return nil, reportError("approvalRequestConfigBody should be ApprovalRequestConfigBody") 195 } 196 localVarPostBody = &localVarOptionalApprovalRequestConfigBody 197 } 198 if ctx != nil { 199 // API Key Authentication 200 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 201 var key string 202 if auth.Prefix != "" { 203 key = auth.Prefix + " " + auth.Key 204 } else { 205 key = auth.Key 206 } 207 localVarHeaderParams["Authorization"] = key 208 209 } 210 } 211 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 212 if err != nil { 213 return nil, err 214 } 215 216 localVarHttpResponse, err := a.client.callAPI(r) 217 if err != nil || localVarHttpResponse == nil { 218 return localVarHttpResponse, err 219 } 220 221 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 222 localVarHttpResponse.Body.Close() 223 if err != nil { 224 return localVarHttpResponse, err 225 } 226 227 228 if localVarHttpResponse.StatusCode >= 300 { 229 newErr := GenericSwaggerError{ 230 body: localVarBody, 231 error: localVarHttpResponse.Status, 232 } 233 234 return localVarHttpResponse, newErr 235 } 236 237 return localVarHttpResponse, nil 238 } 239 240 /* 241 FeatureFlagsApiService Delete a feature flag in all environments. Be careful-- only delete feature flags that are no longer being used by your application. 242 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 243 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 244 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 245 246 247 */ 248 func (a *FeatureFlagsApiService) DeleteFeatureFlag(ctx context.Context, projectKey string, featureFlagKey string) (*http.Response, error) { 249 var ( 250 localVarHttpMethod = strings.ToUpper("Delete") 251 localVarPostBody interface{} 252 localVarFileName string 253 localVarFileBytes []byte 254 255 ) 256 257 // create path and map variables 258 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{featureFlagKey}" 259 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 260 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 261 262 localVarHeaderParams := make(map[string]string) 263 localVarQueryParams := url.Values{} 264 localVarFormParams := url.Values{} 265 266 // to determine the Content-Type header 267 localVarHttpContentTypes := []string{"application/json"} 268 269 // set Content-Type header 270 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 271 if localVarHttpContentType != "" { 272 localVarHeaderParams["Content-Type"] = localVarHttpContentType 273 } 274 275 // to determine the Accept header 276 localVarHttpHeaderAccepts := []string{"application/json"} 277 278 // set Accept header 279 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 280 if localVarHttpHeaderAccept != "" { 281 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 282 } 283 if ctx != nil { 284 // API Key Authentication 285 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 286 var key string 287 if auth.Prefix != "" { 288 key = auth.Prefix + " " + auth.Key 289 } else { 290 key = auth.Key 291 } 292 localVarHeaderParams["Authorization"] = key 293 294 } 295 } 296 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 297 if err != nil { 298 return nil, err 299 } 300 301 localVarHttpResponse, err := a.client.callAPI(r) 302 if err != nil || localVarHttpResponse == nil { 303 return localVarHttpResponse, err 304 } 305 306 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 307 localVarHttpResponse.Body.Close() 308 if err != nil { 309 return localVarHttpResponse, err 310 } 311 312 313 if localVarHttpResponse.StatusCode >= 300 { 314 newErr := GenericSwaggerError{ 315 body: localVarBody, 316 error: localVarHttpResponse.Status, 317 } 318 319 return localVarHttpResponse, newErr 320 } 321 322 return localVarHttpResponse, nil 323 } 324 325 /* 326 FeatureFlagsApiService Delete a scheduled change on a feature flag in an environment. 327 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 328 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 329 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 330 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 331 * @param scheduledChangeId The id of the scheduled change 332 333 334 */ 335 func (a *FeatureFlagsApiService) DeleteFlagConfigScheduledChanges(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string, scheduledChangeId string) (*http.Response, error) { 336 var ( 337 localVarHttpMethod = strings.ToUpper("Delete") 338 localVarPostBody interface{} 339 localVarFileName string 340 localVarFileBytes []byte 341 342 ) 343 344 // create path and map variables 345 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes/{scheduledChangeId}" 346 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 347 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 348 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 349 localVarPath = strings.Replace(localVarPath, "{"+"scheduledChangeId"+"}", fmt.Sprintf("%v", scheduledChangeId), -1) 350 351 localVarHeaderParams := make(map[string]string) 352 localVarQueryParams := url.Values{} 353 localVarFormParams := url.Values{} 354 355 // to determine the Content-Type header 356 localVarHttpContentTypes := []string{"application/json"} 357 358 // set Content-Type header 359 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 360 if localVarHttpContentType != "" { 361 localVarHeaderParams["Content-Type"] = localVarHttpContentType 362 } 363 364 // to determine the Accept header 365 localVarHttpHeaderAccepts := []string{"application/json"} 366 367 // set Accept header 368 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 369 if localVarHttpHeaderAccept != "" { 370 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 371 } 372 if ctx != nil { 373 // API Key Authentication 374 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 375 var key string 376 if auth.Prefix != "" { 377 key = auth.Prefix + " " + auth.Key 378 } else { 379 key = auth.Key 380 } 381 localVarHeaderParams["Authorization"] = key 382 383 } 384 } 385 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 386 if err != nil { 387 return nil, err 388 } 389 390 localVarHttpResponse, err := a.client.callAPI(r) 391 if err != nil || localVarHttpResponse == nil { 392 return localVarHttpResponse, err 393 } 394 395 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 396 localVarHttpResponse.Body.Close() 397 if err != nil { 398 return localVarHttpResponse, err 399 } 400 401 402 if localVarHttpResponse.StatusCode >= 300 { 403 newErr := GenericSwaggerError{ 404 body: localVarBody, 405 error: localVarHttpResponse.Status, 406 } 407 408 return localVarHttpResponse, newErr 409 } 410 411 return localVarHttpResponse, nil 412 } 413 414 /* 415 FeatureFlagsApiService Get dependent flags for the flag in the environment specified in path parameters 416 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 417 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 418 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 419 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 420 421 @return DependentFlagsByEnvironment 422 */ 423 func (a *FeatureFlagsApiService) FlagsProjectKeyEnvironmentKeyFeatureFlagKeyDependentFlagsGet(ctx context.Context, projectKey string, environmentKey string, featureFlagKey string) (DependentFlagsByEnvironment, *http.Response, error) { 424 var ( 425 localVarHttpMethod = strings.ToUpper("Get") 426 localVarPostBody interface{} 427 localVarFileName string 428 localVarFileBytes []byte 429 localVarReturnValue DependentFlagsByEnvironment 430 ) 431 432 // create path and map variables 433 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{environmentKey}/{featureFlagKey}/dependent-flags" 434 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 435 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 436 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 437 438 localVarHeaderParams := make(map[string]string) 439 localVarQueryParams := url.Values{} 440 localVarFormParams := url.Values{} 441 442 // to determine the Content-Type header 443 localVarHttpContentTypes := []string{"application/json"} 444 445 // set Content-Type header 446 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 447 if localVarHttpContentType != "" { 448 localVarHeaderParams["Content-Type"] = localVarHttpContentType 449 } 450 451 // to determine the Accept header 452 localVarHttpHeaderAccepts := []string{"application/json"} 453 454 // set Accept header 455 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 456 if localVarHttpHeaderAccept != "" { 457 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 458 } 459 if ctx != nil { 460 // API Key Authentication 461 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 462 var key string 463 if auth.Prefix != "" { 464 key = auth.Prefix + " " + auth.Key 465 } else { 466 key = auth.Key 467 } 468 localVarHeaderParams["Authorization"] = key 469 470 } 471 } 472 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 473 if err != nil { 474 return localVarReturnValue, nil, err 475 } 476 477 localVarHttpResponse, err := a.client.callAPI(r) 478 if err != nil || localVarHttpResponse == nil { 479 return localVarReturnValue, localVarHttpResponse, err 480 } 481 482 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 483 localVarHttpResponse.Body.Close() 484 if err != nil { 485 return localVarReturnValue, localVarHttpResponse, err 486 } 487 488 if localVarHttpResponse.StatusCode < 300 { 489 // If we succeed, return the data, otherwise pass on to decode error. 490 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 491 return localVarReturnValue, localVarHttpResponse, err 492 } 493 494 if localVarHttpResponse.StatusCode >= 300 { 495 newErr := GenericSwaggerError{ 496 body: localVarBody, 497 error: localVarHttpResponse.Status, 498 } 499 500 if localVarHttpResponse.StatusCode == 200 { 501 var v DependentFlagsByEnvironment 502 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 503 if err != nil { 504 newErr.error = err.Error() 505 return localVarReturnValue, localVarHttpResponse, newErr 506 } 507 newErr.model = v 508 return localVarReturnValue, localVarHttpResponse, newErr 509 } 510 511 if localVarHttpResponse.StatusCode == 403 { 512 var v UsageError 513 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 514 if err != nil { 515 newErr.error = err.Error() 516 return localVarReturnValue, localVarHttpResponse, newErr 517 } 518 newErr.model = v 519 return localVarReturnValue, localVarHttpResponse, newErr 520 } 521 522 return localVarReturnValue, localVarHttpResponse, newErr 523 } 524 525 return localVarReturnValue, localVarHttpResponse, nil 526 } 527 528 /* 529 FeatureFlagsApiService Get dependent flags across all environments for the flag specified in the path parameters 530 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 531 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 532 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 533 534 @return MultiEnvironmentDependentFlags 535 */ 536 func (a *FeatureFlagsApiService) FlagsProjectKeyFeatureFlagKeyDependentFlagsGet(ctx context.Context, projectKey string, featureFlagKey string) (MultiEnvironmentDependentFlags, *http.Response, error) { 537 var ( 538 localVarHttpMethod = strings.ToUpper("Get") 539 localVarPostBody interface{} 540 localVarFileName string 541 localVarFileBytes []byte 542 localVarReturnValue MultiEnvironmentDependentFlags 543 ) 544 545 // create path and map variables 546 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{featureFlagKey}/dependent-flags" 547 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 548 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 549 550 localVarHeaderParams := make(map[string]string) 551 localVarQueryParams := url.Values{} 552 localVarFormParams := url.Values{} 553 554 // to determine the Content-Type header 555 localVarHttpContentTypes := []string{"application/json"} 556 557 // set Content-Type header 558 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 559 if localVarHttpContentType != "" { 560 localVarHeaderParams["Content-Type"] = localVarHttpContentType 561 } 562 563 // to determine the Accept header 564 localVarHttpHeaderAccepts := []string{"application/json"} 565 566 // set Accept header 567 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 568 if localVarHttpHeaderAccept != "" { 569 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 570 } 571 if ctx != nil { 572 // API Key Authentication 573 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 574 var key string 575 if auth.Prefix != "" { 576 key = auth.Prefix + " " + auth.Key 577 } else { 578 key = auth.Key 579 } 580 localVarHeaderParams["Authorization"] = key 581 582 } 583 } 584 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 585 if err != nil { 586 return localVarReturnValue, nil, err 587 } 588 589 localVarHttpResponse, err := a.client.callAPI(r) 590 if err != nil || localVarHttpResponse == nil { 591 return localVarReturnValue, localVarHttpResponse, err 592 } 593 594 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 595 localVarHttpResponse.Body.Close() 596 if err != nil { 597 return localVarReturnValue, localVarHttpResponse, err 598 } 599 600 if localVarHttpResponse.StatusCode < 300 { 601 // If we succeed, return the data, otherwise pass on to decode error. 602 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 603 return localVarReturnValue, localVarHttpResponse, err 604 } 605 606 if localVarHttpResponse.StatusCode >= 300 { 607 newErr := GenericSwaggerError{ 608 body: localVarBody, 609 error: localVarHttpResponse.Status, 610 } 611 612 if localVarHttpResponse.StatusCode == 200 { 613 var v MultiEnvironmentDependentFlags 614 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 615 if err != nil { 616 newErr.error = err.Error() 617 return localVarReturnValue, localVarHttpResponse, newErr 618 } 619 newErr.model = v 620 return localVarReturnValue, localVarHttpResponse, newErr 621 } 622 623 if localVarHttpResponse.StatusCode == 403 { 624 var v UsageError 625 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 626 if err != nil { 627 newErr.error = err.Error() 628 return localVarReturnValue, localVarHttpResponse, newErr 629 } 630 newErr.model = v 631 return localVarReturnValue, localVarHttpResponse, newErr 632 } 633 634 return localVarReturnValue, localVarHttpResponse, newErr 635 } 636 637 return localVarReturnValue, localVarHttpResponse, nil 638 } 639 640 /* 641 FeatureFlagsApiService Get a single approval request for a feature flag config 642 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 643 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 644 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 645 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 646 * @param approvalRequestId The approval request ID 647 648 @return ApprovalRequests 649 */ 650 func (a *FeatureFlagsApiService) GetApprovalRequest(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string, approvalRequestId string) (ApprovalRequests, *http.Response, error) { 651 var ( 652 localVarHttpMethod = strings.ToUpper("Get") 653 localVarPostBody interface{} 654 localVarFileName string 655 localVarFileBytes []byte 656 localVarReturnValue ApprovalRequests 657 ) 658 659 // create path and map variables 660 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}" 661 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 662 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 663 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 664 localVarPath = strings.Replace(localVarPath, "{"+"approvalRequestId"+"}", fmt.Sprintf("%v", approvalRequestId), -1) 665 666 localVarHeaderParams := make(map[string]string) 667 localVarQueryParams := url.Values{} 668 localVarFormParams := url.Values{} 669 670 // to determine the Content-Type header 671 localVarHttpContentTypes := []string{"application/json"} 672 673 // set Content-Type header 674 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 675 if localVarHttpContentType != "" { 676 localVarHeaderParams["Content-Type"] = localVarHttpContentType 677 } 678 679 // to determine the Accept header 680 localVarHttpHeaderAccepts := []string{"application/json"} 681 682 // set Accept header 683 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 684 if localVarHttpHeaderAccept != "" { 685 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 686 } 687 if ctx != nil { 688 // API Key Authentication 689 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 690 var key string 691 if auth.Prefix != "" { 692 key = auth.Prefix + " " + auth.Key 693 } else { 694 key = auth.Key 695 } 696 localVarHeaderParams["Authorization"] = key 697 698 } 699 } 700 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 701 if err != nil { 702 return localVarReturnValue, nil, err 703 } 704 705 localVarHttpResponse, err := a.client.callAPI(r) 706 if err != nil || localVarHttpResponse == nil { 707 return localVarReturnValue, localVarHttpResponse, err 708 } 709 710 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 711 localVarHttpResponse.Body.Close() 712 if err != nil { 713 return localVarReturnValue, localVarHttpResponse, err 714 } 715 716 if localVarHttpResponse.StatusCode < 300 { 717 // If we succeed, return the data, otherwise pass on to decode error. 718 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 719 return localVarReturnValue, localVarHttpResponse, err 720 } 721 722 if localVarHttpResponse.StatusCode >= 300 { 723 newErr := GenericSwaggerError{ 724 body: localVarBody, 725 error: localVarHttpResponse.Status, 726 } 727 728 if localVarHttpResponse.StatusCode == 200 { 729 var v ApprovalRequests 730 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 731 if err != nil { 732 newErr.error = err.Error() 733 return localVarReturnValue, localVarHttpResponse, newErr 734 } 735 newErr.model = v 736 return localVarReturnValue, localVarHttpResponse, newErr 737 } 738 739 return localVarReturnValue, localVarHttpResponse, newErr 740 } 741 742 return localVarReturnValue, localVarHttpResponse, nil 743 } 744 745 /* 746 FeatureFlagsApiService Get all approval requests for a feature flag config 747 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 748 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 749 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 750 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 751 752 @return ApprovalRequests 753 */ 754 func (a *FeatureFlagsApiService) GetApprovalRequests(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string) (ApprovalRequests, *http.Response, error) { 755 var ( 756 localVarHttpMethod = strings.ToUpper("Get") 757 localVarPostBody interface{} 758 localVarFileName string 759 localVarFileBytes []byte 760 localVarReturnValue ApprovalRequests 761 ) 762 763 // create path and map variables 764 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests" 765 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 766 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 767 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 768 769 localVarHeaderParams := make(map[string]string) 770 localVarQueryParams := url.Values{} 771 localVarFormParams := url.Values{} 772 773 // to determine the Content-Type header 774 localVarHttpContentTypes := []string{"application/json"} 775 776 // set Content-Type header 777 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 778 if localVarHttpContentType != "" { 779 localVarHeaderParams["Content-Type"] = localVarHttpContentType 780 } 781 782 // to determine the Accept header 783 localVarHttpHeaderAccepts := []string{"application/json"} 784 785 // set Accept header 786 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 787 if localVarHttpHeaderAccept != "" { 788 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 789 } 790 if ctx != nil { 791 // API Key Authentication 792 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 793 var key string 794 if auth.Prefix != "" { 795 key = auth.Prefix + " " + auth.Key 796 } else { 797 key = auth.Key 798 } 799 localVarHeaderParams["Authorization"] = key 800 801 } 802 } 803 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 804 if err != nil { 805 return localVarReturnValue, nil, err 806 } 807 808 localVarHttpResponse, err := a.client.callAPI(r) 809 if err != nil || localVarHttpResponse == nil { 810 return localVarReturnValue, localVarHttpResponse, err 811 } 812 813 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 814 localVarHttpResponse.Body.Close() 815 if err != nil { 816 return localVarReturnValue, localVarHttpResponse, err 817 } 818 819 if localVarHttpResponse.StatusCode < 300 { 820 // If we succeed, return the data, otherwise pass on to decode error. 821 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 822 return localVarReturnValue, localVarHttpResponse, err 823 } 824 825 if localVarHttpResponse.StatusCode >= 300 { 826 newErr := GenericSwaggerError{ 827 body: localVarBody, 828 error: localVarHttpResponse.Status, 829 } 830 831 if localVarHttpResponse.StatusCode == 200 { 832 var v ApprovalRequests 833 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 834 if err != nil { 835 newErr.error = err.Error() 836 return localVarReturnValue, localVarHttpResponse, newErr 837 } 838 newErr.model = v 839 return localVarReturnValue, localVarHttpResponse, newErr 840 } 841 842 return localVarReturnValue, localVarHttpResponse, newErr 843 } 844 845 return localVarReturnValue, localVarHttpResponse, nil 846 } 847 848 /* 849 FeatureFlagsApiService Get expiring user targets for feature flag 850 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 851 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 852 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 853 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 854 855 @return UserTargetingExpirationForFlags 856 */ 857 func (a *FeatureFlagsApiService) GetExpiringUserTargets(ctx context.Context, projectKey string, environmentKey string, featureFlagKey string) (UserTargetingExpirationForFlags, *http.Response, error) { 858 var ( 859 localVarHttpMethod = strings.ToUpper("Get") 860 localVarPostBody interface{} 861 localVarFileName string 862 localVarFileBytes []byte 863 localVarReturnValue UserTargetingExpirationForFlags 864 ) 865 866 // create path and map variables 867 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{featureFlagKey}/expiring-user-targets/{environmentKey}" 868 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 869 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 870 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 871 872 localVarHeaderParams := make(map[string]string) 873 localVarQueryParams := url.Values{} 874 localVarFormParams := url.Values{} 875 876 // to determine the Content-Type header 877 localVarHttpContentTypes := []string{"application/json"} 878 879 // set Content-Type header 880 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 881 if localVarHttpContentType != "" { 882 localVarHeaderParams["Content-Type"] = localVarHttpContentType 883 } 884 885 // to determine the Accept header 886 localVarHttpHeaderAccepts := []string{"application/json"} 887 888 // set Accept header 889 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 890 if localVarHttpHeaderAccept != "" { 891 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 892 } 893 if ctx != nil { 894 // API Key Authentication 895 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 896 var key string 897 if auth.Prefix != "" { 898 key = auth.Prefix + " " + auth.Key 899 } else { 900 key = auth.Key 901 } 902 localVarHeaderParams["Authorization"] = key 903 904 } 905 } 906 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 907 if err != nil { 908 return localVarReturnValue, nil, err 909 } 910 911 localVarHttpResponse, err := a.client.callAPI(r) 912 if err != nil || localVarHttpResponse == nil { 913 return localVarReturnValue, localVarHttpResponse, err 914 } 915 916 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 917 localVarHttpResponse.Body.Close() 918 if err != nil { 919 return localVarReturnValue, localVarHttpResponse, err 920 } 921 922 if localVarHttpResponse.StatusCode < 300 { 923 // If we succeed, return the data, otherwise pass on to decode error. 924 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 925 return localVarReturnValue, localVarHttpResponse, err 926 } 927 928 if localVarHttpResponse.StatusCode >= 300 { 929 newErr := GenericSwaggerError{ 930 body: localVarBody, 931 error: localVarHttpResponse.Status, 932 } 933 934 if localVarHttpResponse.StatusCode == 200 { 935 var v UserTargetingExpirationForFlags 936 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 937 if err != nil { 938 newErr.error = err.Error() 939 return localVarReturnValue, localVarHttpResponse, newErr 940 } 941 newErr.model = v 942 return localVarReturnValue, localVarHttpResponse, newErr 943 } 944 945 return localVarReturnValue, localVarHttpResponse, newErr 946 } 947 948 return localVarReturnValue, localVarHttpResponse, nil 949 } 950 951 /* 952 FeatureFlagsApiService Get a single feature flag by key. 953 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 954 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 955 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 956 * @param optional nil or *FeatureFlagsApiGetFeatureFlagOpts - Optional Parameters: 957 * @param "Env" (optional.Interface of []string) - By default, each feature will include configurations for each environment. You can filter environments with the env query parameter. For example, setting env=[\"production\"] will restrict the returned configurations to just your production environment. 958 959 @return FeatureFlag 960 */ 961 962 type FeatureFlagsApiGetFeatureFlagOpts struct { 963 Env optional.Interface 964 } 965 966 func (a *FeatureFlagsApiService) GetFeatureFlag(ctx context.Context, projectKey string, featureFlagKey string, localVarOptionals *FeatureFlagsApiGetFeatureFlagOpts) (FeatureFlag, *http.Response, error) { 967 var ( 968 localVarHttpMethod = strings.ToUpper("Get") 969 localVarPostBody interface{} 970 localVarFileName string 971 localVarFileBytes []byte 972 localVarReturnValue FeatureFlag 973 ) 974 975 // create path and map variables 976 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{featureFlagKey}" 977 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 978 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 979 980 localVarHeaderParams := make(map[string]string) 981 localVarQueryParams := url.Values{} 982 localVarFormParams := url.Values{} 983 984 if localVarOptionals != nil && localVarOptionals.Env.IsSet() { 985 localVarQueryParams.Add("env", parameterToString(localVarOptionals.Env.Value(), "multi")) 986 } 987 // to determine the Content-Type header 988 localVarHttpContentTypes := []string{"application/json"} 989 990 // set Content-Type header 991 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 992 if localVarHttpContentType != "" { 993 localVarHeaderParams["Content-Type"] = localVarHttpContentType 994 } 995 996 // to determine the Accept header 997 localVarHttpHeaderAccepts := []string{"application/json"} 998 999 // set Accept header 1000 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1001 if localVarHttpHeaderAccept != "" { 1002 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1003 } 1004 if ctx != nil { 1005 // API Key Authentication 1006 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1007 var key string 1008 if auth.Prefix != "" { 1009 key = auth.Prefix + " " + auth.Key 1010 } else { 1011 key = auth.Key 1012 } 1013 localVarHeaderParams["Authorization"] = key 1014 1015 } 1016 } 1017 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1018 if err != nil { 1019 return localVarReturnValue, nil, err 1020 } 1021 1022 localVarHttpResponse, err := a.client.callAPI(r) 1023 if err != nil || localVarHttpResponse == nil { 1024 return localVarReturnValue, localVarHttpResponse, err 1025 } 1026 1027 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1028 localVarHttpResponse.Body.Close() 1029 if err != nil { 1030 return localVarReturnValue, localVarHttpResponse, err 1031 } 1032 1033 if localVarHttpResponse.StatusCode < 300 { 1034 // If we succeed, return the data, otherwise pass on to decode error. 1035 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1036 return localVarReturnValue, localVarHttpResponse, err 1037 } 1038 1039 if localVarHttpResponse.StatusCode >= 300 { 1040 newErr := GenericSwaggerError{ 1041 body: localVarBody, 1042 error: localVarHttpResponse.Status, 1043 } 1044 1045 if localVarHttpResponse.StatusCode == 200 { 1046 var v FeatureFlag 1047 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1048 if err != nil { 1049 newErr.error = err.Error() 1050 return localVarReturnValue, localVarHttpResponse, newErr 1051 } 1052 newErr.model = v 1053 return localVarReturnValue, localVarHttpResponse, newErr 1054 } 1055 1056 return localVarReturnValue, localVarHttpResponse, newErr 1057 } 1058 1059 return localVarReturnValue, localVarHttpResponse, nil 1060 } 1061 1062 /* 1063 FeatureFlagsApiService Get the status for a particular feature flag. 1064 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1065 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1066 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 1067 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 1068 1069 @return FeatureFlagStatus 1070 */ 1071 func (a *FeatureFlagsApiService) GetFeatureFlagStatus(ctx context.Context, projectKey string, environmentKey string, featureFlagKey string) (FeatureFlagStatus, *http.Response, error) { 1072 var ( 1073 localVarHttpMethod = strings.ToUpper("Get") 1074 localVarPostBody interface{} 1075 localVarFileName string 1076 localVarFileBytes []byte 1077 localVarReturnValue FeatureFlagStatus 1078 ) 1079 1080 // create path and map variables 1081 localVarPath := a.client.cfg.BasePath + "/flag-statuses/{projectKey}/{environmentKey}/{featureFlagKey}" 1082 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1083 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 1084 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 1085 1086 localVarHeaderParams := make(map[string]string) 1087 localVarQueryParams := url.Values{} 1088 localVarFormParams := url.Values{} 1089 1090 // to determine the Content-Type header 1091 localVarHttpContentTypes := []string{"application/json"} 1092 1093 // set Content-Type header 1094 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1095 if localVarHttpContentType != "" { 1096 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1097 } 1098 1099 // to determine the Accept header 1100 localVarHttpHeaderAccepts := []string{"application/json"} 1101 1102 // set Accept header 1103 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1104 if localVarHttpHeaderAccept != "" { 1105 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1106 } 1107 if ctx != nil { 1108 // API Key Authentication 1109 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1110 var key string 1111 if auth.Prefix != "" { 1112 key = auth.Prefix + " " + auth.Key 1113 } else { 1114 key = auth.Key 1115 } 1116 localVarHeaderParams["Authorization"] = key 1117 1118 } 1119 } 1120 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1121 if err != nil { 1122 return localVarReturnValue, nil, err 1123 } 1124 1125 localVarHttpResponse, err := a.client.callAPI(r) 1126 if err != nil || localVarHttpResponse == nil { 1127 return localVarReturnValue, localVarHttpResponse, err 1128 } 1129 1130 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1131 localVarHttpResponse.Body.Close() 1132 if err != nil { 1133 return localVarReturnValue, localVarHttpResponse, err 1134 } 1135 1136 if localVarHttpResponse.StatusCode < 300 { 1137 // If we succeed, return the data, otherwise pass on to decode error. 1138 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1139 return localVarReturnValue, localVarHttpResponse, err 1140 } 1141 1142 if localVarHttpResponse.StatusCode >= 300 { 1143 newErr := GenericSwaggerError{ 1144 body: localVarBody, 1145 error: localVarHttpResponse.Status, 1146 } 1147 1148 if localVarHttpResponse.StatusCode == 200 { 1149 var v FeatureFlagStatus 1150 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1151 if err != nil { 1152 newErr.error = err.Error() 1153 return localVarReturnValue, localVarHttpResponse, newErr 1154 } 1155 newErr.model = v 1156 return localVarReturnValue, localVarHttpResponse, newErr 1157 } 1158 1159 return localVarReturnValue, localVarHttpResponse, newErr 1160 } 1161 1162 return localVarReturnValue, localVarHttpResponse, nil 1163 } 1164 1165 /* 1166 FeatureFlagsApiService Get the status for a particular feature flag across environments 1167 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1168 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1169 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 1170 1171 @return FeatureFlagStatusAcrossEnvironments 1172 */ 1173 func (a *FeatureFlagsApiService) GetFeatureFlagStatusAcrossEnvironments(ctx context.Context, projectKey string, featureFlagKey string) (FeatureFlagStatusAcrossEnvironments, *http.Response, error) { 1174 var ( 1175 localVarHttpMethod = strings.ToUpper("Get") 1176 localVarPostBody interface{} 1177 localVarFileName string 1178 localVarFileBytes []byte 1179 localVarReturnValue FeatureFlagStatusAcrossEnvironments 1180 ) 1181 1182 // create path and map variables 1183 localVarPath := a.client.cfg.BasePath + "/flag-status/{projectKey}/{featureFlagKey}" 1184 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1185 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 1186 1187 localVarHeaderParams := make(map[string]string) 1188 localVarQueryParams := url.Values{} 1189 localVarFormParams := url.Values{} 1190 1191 // to determine the Content-Type header 1192 localVarHttpContentTypes := []string{"application/json"} 1193 1194 // set Content-Type header 1195 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1196 if localVarHttpContentType != "" { 1197 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1198 } 1199 1200 // to determine the Accept header 1201 localVarHttpHeaderAccepts := []string{"application/json"} 1202 1203 // set Accept header 1204 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1205 if localVarHttpHeaderAccept != "" { 1206 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1207 } 1208 if ctx != nil { 1209 // API Key Authentication 1210 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1211 var key string 1212 if auth.Prefix != "" { 1213 key = auth.Prefix + " " + auth.Key 1214 } else { 1215 key = auth.Key 1216 } 1217 localVarHeaderParams["Authorization"] = key 1218 1219 } 1220 } 1221 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1222 if err != nil { 1223 return localVarReturnValue, nil, err 1224 } 1225 1226 localVarHttpResponse, err := a.client.callAPI(r) 1227 if err != nil || localVarHttpResponse == nil { 1228 return localVarReturnValue, localVarHttpResponse, err 1229 } 1230 1231 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1232 localVarHttpResponse.Body.Close() 1233 if err != nil { 1234 return localVarReturnValue, localVarHttpResponse, err 1235 } 1236 1237 if localVarHttpResponse.StatusCode < 300 { 1238 // If we succeed, return the data, otherwise pass on to decode error. 1239 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1240 return localVarReturnValue, localVarHttpResponse, err 1241 } 1242 1243 if localVarHttpResponse.StatusCode >= 300 { 1244 newErr := GenericSwaggerError{ 1245 body: localVarBody, 1246 error: localVarHttpResponse.Status, 1247 } 1248 1249 if localVarHttpResponse.StatusCode == 200 { 1250 var v FeatureFlagStatusAcrossEnvironments 1251 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1252 if err != nil { 1253 newErr.error = err.Error() 1254 return localVarReturnValue, localVarHttpResponse, newErr 1255 } 1256 newErr.model = v 1257 return localVarReturnValue, localVarHttpResponse, newErr 1258 } 1259 1260 if localVarHttpResponse.StatusCode == 403 { 1261 var v UsageError 1262 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1263 if err != nil { 1264 newErr.error = err.Error() 1265 return localVarReturnValue, localVarHttpResponse, newErr 1266 } 1267 newErr.model = v 1268 return localVarReturnValue, localVarHttpResponse, newErr 1269 } 1270 1271 return localVarReturnValue, localVarHttpResponse, newErr 1272 } 1273 1274 return localVarReturnValue, localVarHttpResponse, nil 1275 } 1276 1277 /* 1278 FeatureFlagsApiService Get a list of statuses for all feature flags. The status includes the last time the feature flag was requested, as well as the state of the flag. 1279 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1280 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1281 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 1282 1283 @return FeatureFlagStatuses 1284 */ 1285 func (a *FeatureFlagsApiService) GetFeatureFlagStatuses(ctx context.Context, projectKey string, environmentKey string) (FeatureFlagStatuses, *http.Response, error) { 1286 var ( 1287 localVarHttpMethod = strings.ToUpper("Get") 1288 localVarPostBody interface{} 1289 localVarFileName string 1290 localVarFileBytes []byte 1291 localVarReturnValue FeatureFlagStatuses 1292 ) 1293 1294 // create path and map variables 1295 localVarPath := a.client.cfg.BasePath + "/flag-statuses/{projectKey}/{environmentKey}" 1296 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1297 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 1298 1299 localVarHeaderParams := make(map[string]string) 1300 localVarQueryParams := url.Values{} 1301 localVarFormParams := url.Values{} 1302 1303 // to determine the Content-Type header 1304 localVarHttpContentTypes := []string{"application/json"} 1305 1306 // set Content-Type header 1307 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1308 if localVarHttpContentType != "" { 1309 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1310 } 1311 1312 // to determine the Accept header 1313 localVarHttpHeaderAccepts := []string{"application/json"} 1314 1315 // set Accept header 1316 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1317 if localVarHttpHeaderAccept != "" { 1318 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1319 } 1320 if ctx != nil { 1321 // API Key Authentication 1322 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1323 var key string 1324 if auth.Prefix != "" { 1325 key = auth.Prefix + " " + auth.Key 1326 } else { 1327 key = auth.Key 1328 } 1329 localVarHeaderParams["Authorization"] = key 1330 1331 } 1332 } 1333 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1334 if err != nil { 1335 return localVarReturnValue, nil, err 1336 } 1337 1338 localVarHttpResponse, err := a.client.callAPI(r) 1339 if err != nil || localVarHttpResponse == nil { 1340 return localVarReturnValue, localVarHttpResponse, err 1341 } 1342 1343 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1344 localVarHttpResponse.Body.Close() 1345 if err != nil { 1346 return localVarReturnValue, localVarHttpResponse, err 1347 } 1348 1349 if localVarHttpResponse.StatusCode < 300 { 1350 // If we succeed, return the data, otherwise pass on to decode error. 1351 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1352 return localVarReturnValue, localVarHttpResponse, err 1353 } 1354 1355 if localVarHttpResponse.StatusCode >= 300 { 1356 newErr := GenericSwaggerError{ 1357 body: localVarBody, 1358 error: localVarHttpResponse.Status, 1359 } 1360 1361 if localVarHttpResponse.StatusCode == 200 { 1362 var v FeatureFlagStatuses 1363 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1364 if err != nil { 1365 newErr.error = err.Error() 1366 return localVarReturnValue, localVarHttpResponse, newErr 1367 } 1368 newErr.model = v 1369 return localVarReturnValue, localVarHttpResponse, newErr 1370 } 1371 1372 return localVarReturnValue, localVarHttpResponse, newErr 1373 } 1374 1375 return localVarReturnValue, localVarHttpResponse, nil 1376 } 1377 1378 /* 1379 FeatureFlagsApiService Get a list of all features in the given project. 1380 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1381 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1382 * @param optional nil or *FeatureFlagsApiGetFeatureFlagsOpts - Optional Parameters: 1383 * @param "Env" (optional.Interface of []string) - By default, each feature will include configurations for each environment. You can filter environments with the env query parameter. For example, setting env=[\"production\"] will restrict the returned configurations to just your production environment. 1384 * @param "Summary" (optional.Bool) - By default in api version >= 1, flags will _not_ include their list of prerequisites, targets or rules. Set summary=0 to include these fields for each flag returned. 1385 * @param "Archived" (optional.Bool) - When set to 1, only archived flags will be included in the list of flags returned. By default, archived flags are not included in the list of flags. 1386 * @param "Limit" (optional.Float32) - The number of objects to return. Defaults to -1, which returns everything. 1387 * @param "Offset" (optional.Float32) - Where to start in the list. This is for use with pagination. For example, an offset of 10 would skip the first 10 items and then return the next limit items. 1388 * @param "Filter" (optional.String) - A comma-separated list of filters. Each filter is of the form field:value. 1389 * @param "Sort" (optional.String) - A comma-separated list of fields to sort by. A field prefixed by a - will be sorted in descending order. 1390 * @param "Tag" (optional.String) - Filter by tag. A tag can be used to group flags across projects. 1391 1392 @return FeatureFlags 1393 */ 1394 1395 type FeatureFlagsApiGetFeatureFlagsOpts struct { 1396 Env optional.Interface 1397 Summary optional.Bool 1398 Archived optional.Bool 1399 Limit optional.Float32 1400 Offset optional.Float32 1401 Filter optional.String 1402 Sort optional.String 1403 Tag optional.String 1404 } 1405 1406 func (a *FeatureFlagsApiService) GetFeatureFlags(ctx context.Context, projectKey string, localVarOptionals *FeatureFlagsApiGetFeatureFlagsOpts) (FeatureFlags, *http.Response, error) { 1407 var ( 1408 localVarHttpMethod = strings.ToUpper("Get") 1409 localVarPostBody interface{} 1410 localVarFileName string 1411 localVarFileBytes []byte 1412 localVarReturnValue FeatureFlags 1413 ) 1414 1415 // create path and map variables 1416 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}" 1417 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1418 1419 localVarHeaderParams := make(map[string]string) 1420 localVarQueryParams := url.Values{} 1421 localVarFormParams := url.Values{} 1422 1423 if localVarOptionals != nil && localVarOptionals.Env.IsSet() { 1424 localVarQueryParams.Add("env", parameterToString(localVarOptionals.Env.Value(), "multi")) 1425 } 1426 if localVarOptionals != nil && localVarOptionals.Summary.IsSet() { 1427 localVarQueryParams.Add("summary", parameterToString(localVarOptionals.Summary.Value(), "")) 1428 } 1429 if localVarOptionals != nil && localVarOptionals.Archived.IsSet() { 1430 localVarQueryParams.Add("archived", parameterToString(localVarOptionals.Archived.Value(), "")) 1431 } 1432 if localVarOptionals != nil && localVarOptionals.Limit.IsSet() { 1433 localVarQueryParams.Add("limit", parameterToString(localVarOptionals.Limit.Value(), "")) 1434 } 1435 if localVarOptionals != nil && localVarOptionals.Offset.IsSet() { 1436 localVarQueryParams.Add("offset", parameterToString(localVarOptionals.Offset.Value(), "")) 1437 } 1438 if localVarOptionals != nil && localVarOptionals.Filter.IsSet() { 1439 localVarQueryParams.Add("filter", parameterToString(localVarOptionals.Filter.Value(), "")) 1440 } 1441 if localVarOptionals != nil && localVarOptionals.Sort.IsSet() { 1442 localVarQueryParams.Add("sort", parameterToString(localVarOptionals.Sort.Value(), "")) 1443 } 1444 if localVarOptionals != nil && localVarOptionals.Tag.IsSet() { 1445 localVarQueryParams.Add("tag", parameterToString(localVarOptionals.Tag.Value(), "")) 1446 } 1447 // to determine the Content-Type header 1448 localVarHttpContentTypes := []string{"application/json"} 1449 1450 // set Content-Type header 1451 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1452 if localVarHttpContentType != "" { 1453 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1454 } 1455 1456 // to determine the Accept header 1457 localVarHttpHeaderAccepts := []string{"application/json"} 1458 1459 // set Accept header 1460 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1461 if localVarHttpHeaderAccept != "" { 1462 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1463 } 1464 if ctx != nil { 1465 // API Key Authentication 1466 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1467 var key string 1468 if auth.Prefix != "" { 1469 key = auth.Prefix + " " + auth.Key 1470 } else { 1471 key = auth.Key 1472 } 1473 localVarHeaderParams["Authorization"] = key 1474 1475 } 1476 } 1477 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1478 if err != nil { 1479 return localVarReturnValue, nil, err 1480 } 1481 1482 localVarHttpResponse, err := a.client.callAPI(r) 1483 if err != nil || localVarHttpResponse == nil { 1484 return localVarReturnValue, localVarHttpResponse, err 1485 } 1486 1487 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1488 localVarHttpResponse.Body.Close() 1489 if err != nil { 1490 return localVarReturnValue, localVarHttpResponse, err 1491 } 1492 1493 if localVarHttpResponse.StatusCode < 300 { 1494 // If we succeed, return the data, otherwise pass on to decode error. 1495 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1496 return localVarReturnValue, localVarHttpResponse, err 1497 } 1498 1499 if localVarHttpResponse.StatusCode >= 300 { 1500 newErr := GenericSwaggerError{ 1501 body: localVarBody, 1502 error: localVarHttpResponse.Status, 1503 } 1504 1505 if localVarHttpResponse.StatusCode == 200 { 1506 var v FeatureFlags 1507 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1508 if err != nil { 1509 newErr.error = err.Error() 1510 return localVarReturnValue, localVarHttpResponse, newErr 1511 } 1512 newErr.model = v 1513 return localVarReturnValue, localVarHttpResponse, newErr 1514 } 1515 1516 return localVarReturnValue, localVarHttpResponse, newErr 1517 } 1518 1519 return localVarReturnValue, localVarHttpResponse, nil 1520 } 1521 1522 /* 1523 FeatureFlagsApiService Get a scheduled change on a feature flag by id. 1524 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1525 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1526 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 1527 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 1528 * @param scheduledChangeId The id of the scheduled change 1529 1530 @return FeatureFlagScheduledChange 1531 */ 1532 func (a *FeatureFlagsApiService) GetFlagConfigScheduledChange(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string, scheduledChangeId string) (FeatureFlagScheduledChange, *http.Response, error) { 1533 var ( 1534 localVarHttpMethod = strings.ToUpper("Get") 1535 localVarPostBody interface{} 1536 localVarFileName string 1537 localVarFileBytes []byte 1538 localVarReturnValue FeatureFlagScheduledChange 1539 ) 1540 1541 // create path and map variables 1542 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes/{scheduledChangeId}" 1543 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1544 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 1545 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 1546 localVarPath = strings.Replace(localVarPath, "{"+"scheduledChangeId"+"}", fmt.Sprintf("%v", scheduledChangeId), -1) 1547 1548 localVarHeaderParams := make(map[string]string) 1549 localVarQueryParams := url.Values{} 1550 localVarFormParams := url.Values{} 1551 1552 // to determine the Content-Type header 1553 localVarHttpContentTypes := []string{"application/json"} 1554 1555 // set Content-Type header 1556 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1557 if localVarHttpContentType != "" { 1558 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1559 } 1560 1561 // to determine the Accept header 1562 localVarHttpHeaderAccepts := []string{"application/json"} 1563 1564 // set Accept header 1565 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1566 if localVarHttpHeaderAccept != "" { 1567 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1568 } 1569 if ctx != nil { 1570 // API Key Authentication 1571 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1572 var key string 1573 if auth.Prefix != "" { 1574 key = auth.Prefix + " " + auth.Key 1575 } else { 1576 key = auth.Key 1577 } 1578 localVarHeaderParams["Authorization"] = key 1579 1580 } 1581 } 1582 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1583 if err != nil { 1584 return localVarReturnValue, nil, err 1585 } 1586 1587 localVarHttpResponse, err := a.client.callAPI(r) 1588 if err != nil || localVarHttpResponse == nil { 1589 return localVarReturnValue, localVarHttpResponse, err 1590 } 1591 1592 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1593 localVarHttpResponse.Body.Close() 1594 if err != nil { 1595 return localVarReturnValue, localVarHttpResponse, err 1596 } 1597 1598 if localVarHttpResponse.StatusCode < 300 { 1599 // If we succeed, return the data, otherwise pass on to decode error. 1600 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1601 return localVarReturnValue, localVarHttpResponse, err 1602 } 1603 1604 if localVarHttpResponse.StatusCode >= 300 { 1605 newErr := GenericSwaggerError{ 1606 body: localVarBody, 1607 error: localVarHttpResponse.Status, 1608 } 1609 1610 if localVarHttpResponse.StatusCode == 200 { 1611 var v FeatureFlagScheduledChange 1612 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1613 if err != nil { 1614 newErr.error = err.Error() 1615 return localVarReturnValue, localVarHttpResponse, newErr 1616 } 1617 newErr.model = v 1618 return localVarReturnValue, localVarHttpResponse, newErr 1619 } 1620 1621 return localVarReturnValue, localVarHttpResponse, newErr 1622 } 1623 1624 return localVarReturnValue, localVarHttpResponse, nil 1625 } 1626 1627 /* 1628 FeatureFlagsApiService Get all scheduled workflows for a feature flag by key. 1629 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1630 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1631 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 1632 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 1633 1634 @return FeatureFlagScheduledChanges 1635 */ 1636 func (a *FeatureFlagsApiService) GetFlagConfigScheduledChanges(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string) (FeatureFlagScheduledChanges, *http.Response, error) { 1637 var ( 1638 localVarHttpMethod = strings.ToUpper("Get") 1639 localVarPostBody interface{} 1640 localVarFileName string 1641 localVarFileBytes []byte 1642 localVarReturnValue FeatureFlagScheduledChanges 1643 ) 1644 1645 // create path and map variables 1646 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes" 1647 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1648 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 1649 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 1650 1651 localVarHeaderParams := make(map[string]string) 1652 localVarQueryParams := url.Values{} 1653 localVarFormParams := url.Values{} 1654 1655 // to determine the Content-Type header 1656 localVarHttpContentTypes := []string{"application/json"} 1657 1658 // set Content-Type header 1659 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1660 if localVarHttpContentType != "" { 1661 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1662 } 1663 1664 // to determine the Accept header 1665 localVarHttpHeaderAccepts := []string{"application/json"} 1666 1667 // set Accept header 1668 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1669 if localVarHttpHeaderAccept != "" { 1670 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1671 } 1672 if ctx != nil { 1673 // API Key Authentication 1674 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1675 var key string 1676 if auth.Prefix != "" { 1677 key = auth.Prefix + " " + auth.Key 1678 } else { 1679 key = auth.Key 1680 } 1681 localVarHeaderParams["Authorization"] = key 1682 1683 } 1684 } 1685 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1686 if err != nil { 1687 return localVarReturnValue, nil, err 1688 } 1689 1690 localVarHttpResponse, err := a.client.callAPI(r) 1691 if err != nil || localVarHttpResponse == nil { 1692 return localVarReturnValue, localVarHttpResponse, err 1693 } 1694 1695 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1696 localVarHttpResponse.Body.Close() 1697 if err != nil { 1698 return localVarReturnValue, localVarHttpResponse, err 1699 } 1700 1701 if localVarHttpResponse.StatusCode < 300 { 1702 // If we succeed, return the data, otherwise pass on to decode error. 1703 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1704 return localVarReturnValue, localVarHttpResponse, err 1705 } 1706 1707 if localVarHttpResponse.StatusCode >= 300 { 1708 newErr := GenericSwaggerError{ 1709 body: localVarBody, 1710 error: localVarHttpResponse.Status, 1711 } 1712 1713 if localVarHttpResponse.StatusCode == 200 { 1714 var v FeatureFlagScheduledChanges 1715 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1716 if err != nil { 1717 newErr.error = err.Error() 1718 return localVarReturnValue, localVarHttpResponse, newErr 1719 } 1720 newErr.model = v 1721 return localVarReturnValue, localVarHttpResponse, newErr 1722 } 1723 1724 return localVarReturnValue, localVarHttpResponse, newErr 1725 } 1726 1727 return localVarReturnValue, localVarHttpResponse, nil 1728 } 1729 1730 /* 1731 FeatureFlagsApiService Lists conflicts between the given instructions and any existing scheduled changes for the feature flag. The actual HTTP verb should be REPORT, not POST. 1732 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1733 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1734 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 1735 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 1736 * @param flagConfigScheduledChangesConflictsBody Used to determine if a semantic patch will result in conflicts with scheduled changes on a feature flag. 1737 1738 @return FeatureFlagScheduledChangesConflicts 1739 */ 1740 func (a *FeatureFlagsApiService) GetFlagConfigScheduledChangesConflicts(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string, flagConfigScheduledChangesConflictsBody FlagConfigScheduledChangesConflictsBody) (FeatureFlagScheduledChangesConflicts, *http.Response, error) { 1741 var ( 1742 localVarHttpMethod = strings.ToUpper("Post") 1743 localVarPostBody interface{} 1744 localVarFileName string 1745 localVarFileBytes []byte 1746 localVarReturnValue FeatureFlagScheduledChangesConflicts 1747 ) 1748 1749 // create path and map variables 1750 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes-conflicts" 1751 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1752 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 1753 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 1754 1755 localVarHeaderParams := make(map[string]string) 1756 localVarQueryParams := url.Values{} 1757 localVarFormParams := url.Values{} 1758 1759 // to determine the Content-Type header 1760 localVarHttpContentTypes := []string{"application/json"} 1761 1762 // set Content-Type header 1763 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1764 if localVarHttpContentType != "" { 1765 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1766 } 1767 1768 // to determine the Accept header 1769 localVarHttpHeaderAccepts := []string{"application/json"} 1770 1771 // set Accept header 1772 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1773 if localVarHttpHeaderAccept != "" { 1774 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1775 } 1776 // body params 1777 localVarPostBody = &flagConfigScheduledChangesConflictsBody 1778 if ctx != nil { 1779 // API Key Authentication 1780 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1781 var key string 1782 if auth.Prefix != "" { 1783 key = auth.Prefix + " " + auth.Key 1784 } else { 1785 key = auth.Key 1786 } 1787 localVarHeaderParams["Authorization"] = key 1788 1789 } 1790 } 1791 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1792 if err != nil { 1793 return localVarReturnValue, nil, err 1794 } 1795 1796 localVarHttpResponse, err := a.client.callAPI(r) 1797 if err != nil || localVarHttpResponse == nil { 1798 return localVarReturnValue, localVarHttpResponse, err 1799 } 1800 1801 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1802 localVarHttpResponse.Body.Close() 1803 if err != nil { 1804 return localVarReturnValue, localVarHttpResponse, err 1805 } 1806 1807 if localVarHttpResponse.StatusCode < 300 { 1808 // If we succeed, return the data, otherwise pass on to decode error. 1809 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1810 return localVarReturnValue, localVarHttpResponse, err 1811 } 1812 1813 if localVarHttpResponse.StatusCode >= 300 { 1814 newErr := GenericSwaggerError{ 1815 body: localVarBody, 1816 error: localVarHttpResponse.Status, 1817 } 1818 1819 if localVarHttpResponse.StatusCode == 200 { 1820 var v FeatureFlagScheduledChangesConflicts 1821 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1822 if err != nil { 1823 newErr.error = err.Error() 1824 return localVarReturnValue, localVarHttpResponse, newErr 1825 } 1826 newErr.model = v 1827 return localVarReturnValue, localVarHttpResponse, newErr 1828 } 1829 1830 return localVarReturnValue, localVarHttpResponse, newErr 1831 } 1832 1833 return localVarReturnValue, localVarHttpResponse, nil 1834 } 1835 1836 /* 1837 FeatureFlagsApiService Update, add, or delete expiring user targets on feature flag 1838 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1839 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1840 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 1841 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 1842 * @param semanticPatchWithComment Requires a Semantic Patch representation of the desired changes to the resource. 'https://apidocs.launchdarkly.com/reference#updates-via-semantic-patches'. The addition of comments is also supported. 1843 1844 @return UserTargetingExpirationForFlags 1845 */ 1846 func (a *FeatureFlagsApiService) PatchExpiringUserTargets(ctx context.Context, projectKey string, environmentKey string, featureFlagKey string, semanticPatchWithComment interface{}) (UserTargetingExpirationForFlags, *http.Response, error) { 1847 var ( 1848 localVarHttpMethod = strings.ToUpper("Patch") 1849 localVarPostBody interface{} 1850 localVarFileName string 1851 localVarFileBytes []byte 1852 localVarReturnValue UserTargetingExpirationForFlags 1853 ) 1854 1855 // create path and map variables 1856 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{featureFlagKey}/expiring-user-targets/{environmentKey}" 1857 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1858 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 1859 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 1860 1861 localVarHeaderParams := make(map[string]string) 1862 localVarQueryParams := url.Values{} 1863 localVarFormParams := url.Values{} 1864 1865 // to determine the Content-Type header 1866 localVarHttpContentTypes := []string{"application/json"} 1867 1868 // set Content-Type header 1869 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1870 if localVarHttpContentType != "" { 1871 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1872 } 1873 1874 // to determine the Accept header 1875 localVarHttpHeaderAccepts := []string{"application/json"} 1876 1877 // set Accept header 1878 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1879 if localVarHttpHeaderAccept != "" { 1880 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1881 } 1882 // body params 1883 localVarPostBody = &semanticPatchWithComment 1884 if ctx != nil { 1885 // API Key Authentication 1886 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1887 var key string 1888 if auth.Prefix != "" { 1889 key = auth.Prefix + " " + auth.Key 1890 } else { 1891 key = auth.Key 1892 } 1893 localVarHeaderParams["Authorization"] = key 1894 1895 } 1896 } 1897 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1898 if err != nil { 1899 return localVarReturnValue, nil, err 1900 } 1901 1902 localVarHttpResponse, err := a.client.callAPI(r) 1903 if err != nil || localVarHttpResponse == nil { 1904 return localVarReturnValue, localVarHttpResponse, err 1905 } 1906 1907 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 1908 localVarHttpResponse.Body.Close() 1909 if err != nil { 1910 return localVarReturnValue, localVarHttpResponse, err 1911 } 1912 1913 if localVarHttpResponse.StatusCode < 300 { 1914 // If we succeed, return the data, otherwise pass on to decode error. 1915 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1916 return localVarReturnValue, localVarHttpResponse, err 1917 } 1918 1919 if localVarHttpResponse.StatusCode >= 300 { 1920 newErr := GenericSwaggerError{ 1921 body: localVarBody, 1922 error: localVarHttpResponse.Status, 1923 } 1924 1925 if localVarHttpResponse.StatusCode == 200 { 1926 var v UserTargetingExpirationForFlags 1927 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 1928 if err != nil { 1929 newErr.error = err.Error() 1930 return localVarReturnValue, localVarHttpResponse, newErr 1931 } 1932 newErr.model = v 1933 return localVarReturnValue, localVarHttpResponse, newErr 1934 } 1935 1936 return localVarReturnValue, localVarHttpResponse, newErr 1937 } 1938 1939 return localVarReturnValue, localVarHttpResponse, nil 1940 } 1941 1942 /* 1943 FeatureFlagsApiService Perform a partial update to a feature. 1944 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 1945 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 1946 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 1947 * @param patchComment Requires a JSON Patch representation of the desired changes to the project, and an optional comment. 'http://jsonpatch.com/' Feature flag patches also support JSON Merge Patch format. 'https://tools.ietf.org/html/rfc7386' The addition of comments is also supported. 1948 1949 @return FeatureFlag 1950 */ 1951 func (a *FeatureFlagsApiService) PatchFeatureFlag(ctx context.Context, projectKey string, featureFlagKey string, patchComment PatchComment) (FeatureFlag, *http.Response, error) { 1952 var ( 1953 localVarHttpMethod = strings.ToUpper("Patch") 1954 localVarPostBody interface{} 1955 localVarFileName string 1956 localVarFileBytes []byte 1957 localVarReturnValue FeatureFlag 1958 ) 1959 1960 // create path and map variables 1961 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}/{featureFlagKey}" 1962 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 1963 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 1964 1965 localVarHeaderParams := make(map[string]string) 1966 localVarQueryParams := url.Values{} 1967 localVarFormParams := url.Values{} 1968 1969 // to determine the Content-Type header 1970 localVarHttpContentTypes := []string{"application/json"} 1971 1972 // set Content-Type header 1973 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1974 if localVarHttpContentType != "" { 1975 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1976 } 1977 1978 // to determine the Accept header 1979 localVarHttpHeaderAccepts := []string{"application/json"} 1980 1981 // set Accept header 1982 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1983 if localVarHttpHeaderAccept != "" { 1984 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1985 } 1986 // body params 1987 localVarPostBody = &patchComment 1988 if ctx != nil { 1989 // API Key Authentication 1990 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 1991 var key string 1992 if auth.Prefix != "" { 1993 key = auth.Prefix + " " + auth.Key 1994 } else { 1995 key = auth.Key 1996 } 1997 localVarHeaderParams["Authorization"] = key 1998 1999 } 2000 } 2001 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2002 if err != nil { 2003 return localVarReturnValue, nil, err 2004 } 2005 2006 localVarHttpResponse, err := a.client.callAPI(r) 2007 if err != nil || localVarHttpResponse == nil { 2008 return localVarReturnValue, localVarHttpResponse, err 2009 } 2010 2011 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 2012 localVarHttpResponse.Body.Close() 2013 if err != nil { 2014 return localVarReturnValue, localVarHttpResponse, err 2015 } 2016 2017 if localVarHttpResponse.StatusCode < 300 { 2018 // If we succeed, return the data, otherwise pass on to decode error. 2019 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2020 return localVarReturnValue, localVarHttpResponse, err 2021 } 2022 2023 if localVarHttpResponse.StatusCode >= 300 { 2024 newErr := GenericSwaggerError{ 2025 body: localVarBody, 2026 error: localVarHttpResponse.Status, 2027 } 2028 2029 if localVarHttpResponse.StatusCode == 200 { 2030 var v FeatureFlag 2031 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2032 if err != nil { 2033 newErr.error = err.Error() 2034 return localVarReturnValue, localVarHttpResponse, newErr 2035 } 2036 newErr.model = v 2037 return localVarReturnValue, localVarHttpResponse, newErr 2038 } 2039 2040 return localVarReturnValue, localVarHttpResponse, newErr 2041 } 2042 2043 return localVarReturnValue, localVarHttpResponse, nil 2044 } 2045 2046 /* 2047 FeatureFlagsApiService Updates an existing scheduled-change on a feature flag in an environment. 2048 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 2049 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 2050 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 2051 * @param flagConfigScheduledChangesPatchBody Update scheduled changes on a feature flag. 2052 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 2053 * @param scheduledChangeId The id of the scheduled change 2054 2055 @return FeatureFlagScheduledChange 2056 */ 2057 func (a *FeatureFlagsApiService) PatchFlagConfigScheduledChange(ctx context.Context, projectKey string, featureFlagKey string, flagConfigScheduledChangesPatchBody FlagConfigScheduledChangesPatchBody, environmentKey string, scheduledChangeId string) (FeatureFlagScheduledChange, *http.Response, error) { 2058 var ( 2059 localVarHttpMethod = strings.ToUpper("Patch") 2060 localVarPostBody interface{} 2061 localVarFileName string 2062 localVarFileBytes []byte 2063 localVarReturnValue FeatureFlagScheduledChange 2064 ) 2065 2066 // create path and map variables 2067 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes/{scheduledChangeId}" 2068 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 2069 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 2070 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 2071 localVarPath = strings.Replace(localVarPath, "{"+"scheduledChangeId"+"}", fmt.Sprintf("%v", scheduledChangeId), -1) 2072 2073 localVarHeaderParams := make(map[string]string) 2074 localVarQueryParams := url.Values{} 2075 localVarFormParams := url.Values{} 2076 2077 // to determine the Content-Type header 2078 localVarHttpContentTypes := []string{"application/json"} 2079 2080 // set Content-Type header 2081 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2082 if localVarHttpContentType != "" { 2083 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2084 } 2085 2086 // to determine the Accept header 2087 localVarHttpHeaderAccepts := []string{"application/json"} 2088 2089 // set Accept header 2090 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2091 if localVarHttpHeaderAccept != "" { 2092 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2093 } 2094 // body params 2095 localVarPostBody = &flagConfigScheduledChangesPatchBody 2096 if ctx != nil { 2097 // API Key Authentication 2098 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 2099 var key string 2100 if auth.Prefix != "" { 2101 key = auth.Prefix + " " + auth.Key 2102 } else { 2103 key = auth.Key 2104 } 2105 localVarHeaderParams["Authorization"] = key 2106 2107 } 2108 } 2109 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2110 if err != nil { 2111 return localVarReturnValue, nil, err 2112 } 2113 2114 localVarHttpResponse, err := a.client.callAPI(r) 2115 if err != nil || localVarHttpResponse == nil { 2116 return localVarReturnValue, localVarHttpResponse, err 2117 } 2118 2119 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 2120 localVarHttpResponse.Body.Close() 2121 if err != nil { 2122 return localVarReturnValue, localVarHttpResponse, err 2123 } 2124 2125 if localVarHttpResponse.StatusCode < 300 { 2126 // If we succeed, return the data, otherwise pass on to decode error. 2127 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2128 return localVarReturnValue, localVarHttpResponse, err 2129 } 2130 2131 if localVarHttpResponse.StatusCode >= 300 { 2132 newErr := GenericSwaggerError{ 2133 body: localVarBody, 2134 error: localVarHttpResponse.Status, 2135 } 2136 2137 if localVarHttpResponse.StatusCode == 201 { 2138 var v FeatureFlagScheduledChange 2139 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2140 if err != nil { 2141 newErr.error = err.Error() 2142 return localVarReturnValue, localVarHttpResponse, newErr 2143 } 2144 newErr.model = v 2145 return localVarReturnValue, localVarHttpResponse, newErr 2146 } 2147 2148 return localVarReturnValue, localVarHttpResponse, newErr 2149 } 2150 2151 return localVarReturnValue, localVarHttpResponse, nil 2152 } 2153 2154 /* 2155 FeatureFlagsApiService Apply approval request for a feature flag config 2156 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 2157 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 2158 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 2159 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 2160 * @param approvalRequestId The approval request ID 2161 * @param approvalRequestApplyConfigBody Apply an approval request 2162 2163 @return ApprovalRequests 2164 */ 2165 func (a *FeatureFlagsApiService) PostApplyApprovalRequest(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string, approvalRequestId string, approvalRequestApplyConfigBody ApprovalRequestApplyConfigBody) (ApprovalRequests, *http.Response, error) { 2166 var ( 2167 localVarHttpMethod = strings.ToUpper("Post") 2168 localVarPostBody interface{} 2169 localVarFileName string 2170 localVarFileBytes []byte 2171 localVarReturnValue ApprovalRequests 2172 ) 2173 2174 // create path and map variables 2175 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}/apply" 2176 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 2177 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 2178 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 2179 localVarPath = strings.Replace(localVarPath, "{"+"approvalRequestId"+"}", fmt.Sprintf("%v", approvalRequestId), -1) 2180 2181 localVarHeaderParams := make(map[string]string) 2182 localVarQueryParams := url.Values{} 2183 localVarFormParams := url.Values{} 2184 2185 // to determine the Content-Type header 2186 localVarHttpContentTypes := []string{"application/json"} 2187 2188 // set Content-Type header 2189 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2190 if localVarHttpContentType != "" { 2191 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2192 } 2193 2194 // to determine the Accept header 2195 localVarHttpHeaderAccepts := []string{"application/json"} 2196 2197 // set Accept header 2198 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2199 if localVarHttpHeaderAccept != "" { 2200 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2201 } 2202 // body params 2203 localVarPostBody = &approvalRequestApplyConfigBody 2204 if ctx != nil { 2205 // API Key Authentication 2206 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 2207 var key string 2208 if auth.Prefix != "" { 2209 key = auth.Prefix + " " + auth.Key 2210 } else { 2211 key = auth.Key 2212 } 2213 localVarHeaderParams["Authorization"] = key 2214 2215 } 2216 } 2217 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2218 if err != nil { 2219 return localVarReturnValue, nil, err 2220 } 2221 2222 localVarHttpResponse, err := a.client.callAPI(r) 2223 if err != nil || localVarHttpResponse == nil { 2224 return localVarReturnValue, localVarHttpResponse, err 2225 } 2226 2227 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 2228 localVarHttpResponse.Body.Close() 2229 if err != nil { 2230 return localVarReturnValue, localVarHttpResponse, err 2231 } 2232 2233 if localVarHttpResponse.StatusCode < 300 { 2234 // If we succeed, return the data, otherwise pass on to decode error. 2235 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2236 return localVarReturnValue, localVarHttpResponse, err 2237 } 2238 2239 if localVarHttpResponse.StatusCode >= 300 { 2240 newErr := GenericSwaggerError{ 2241 body: localVarBody, 2242 error: localVarHttpResponse.Status, 2243 } 2244 2245 if localVarHttpResponse.StatusCode == 200 { 2246 var v ApprovalRequests 2247 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2248 if err != nil { 2249 newErr.error = err.Error() 2250 return localVarReturnValue, localVarHttpResponse, newErr 2251 } 2252 newErr.model = v 2253 return localVarReturnValue, localVarHttpResponse, newErr 2254 } 2255 2256 return localVarReturnValue, localVarHttpResponse, newErr 2257 } 2258 2259 return localVarReturnValue, localVarHttpResponse, nil 2260 } 2261 2262 /* 2263 FeatureFlagsApiService Create an approval request for a feature flag config 2264 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 2265 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 2266 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 2267 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 2268 * @param approvalRequestId The approval request ID 2269 * @param optional nil or *FeatureFlagsApiPostApprovalRequestOpts - Optional Parameters: 2270 * @param "ApprovalRequestConfigBody" (optional.Interface of ApprovalRequestConfigBody) - Create a new approval request 2271 2272 @return ApprovalRequest 2273 */ 2274 2275 type FeatureFlagsApiPostApprovalRequestOpts struct { 2276 ApprovalRequestConfigBody optional.Interface 2277 } 2278 2279 func (a *FeatureFlagsApiService) PostApprovalRequest(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string, approvalRequestId string, localVarOptionals *FeatureFlagsApiPostApprovalRequestOpts) (ApprovalRequest, *http.Response, error) { 2280 var ( 2281 localVarHttpMethod = strings.ToUpper("Post") 2282 localVarPostBody interface{} 2283 localVarFileName string 2284 localVarFileBytes []byte 2285 localVarReturnValue ApprovalRequest 2286 ) 2287 2288 // create path and map variables 2289 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}" 2290 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 2291 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 2292 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 2293 localVarPath = strings.Replace(localVarPath, "{"+"approvalRequestId"+"}", fmt.Sprintf("%v", approvalRequestId), -1) 2294 2295 localVarHeaderParams := make(map[string]string) 2296 localVarQueryParams := url.Values{} 2297 localVarFormParams := url.Values{} 2298 2299 // to determine the Content-Type header 2300 localVarHttpContentTypes := []string{"application/json"} 2301 2302 // set Content-Type header 2303 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2304 if localVarHttpContentType != "" { 2305 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2306 } 2307 2308 // to determine the Accept header 2309 localVarHttpHeaderAccepts := []string{"application/json"} 2310 2311 // set Accept header 2312 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2313 if localVarHttpHeaderAccept != "" { 2314 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2315 } 2316 // body params 2317 if localVarOptionals != nil && localVarOptionals.ApprovalRequestConfigBody.IsSet() { 2318 2319 localVarOptionalApprovalRequestConfigBody, localVarOptionalApprovalRequestConfigBodyok := localVarOptionals.ApprovalRequestConfigBody.Value().(ApprovalRequestConfigBody) 2320 if !localVarOptionalApprovalRequestConfigBodyok { 2321 return localVarReturnValue, nil, reportError("approvalRequestConfigBody should be ApprovalRequestConfigBody") 2322 } 2323 localVarPostBody = &localVarOptionalApprovalRequestConfigBody 2324 } 2325 if ctx != nil { 2326 // API Key Authentication 2327 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 2328 var key string 2329 if auth.Prefix != "" { 2330 key = auth.Prefix + " " + auth.Key 2331 } else { 2332 key = auth.Key 2333 } 2334 localVarHeaderParams["Authorization"] = key 2335 2336 } 2337 } 2338 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2339 if err != nil { 2340 return localVarReturnValue, nil, err 2341 } 2342 2343 localVarHttpResponse, err := a.client.callAPI(r) 2344 if err != nil || localVarHttpResponse == nil { 2345 return localVarReturnValue, localVarHttpResponse, err 2346 } 2347 2348 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 2349 localVarHttpResponse.Body.Close() 2350 if err != nil { 2351 return localVarReturnValue, localVarHttpResponse, err 2352 } 2353 2354 if localVarHttpResponse.StatusCode < 300 { 2355 // If we succeed, return the data, otherwise pass on to decode error. 2356 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2357 return localVarReturnValue, localVarHttpResponse, err 2358 } 2359 2360 if localVarHttpResponse.StatusCode >= 300 { 2361 newErr := GenericSwaggerError{ 2362 body: localVarBody, 2363 error: localVarHttpResponse.Status, 2364 } 2365 2366 if localVarHttpResponse.StatusCode == 200 { 2367 var v ApprovalRequest 2368 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2369 if err != nil { 2370 newErr.error = err.Error() 2371 return localVarReturnValue, localVarHttpResponse, newErr 2372 } 2373 newErr.model = v 2374 return localVarReturnValue, localVarHttpResponse, newErr 2375 } 2376 2377 return localVarReturnValue, localVarHttpResponse, newErr 2378 } 2379 2380 return localVarReturnValue, localVarHttpResponse, nil 2381 } 2382 2383 /* 2384 FeatureFlagsApiService Creates a new feature flag. 2385 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 2386 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 2387 * @param featureFlagBody Create a new feature flag. 2388 * @param optional nil or *FeatureFlagsApiPostFeatureFlagOpts - Optional Parameters: 2389 * @param "Clone" (optional.String) - The key of the feature flag to be cloned. The key identifies the flag in your code. For example, setting clone=flagKey will copy the full targeting configuration for all environments (including on/off state) from the original flag to the new flag. 2390 2391 @return FeatureFlag 2392 */ 2393 2394 type FeatureFlagsApiPostFeatureFlagOpts struct { 2395 Clone optional.String 2396 } 2397 2398 func (a *FeatureFlagsApiService) PostFeatureFlag(ctx context.Context, projectKey string, featureFlagBody FeatureFlagBody, localVarOptionals *FeatureFlagsApiPostFeatureFlagOpts) (FeatureFlag, *http.Response, error) { 2399 var ( 2400 localVarHttpMethod = strings.ToUpper("Post") 2401 localVarPostBody interface{} 2402 localVarFileName string 2403 localVarFileBytes []byte 2404 localVarReturnValue FeatureFlag 2405 ) 2406 2407 // create path and map variables 2408 localVarPath := a.client.cfg.BasePath + "/flags/{projectKey}" 2409 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 2410 2411 localVarHeaderParams := make(map[string]string) 2412 localVarQueryParams := url.Values{} 2413 localVarFormParams := url.Values{} 2414 2415 if localVarOptionals != nil && localVarOptionals.Clone.IsSet() { 2416 localVarQueryParams.Add("clone", parameterToString(localVarOptionals.Clone.Value(), "")) 2417 } 2418 // to determine the Content-Type header 2419 localVarHttpContentTypes := []string{"application/json"} 2420 2421 // set Content-Type header 2422 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2423 if localVarHttpContentType != "" { 2424 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2425 } 2426 2427 // to determine the Accept header 2428 localVarHttpHeaderAccepts := []string{"application/json"} 2429 2430 // set Accept header 2431 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2432 if localVarHttpHeaderAccept != "" { 2433 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2434 } 2435 // body params 2436 localVarPostBody = &featureFlagBody 2437 if ctx != nil { 2438 // API Key Authentication 2439 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 2440 var key string 2441 if auth.Prefix != "" { 2442 key = auth.Prefix + " " + auth.Key 2443 } else { 2444 key = auth.Key 2445 } 2446 localVarHeaderParams["Authorization"] = key 2447 2448 } 2449 } 2450 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2451 if err != nil { 2452 return localVarReturnValue, nil, err 2453 } 2454 2455 localVarHttpResponse, err := a.client.callAPI(r) 2456 if err != nil || localVarHttpResponse == nil { 2457 return localVarReturnValue, localVarHttpResponse, err 2458 } 2459 2460 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 2461 localVarHttpResponse.Body.Close() 2462 if err != nil { 2463 return localVarReturnValue, localVarHttpResponse, err 2464 } 2465 2466 if localVarHttpResponse.StatusCode < 300 { 2467 // If we succeed, return the data, otherwise pass on to decode error. 2468 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2469 return localVarReturnValue, localVarHttpResponse, err 2470 } 2471 2472 if localVarHttpResponse.StatusCode >= 300 { 2473 newErr := GenericSwaggerError{ 2474 body: localVarBody, 2475 error: localVarHttpResponse.Status, 2476 } 2477 2478 if localVarHttpResponse.StatusCode == 201 { 2479 var v FeatureFlag 2480 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2481 if err != nil { 2482 newErr.error = err.Error() 2483 return localVarReturnValue, localVarHttpResponse, newErr 2484 } 2485 newErr.model = v 2486 return localVarReturnValue, localVarHttpResponse, newErr 2487 } 2488 2489 return localVarReturnValue, localVarHttpResponse, newErr 2490 } 2491 2492 return localVarReturnValue, localVarHttpResponse, nil 2493 } 2494 2495 /* 2496 FeatureFlagsApiService Creates a new scheduled change for a feature flag. 2497 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 2498 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 2499 * @param flagConfigScheduledChangesPostBody Create scheduled changes on a feature flag. 2500 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 2501 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 2502 2503 @return FeatureFlagScheduledChange 2504 */ 2505 func (a *FeatureFlagsApiService) PostFlagConfigScheduledChanges(ctx context.Context, projectKey string, flagConfigScheduledChangesPostBody FlagConfigScheduledChangesPostBody, featureFlagKey string, environmentKey string) (FeatureFlagScheduledChange, *http.Response, error) { 2506 var ( 2507 localVarHttpMethod = strings.ToUpper("Post") 2508 localVarPostBody interface{} 2509 localVarFileName string 2510 localVarFileBytes []byte 2511 localVarReturnValue FeatureFlagScheduledChange 2512 ) 2513 2514 // create path and map variables 2515 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/scheduled-changes" 2516 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 2517 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 2518 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 2519 2520 localVarHeaderParams := make(map[string]string) 2521 localVarQueryParams := url.Values{} 2522 localVarFormParams := url.Values{} 2523 2524 // to determine the Content-Type header 2525 localVarHttpContentTypes := []string{"application/json"} 2526 2527 // set Content-Type header 2528 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2529 if localVarHttpContentType != "" { 2530 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2531 } 2532 2533 // to determine the Accept header 2534 localVarHttpHeaderAccepts := []string{"application/json"} 2535 2536 // set Accept header 2537 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2538 if localVarHttpHeaderAccept != "" { 2539 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2540 } 2541 // body params 2542 localVarPostBody = &flagConfigScheduledChangesPostBody 2543 if ctx != nil { 2544 // API Key Authentication 2545 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 2546 var key string 2547 if auth.Prefix != "" { 2548 key = auth.Prefix + " " + auth.Key 2549 } else { 2550 key = auth.Key 2551 } 2552 localVarHeaderParams["Authorization"] = key 2553 2554 } 2555 } 2556 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2557 if err != nil { 2558 return localVarReturnValue, nil, err 2559 } 2560 2561 localVarHttpResponse, err := a.client.callAPI(r) 2562 if err != nil || localVarHttpResponse == nil { 2563 return localVarReturnValue, localVarHttpResponse, err 2564 } 2565 2566 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 2567 localVarHttpResponse.Body.Close() 2568 if err != nil { 2569 return localVarReturnValue, localVarHttpResponse, err 2570 } 2571 2572 if localVarHttpResponse.StatusCode < 300 { 2573 // If we succeed, return the data, otherwise pass on to decode error. 2574 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2575 return localVarReturnValue, localVarHttpResponse, err 2576 } 2577 2578 if localVarHttpResponse.StatusCode >= 300 { 2579 newErr := GenericSwaggerError{ 2580 body: localVarBody, 2581 error: localVarHttpResponse.Status, 2582 } 2583 2584 if localVarHttpResponse.StatusCode == 201 { 2585 var v FeatureFlagScheduledChange 2586 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2587 if err != nil { 2588 newErr.error = err.Error() 2589 return localVarReturnValue, localVarHttpResponse, newErr 2590 } 2591 newErr.model = v 2592 return localVarReturnValue, localVarHttpResponse, newErr 2593 } 2594 2595 return localVarReturnValue, localVarHttpResponse, newErr 2596 } 2597 2598 return localVarReturnValue, localVarHttpResponse, nil 2599 } 2600 2601 /* 2602 FeatureFlagsApiService Review approval request for a feature flag config 2603 * @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). 2604 * @param projectKey The project key, used to tie the flags together under one project so they can be managed together. 2605 * @param featureFlagKey The feature flag's key. The key identifies the flag in your code. 2606 * @param environmentKey The environment key, used to tie together flag configuration and users under one environment so they can be managed together. 2607 * @param approvalRequestId The approval request ID 2608 * @param approvalRequestReviewConfigBody Review an approval request 2609 2610 @return ApprovalRequests 2611 */ 2612 func (a *FeatureFlagsApiService) PostReviewApprovalRequest(ctx context.Context, projectKey string, featureFlagKey string, environmentKey string, approvalRequestId string, approvalRequestReviewConfigBody ApprovalRequestReviewConfigBody) (ApprovalRequests, *http.Response, error) { 2613 var ( 2614 localVarHttpMethod = strings.ToUpper("Post") 2615 localVarPostBody interface{} 2616 localVarFileName string 2617 localVarFileBytes []byte 2618 localVarReturnValue ApprovalRequests 2619 ) 2620 2621 // create path and map variables 2622 localVarPath := a.client.cfg.BasePath + "/projects/{projectKey}/flags/{featureFlagKey}/environments/{environmentKey}/approval-requests/{approvalRequestId}/review" 2623 localVarPath = strings.Replace(localVarPath, "{"+"projectKey"+"}", fmt.Sprintf("%v", projectKey), -1) 2624 localVarPath = strings.Replace(localVarPath, "{"+"featureFlagKey"+"}", fmt.Sprintf("%v", featureFlagKey), -1) 2625 localVarPath = strings.Replace(localVarPath, "{"+"environmentKey"+"}", fmt.Sprintf("%v", environmentKey), -1) 2626 localVarPath = strings.Replace(localVarPath, "{"+"approvalRequestId"+"}", fmt.Sprintf("%v", approvalRequestId), -1) 2627 2628 localVarHeaderParams := make(map[string]string) 2629 localVarQueryParams := url.Values{} 2630 localVarFormParams := url.Values{} 2631 2632 // to determine the Content-Type header 2633 localVarHttpContentTypes := []string{"application/json"} 2634 2635 // set Content-Type header 2636 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2637 if localVarHttpContentType != "" { 2638 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2639 } 2640 2641 // to determine the Accept header 2642 localVarHttpHeaderAccepts := []string{"application/json"} 2643 2644 // set Accept header 2645 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2646 if localVarHttpHeaderAccept != "" { 2647 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2648 } 2649 // body params 2650 localVarPostBody = &approvalRequestReviewConfigBody 2651 if ctx != nil { 2652 // API Key Authentication 2653 if auth, ok := ctx.Value(ContextAPIKey).(APIKey); ok { 2654 var key string 2655 if auth.Prefix != "" { 2656 key = auth.Prefix + " " + auth.Key 2657 } else { 2658 key = auth.Key 2659 } 2660 localVarHeaderParams["Authorization"] = key 2661 2662 } 2663 } 2664 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2665 if err != nil { 2666 return localVarReturnValue, nil, err 2667 } 2668 2669 localVarHttpResponse, err := a.client.callAPI(r) 2670 if err != nil || localVarHttpResponse == nil { 2671 return localVarReturnValue, localVarHttpResponse, err 2672 } 2673 2674 localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body) 2675 localVarHttpResponse.Body.Close() 2676 if err != nil { 2677 return localVarReturnValue, localVarHttpResponse, err 2678 } 2679 2680 if localVarHttpResponse.StatusCode < 300 { 2681 // If we succeed, return the data, otherwise pass on to decode error. 2682 err = a.client.decode(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2683 return localVarReturnValue, localVarHttpResponse, err 2684 } 2685 2686 if localVarHttpResponse.StatusCode >= 300 { 2687 newErr := GenericSwaggerError{ 2688 body: localVarBody, 2689 error: localVarHttpResponse.Status, 2690 } 2691 2692 if localVarHttpResponse.StatusCode == 200 { 2693 var v ApprovalRequests 2694 err = a.client.decode(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type")); 2695 if err != nil { 2696 newErr.error = err.Error() 2697 return localVarReturnValue, localVarHttpResponse, newErr 2698 } 2699 newErr.model = v 2700 return localVarReturnValue, localVarHttpResponse, newErr 2701 } 2702 2703 return localVarReturnValue, localVarHttpResponse, newErr 2704 } 2705 2706 return localVarReturnValue, localVarHttpResponse, nil 2707 } 2708