github.com/vmware/go-vmware-nsxt@v0.0.0-20230223012718-d31b8a1ca05e/upgrade_api.go (about) 1 /* Copyright © 2017 VMware, Inc. All Rights Reserved. 2 SPDX-License-Identifier: BSD-2-Clause 3 4 Generated by: https://github.com/swagger-api/swagger-codegen.git */ 5 6 package nsxt 7 8 import ( 9 "context" 10 "encoding/json" 11 "fmt" 12 "github.com/vmware/go-vmware-nsxt/upgrade" 13 "net/http" 14 "net/url" 15 "strings" 16 ) 17 18 // Linger please 19 var ( 20 _ context.Context 21 ) 22 23 type UpgradeApiService service 24 25 /* UpgradeApiService Add upgrade units to specified upgrade unit group 26 Add upgrade units to specified upgrade unit group 27 * @param ctx context.Context Authentication Context 28 @param groupId 29 @param upgradeUnitList 30 @return UpgradeUnitList*/ 31 func (a *UpgradeApiService) AddUpgradeUnitsToGroupAddUpgradeUnits(ctx context.Context, groupId string, upgradeUnitList upgrade.UpgradeUnitList) (upgrade.UpgradeUnitList, *http.Response, error) { 32 var ( 33 localVarHttpMethod = strings.ToUpper("Post") 34 localVarPostBody interface{} 35 localVarFileName string 36 localVarFileBytes []byte 37 successPayload upgrade.UpgradeUnitList 38 ) 39 40 // create path and map variables 41 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}?action=add_upgrade_units" 42 localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1) 43 44 localVarHeaderParams := make(map[string]string) 45 localVarQueryParams := url.Values{} 46 localVarFormParams := url.Values{} 47 48 // to determine the Content-Type header 49 localVarHttpContentTypes := []string{"application/json"} 50 51 // set Content-Type header 52 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 53 if localVarHttpContentType != "" { 54 localVarHeaderParams["Content-Type"] = localVarHttpContentType 55 } 56 57 // to determine the Accept header 58 localVarHttpHeaderAccepts := []string{ 59 "application/json", 60 } 61 62 // set Accept header 63 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 64 if localVarHttpHeaderAccept != "" { 65 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 66 } 67 // body params 68 localVarPostBody = &upgradeUnitList 69 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 70 if err != nil { 71 return successPayload, nil, err 72 } 73 74 localVarHttpResponse, err := a.client.callAPI(r) 75 if err != nil || localVarHttpResponse == nil { 76 return successPayload, localVarHttpResponse, err 77 } 78 defer localVarHttpResponse.Body.Close() 79 if localVarHttpResponse.StatusCode >= 300 { 80 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 81 } 82 83 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 84 return successPayload, localVarHttpResponse, err 85 } 86 87 return successPayload, localVarHttpResponse, err 88 } 89 90 /* UpgradeApiService Continue upgrade 91 Continue upgrade 92 * @param ctx context.Context Authentication Context 93 @param optional (nil or map[string]interface{}) with one or more of: 94 @param "skip" (bool) Skip to upgrade of next component. 95 @return */ 96 func (a *UpgradeApiService) ContinueUpgradeContinue(ctx context.Context, localVarOptionals map[string]interface{}) (*http.Response, error) { 97 var ( 98 localVarHttpMethod = strings.ToUpper("Post") 99 localVarPostBody interface{} 100 localVarFileName string 101 localVarFileBytes []byte 102 ) 103 104 // create path and map variables 105 localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=continue" 106 107 localVarHeaderParams := make(map[string]string) 108 localVarQueryParams := url.Values{} 109 localVarFormParams := url.Values{} 110 111 if err := typeCheckParameter(localVarOptionals["skip"], "bool", "skip"); err != nil { 112 return nil, err 113 } 114 115 if localVarTempParam, localVarOk := localVarOptionals["skip"].(bool); localVarOk { 116 localVarQueryParams.Add("skip", parameterToString(localVarTempParam, "")) 117 } 118 // to determine the Content-Type header 119 localVarHttpContentTypes := []string{"application/json"} 120 121 // set Content-Type header 122 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 123 if localVarHttpContentType != "" { 124 localVarHeaderParams["Content-Type"] = localVarHttpContentType 125 } 126 127 // to determine the Accept header 128 localVarHttpHeaderAccepts := []string{ 129 "application/json", 130 } 131 132 // set Accept header 133 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 134 if localVarHttpHeaderAccept != "" { 135 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 136 } 137 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 138 if err != nil { 139 return nil, err 140 } 141 142 localVarHttpResponse, err := a.client.callAPI(r) 143 if err != nil || localVarHttpResponse == nil { 144 return localVarHttpResponse, err 145 } 146 defer localVarHttpResponse.Body.Close() 147 if localVarHttpResponse.StatusCode >= 300 { 148 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 149 } 150 151 return localVarHttpResponse, err 152 } 153 154 /* UpgradeApiService Create a group 155 Create a group 156 * @param ctx context.Context Authentication Context 157 @param upgradeUnitGroup 158 @return upgrade.UpgradeUnitGroup*/ 159 func (a *UpgradeApiService) CreateUpgradeUnitGroup(ctx context.Context, upgradeUnitGroup upgrade.UpgradeUnitGroup) (upgrade.UpgradeUnitGroup, *http.Response, error) { 160 var ( 161 localVarHttpMethod = strings.ToUpper("Post") 162 localVarPostBody interface{} 163 localVarFileName string 164 localVarFileBytes []byte 165 successPayload upgrade.UpgradeUnitGroup 166 ) 167 168 // create path and map variables 169 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups" 170 171 localVarHeaderParams := make(map[string]string) 172 localVarQueryParams := url.Values{} 173 localVarFormParams := url.Values{} 174 175 // to determine the Content-Type header 176 localVarHttpContentTypes := []string{"application/json"} 177 178 // set Content-Type header 179 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 180 if localVarHttpContentType != "" { 181 localVarHeaderParams["Content-Type"] = localVarHttpContentType 182 } 183 184 // to determine the Accept header 185 localVarHttpHeaderAccepts := []string{ 186 "application/json", 187 } 188 189 // set Accept header 190 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 191 if localVarHttpHeaderAccept != "" { 192 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 193 } 194 // body params 195 localVarPostBody = &upgradeUnitGroup 196 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 197 if err != nil { 198 return successPayload, nil, err 199 } 200 201 localVarHttpResponse, err := a.client.callAPI(r) 202 if err != nil || localVarHttpResponse == nil { 203 return successPayload, localVarHttpResponse, err 204 } 205 defer localVarHttpResponse.Body.Close() 206 if localVarHttpResponse.StatusCode >= 300 { 207 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 208 } 209 210 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 211 return successPayload, localVarHttpResponse, err 212 } 213 214 return successPayload, localVarHttpResponse, err 215 } 216 217 /* UpgradeApiService Delete the upgrade unit group 218 Delete the upgrade unit group 219 * @param ctx context.Context Authentication Context 220 @param groupId 221 @return */ 222 func (a *UpgradeApiService) DeleteUpgradeUnitGroup(ctx context.Context, groupId string) (*http.Response, error) { 223 var ( 224 localVarHttpMethod = strings.ToUpper("Delete") 225 localVarPostBody interface{} 226 localVarFileName string 227 localVarFileBytes []byte 228 ) 229 230 // create path and map variables 231 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}" 232 localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1) 233 234 localVarHeaderParams := make(map[string]string) 235 localVarQueryParams := url.Values{} 236 localVarFormParams := url.Values{} 237 238 // to determine the Content-Type header 239 localVarHttpContentTypes := []string{"application/json"} 240 241 // set Content-Type header 242 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 243 if localVarHttpContentType != "" { 244 localVarHeaderParams["Content-Type"] = localVarHttpContentType 245 } 246 247 // to determine the Accept header 248 localVarHttpHeaderAccepts := []string{ 249 "application/json", 250 } 251 252 // set Accept header 253 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 254 if localVarHttpHeaderAccept != "" { 255 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 256 } 257 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 258 if err != nil { 259 return nil, err 260 } 261 262 localVarHttpResponse, err := a.client.callAPI(r) 263 if err != nil || localVarHttpResponse == nil { 264 return localVarHttpResponse, err 265 } 266 defer localVarHttpResponse.Body.Close() 267 if localVarHttpResponse.StatusCode >= 300 { 268 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 269 } 270 271 return localVarHttpResponse, err 272 } 273 274 /* UpgradeApiService Get list of nodes across all types 275 Get list of nodes across all types 276 * @param ctx context.Context Authentication Context 277 @param optional (nil or map[string]interface{}) with one or more of: 278 @param "componentType" (string) Component type based on which nodes will be filtered 279 @param "componentVersion" (string) Component version based on which nodes will be filtered 280 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 281 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 282 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 283 @param "sortAscending" (bool) 284 @param "sortBy" (string) Field by which records are sorted 285 @return upgrade.NodeInfoListResult*/ 286 func (a *UpgradeApiService) GetNodes(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.NodeInfoListResult, *http.Response, error) { 287 var ( 288 localVarHttpMethod = strings.ToUpper("Get") 289 localVarPostBody interface{} 290 localVarFileName string 291 localVarFileBytes []byte 292 successPayload upgrade.NodeInfoListResult 293 ) 294 295 // create path and map variables 296 localVarPath := a.client.cfg.BasePath + "/upgrade/nodes" 297 298 localVarHeaderParams := make(map[string]string) 299 localVarQueryParams := url.Values{} 300 localVarFormParams := url.Values{} 301 302 if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil { 303 return successPayload, nil, err 304 } 305 if err := typeCheckParameter(localVarOptionals["componentVersion"], "string", "componentVersion"); err != nil { 306 return successPayload, nil, err 307 } 308 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 309 return successPayload, nil, err 310 } 311 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 312 return successPayload, nil, err 313 } 314 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 315 return successPayload, nil, err 316 } 317 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 318 return successPayload, nil, err 319 } 320 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 321 return successPayload, nil, err 322 } 323 324 if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk { 325 localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, "")) 326 } 327 if localVarTempParam, localVarOk := localVarOptionals["componentVersion"].(string); localVarOk { 328 localVarQueryParams.Add("component_version", parameterToString(localVarTempParam, "")) 329 } 330 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 331 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 332 } 333 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 334 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 335 } 336 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 337 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 338 } 339 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 340 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 341 } 342 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 343 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 344 } 345 // to determine the Content-Type header 346 localVarHttpContentTypes := []string{"application/json"} 347 348 // set Content-Type header 349 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 350 if localVarHttpContentType != "" { 351 localVarHeaderParams["Content-Type"] = localVarHttpContentType 352 } 353 354 // to determine the Accept header 355 localVarHttpHeaderAccepts := []string{ 356 "application/json", 357 } 358 359 // set Accept header 360 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 361 if localVarHttpHeaderAccept != "" { 362 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 363 } 364 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 365 if err != nil { 366 return successPayload, nil, err 367 } 368 369 localVarHttpResponse, err := a.client.callAPI(r) 370 if err != nil || localVarHttpResponse == nil { 371 return successPayload, localVarHttpResponse, err 372 } 373 defer localVarHttpResponse.Body.Close() 374 if localVarHttpResponse.StatusCode >= 300 { 375 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 376 } 377 378 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 379 return successPayload, localVarHttpResponse, err 380 } 381 382 return successPayload, localVarHttpResponse, err 383 } 384 385 /* UpgradeApiService Get summary of nodes 386 Get summary of nodes 387 * @param ctx context.Context Authentication Context 388 @return upgrade.NodeSummaryList*/ 389 func (a *UpgradeApiService) GetNodesSummary(ctx context.Context) (upgrade.NodeSummaryList, *http.Response, error) { 390 var ( 391 localVarHttpMethod = strings.ToUpper("Get") 392 localVarPostBody interface{} 393 localVarFileName string 394 localVarFileBytes []byte 395 successPayload upgrade.NodeSummaryList 396 ) 397 398 // create path and map variables 399 localVarPath := a.client.cfg.BasePath + "/upgrade/nodes-summary" 400 401 localVarHeaderParams := make(map[string]string) 402 localVarQueryParams := url.Values{} 403 localVarFormParams := url.Values{} 404 405 // to determine the Content-Type header 406 localVarHttpContentTypes := []string{"application/json"} 407 408 // set Content-Type header 409 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 410 if localVarHttpContentType != "" { 411 localVarHeaderParams["Content-Type"] = localVarHttpContentType 412 } 413 414 // to determine the Accept header 415 localVarHttpHeaderAccepts := []string{ 416 "application/json", 417 } 418 419 // set Accept header 420 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 421 if localVarHttpHeaderAccept != "" { 422 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 423 } 424 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 425 if err != nil { 426 return successPayload, nil, err 427 } 428 429 localVarHttpResponse, err := a.client.callAPI(r) 430 if err != nil || localVarHttpResponse == nil { 431 return successPayload, localVarHttpResponse, err 432 } 433 defer localVarHttpResponse.Body.Close() 434 if localVarHttpResponse.StatusCode >= 300 { 435 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 436 } 437 438 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 439 return successPayload, localVarHttpResponse, err 440 } 441 442 return successPayload, localVarHttpResponse, err 443 } 444 445 /* UpgradeApiService Get upgrade history 446 Get upgrade history 447 * @param ctx context.Context Authentication Context 448 @return UpgradeHistoryList*/ 449 func (a *UpgradeApiService) GetUpgradeHistory(ctx context.Context) (upgrade.UpgradeHistoryList, *http.Response, error) { 450 var ( 451 localVarHttpMethod = strings.ToUpper("Get") 452 localVarPostBody interface{} 453 localVarFileName string 454 localVarFileBytes []byte 455 successPayload upgrade.UpgradeHistoryList 456 ) 457 458 // create path and map variables 459 localVarPath := a.client.cfg.BasePath + "/upgrade/history" 460 461 localVarHeaderParams := make(map[string]string) 462 localVarQueryParams := url.Values{} 463 localVarFormParams := url.Values{} 464 465 // to determine the Content-Type header 466 localVarHttpContentTypes := []string{"application/json"} 467 468 // set Content-Type header 469 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 470 if localVarHttpContentType != "" { 471 localVarHeaderParams["Content-Type"] = localVarHttpContentType 472 } 473 474 // to determine the Accept header 475 localVarHttpHeaderAccepts := []string{ 476 "application/json", 477 } 478 479 // set Accept header 480 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 481 if localVarHttpHeaderAccept != "" { 482 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 483 } 484 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 485 if err != nil { 486 return successPayload, nil, err 487 } 488 489 localVarHttpResponse, err := a.client.callAPI(r) 490 if err != nil || localVarHttpResponse == nil { 491 return successPayload, localVarHttpResponse, err 492 } 493 defer localVarHttpResponse.Body.Close() 494 if localVarHttpResponse.StatusCode >= 300 { 495 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 496 } 497 498 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 499 return successPayload, localVarHttpResponse, err 500 } 501 502 return successPayload, localVarHttpResponse, err 503 } 504 505 /* UpgradeApiService Get upgrade plan settings for the component 506 Get the upgrade plan settings for the component. 507 * @param ctx context.Context Authentication Context 508 @param componentType 509 @return UpgradePlanSettings*/ 510 func (a *UpgradeApiService) GetUpgradePlanSettings(ctx context.Context, componentType string) (upgrade.UpgradePlanSettings, *http.Response, error) { 511 var ( 512 localVarHttpMethod = strings.ToUpper("Get") 513 localVarPostBody interface{} 514 localVarFileName string 515 localVarFileBytes []byte 516 successPayload upgrade.UpgradePlanSettings 517 ) 518 519 // create path and map variables 520 localVarPath := a.client.cfg.BasePath + "/upgrade/plan/{component_type}/settings" 521 localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1) 522 523 localVarHeaderParams := make(map[string]string) 524 localVarQueryParams := url.Values{} 525 localVarFormParams := url.Values{} 526 527 // to determine the Content-Type header 528 localVarHttpContentTypes := []string{"application/json"} 529 530 // set Content-Type header 531 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 532 if localVarHttpContentType != "" { 533 localVarHeaderParams["Content-Type"] = localVarHttpContentType 534 } 535 536 // to determine the Accept header 537 localVarHttpHeaderAccepts := []string{ 538 "application/json", 539 } 540 541 // set Accept header 542 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 543 if localVarHttpHeaderAccept != "" { 544 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 545 } 546 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 547 if err != nil { 548 return successPayload, nil, err 549 } 550 551 localVarHttpResponse, err := a.client.callAPI(r) 552 if err != nil || localVarHttpResponse == nil { 553 return successPayload, localVarHttpResponse, err 554 } 555 defer localVarHttpResponse.Body.Close() 556 if localVarHttpResponse.StatusCode >= 300 { 557 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 558 } 559 560 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 561 return successPayload, localVarHttpResponse, err 562 } 563 564 return successPayload, localVarHttpResponse, err 565 } 566 567 /* UpgradeApiService Get upgrade status summary 568 Get upgrade status summary 569 * @param ctx context.Context Authentication Context 570 @param optional (nil or map[string]interface{}) with one or more of: 571 @param "componentType" (string) Component type based on which upgrade units to be filtered 572 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 573 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 574 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 575 @param "selectionStatus" (string) Flag to indicate whether to return status for only selected, only deselected or both type of upgrade units 576 @param "sortAscending" (bool) 577 @param "sortBy" (string) Field by which records are sorted 578 @return UpgradeStatus*/ 579 func (a *UpgradeApiService) GetUpgradeStatusSummary(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeStatus, *http.Response, error) { 580 var ( 581 localVarHttpMethod = strings.ToUpper("Get") 582 localVarPostBody interface{} 583 localVarFileName string 584 localVarFileBytes []byte 585 successPayload upgrade.UpgradeStatus 586 ) 587 588 // create path and map variables 589 localVarPath := a.client.cfg.BasePath + "/upgrade/status-summary" 590 591 localVarHeaderParams := make(map[string]string) 592 localVarQueryParams := url.Values{} 593 localVarFormParams := url.Values{} 594 595 if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil { 596 return successPayload, nil, err 597 } 598 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 599 return successPayload, nil, err 600 } 601 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 602 return successPayload, nil, err 603 } 604 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 605 return successPayload, nil, err 606 } 607 if err := typeCheckParameter(localVarOptionals["selectionStatus"], "string", "selectionStatus"); err != nil { 608 return successPayload, nil, err 609 } 610 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 611 return successPayload, nil, err 612 } 613 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 614 return successPayload, nil, err 615 } 616 617 if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk { 618 localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, "")) 619 } 620 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 621 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 622 } 623 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 624 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 625 } 626 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 627 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 628 } 629 if localVarTempParam, localVarOk := localVarOptionals["selectionStatus"].(string); localVarOk { 630 localVarQueryParams.Add("selection_status", parameterToString(localVarTempParam, "")) 631 } 632 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 633 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 634 } 635 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 636 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 637 } 638 // to determine the Content-Type header 639 localVarHttpContentTypes := []string{"application/json"} 640 641 // set Content-Type header 642 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 643 if localVarHttpContentType != "" { 644 localVarHeaderParams["Content-Type"] = localVarHttpContentType 645 } 646 647 // to determine the Accept header 648 localVarHttpHeaderAccepts := []string{ 649 "application/json", 650 } 651 652 // set Accept header 653 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 654 if localVarHttpHeaderAccept != "" { 655 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 656 } 657 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 658 if err != nil { 659 return successPayload, nil, err 660 } 661 662 localVarHttpResponse, err := a.client.callAPI(r) 663 if err != nil || localVarHttpResponse == nil { 664 return successPayload, localVarHttpResponse, err 665 } 666 defer localVarHttpResponse.Body.Close() 667 if localVarHttpResponse.StatusCode >= 300 { 668 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 669 } 670 671 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 672 return successPayload, localVarHttpResponse, err 673 } 674 675 return successPayload, localVarHttpResponse, err 676 } 677 678 /* UpgradeApiService Get upgrade summary 679 Get upgrade summary 680 * @param ctx context.Context Authentication Context 681 @return UpgradeSummary*/ 682 func (a *UpgradeApiService) GetUpgradeSummary(ctx context.Context) (upgrade.UpgradeSummary, *http.Response, error) { 683 var ( 684 localVarHttpMethod = strings.ToUpper("Get") 685 localVarPostBody interface{} 686 localVarFileName string 687 localVarFileBytes []byte 688 successPayload upgrade.UpgradeSummary 689 ) 690 691 // create path and map variables 692 localVarPath := a.client.cfg.BasePath + "/upgrade/summary" 693 694 localVarHeaderParams := make(map[string]string) 695 localVarQueryParams := url.Values{} 696 localVarFormParams := url.Values{} 697 698 // to determine the Content-Type header 699 localVarHttpContentTypes := []string{"application/json"} 700 701 // set Content-Type header 702 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 703 if localVarHttpContentType != "" { 704 localVarHeaderParams["Content-Type"] = localVarHttpContentType 705 } 706 707 // to determine the Accept header 708 localVarHttpHeaderAccepts := []string{ 709 "application/json", 710 } 711 712 // set Accept header 713 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 714 if localVarHttpHeaderAccept != "" { 715 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 716 } 717 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 718 if err != nil { 719 return successPayload, nil, err 720 } 721 722 localVarHttpResponse, err := a.client.callAPI(r) 723 if err != nil || localVarHttpResponse == nil { 724 return successPayload, localVarHttpResponse, err 725 } 726 defer localVarHttpResponse.Body.Close() 727 if localVarHttpResponse.StatusCode >= 300 { 728 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 729 } 730 731 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 732 return successPayload, localVarHttpResponse, err 733 } 734 735 return successPayload, localVarHttpResponse, err 736 } 737 738 /* UpgradeApiService Get a specific upgrade unit 739 Get a specific upgrade unit 740 * @param ctx context.Context Authentication Context 741 @param upgradeUnitId 742 @return UpgradeUnit*/ 743 func (a *UpgradeApiService) GetUpgradeUnit(ctx context.Context, upgradeUnitId string) (upgrade.UpgradeUnit, *http.Response, error) { 744 var ( 745 localVarHttpMethod = strings.ToUpper("Get") 746 localVarPostBody interface{} 747 localVarFileName string 748 localVarFileBytes []byte 749 successPayload upgrade.UpgradeUnit 750 ) 751 752 // create path and map variables 753 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units/{upgrade-unit-id}" 754 localVarPath = strings.Replace(localVarPath, "{"+"upgrade-unit-id"+"}", fmt.Sprintf("%v", upgradeUnitId), -1) 755 756 localVarHeaderParams := make(map[string]string) 757 localVarQueryParams := url.Values{} 758 localVarFormParams := url.Values{} 759 760 // to determine the Content-Type header 761 localVarHttpContentTypes := []string{"application/json"} 762 763 // set Content-Type header 764 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 765 if localVarHttpContentType != "" { 766 localVarHeaderParams["Content-Type"] = localVarHttpContentType 767 } 768 769 // to determine the Accept header 770 localVarHttpHeaderAccepts := []string{ 771 "application/json", 772 } 773 774 // set Accept header 775 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 776 if localVarHttpHeaderAccept != "" { 777 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 778 } 779 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 780 if err != nil { 781 return successPayload, nil, err 782 } 783 784 localVarHttpResponse, err := a.client.callAPI(r) 785 if err != nil || localVarHttpResponse == nil { 786 return successPayload, localVarHttpResponse, err 787 } 788 defer localVarHttpResponse.Body.Close() 789 if localVarHttpResponse.StatusCode >= 300 { 790 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 791 } 792 793 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 794 return successPayload, localVarHttpResponse, err 795 } 796 797 return successPayload, localVarHttpResponse, err 798 } 799 800 /* UpgradeApiService Get upgrade units aggregate-info 801 Get upgrade units aggregate-info 802 * @param ctx context.Context Authentication Context 803 @param optional (nil or map[string]interface{}) with one or more of: 804 @param "componentType" (string) Component type based on which upgrade units to be filtered 805 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 806 @param "groupId" (string) Identifier of group based on which upgrade units to be filtered 807 @param "hasErrors" (bool) Flag to indicate whether to return only upgrade units with errors 808 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 809 @param "metadata" (string) Metadata about upgrade unit to filter on 810 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 811 @param "selectionStatus" (string) Flag to indicate whether to return only selected, only deselected or both type of upgrade units 812 @param "sortAscending" (bool) 813 @param "sortBy" (string) Field by which records are sorted 814 @return UpgradeUnitAggregateInfoListResult*/ 815 func (a *UpgradeApiService) GetUpgradeUnitAggregateInfo(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitAggregateInfoListResult, *http.Response, error) { 816 var ( 817 localVarHttpMethod = strings.ToUpper("Get") 818 localVarPostBody interface{} 819 localVarFileName string 820 localVarFileBytes []byte 821 successPayload upgrade.UpgradeUnitAggregateInfoListResult 822 ) 823 824 // create path and map variables 825 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units/aggregate-info" 826 827 localVarHeaderParams := make(map[string]string) 828 localVarQueryParams := url.Values{} 829 localVarFormParams := url.Values{} 830 831 if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil { 832 return successPayload, nil, err 833 } 834 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 835 return successPayload, nil, err 836 } 837 if err := typeCheckParameter(localVarOptionals["groupId"], "string", "groupId"); err != nil { 838 return successPayload, nil, err 839 } 840 if err := typeCheckParameter(localVarOptionals["hasErrors"], "bool", "hasErrors"); err != nil { 841 return successPayload, nil, err 842 } 843 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 844 return successPayload, nil, err 845 } 846 if err := typeCheckParameter(localVarOptionals["metadata"], "string", "metadata"); err != nil { 847 return successPayload, nil, err 848 } 849 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 850 return successPayload, nil, err 851 } 852 if err := typeCheckParameter(localVarOptionals["selectionStatus"], "string", "selectionStatus"); err != nil { 853 return successPayload, nil, err 854 } 855 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 856 return successPayload, nil, err 857 } 858 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 859 return successPayload, nil, err 860 } 861 862 if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk { 863 localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, "")) 864 } 865 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 866 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 867 } 868 if localVarTempParam, localVarOk := localVarOptionals["groupId"].(string); localVarOk { 869 localVarQueryParams.Add("group_id", parameterToString(localVarTempParam, "")) 870 } 871 if localVarTempParam, localVarOk := localVarOptionals["hasErrors"].(bool); localVarOk { 872 localVarQueryParams.Add("has_errors", parameterToString(localVarTempParam, "")) 873 } 874 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 875 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 876 } 877 if localVarTempParam, localVarOk := localVarOptionals["metadata"].(string); localVarOk { 878 localVarQueryParams.Add("metadata", parameterToString(localVarTempParam, "")) 879 } 880 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 881 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 882 } 883 if localVarTempParam, localVarOk := localVarOptionals["selectionStatus"].(string); localVarOk { 884 localVarQueryParams.Add("selection_status", parameterToString(localVarTempParam, "")) 885 } 886 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 887 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 888 } 889 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 890 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 891 } 892 // to determine the Content-Type header 893 localVarHttpContentTypes := []string{"application/json"} 894 895 // set Content-Type header 896 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 897 if localVarHttpContentType != "" { 898 localVarHeaderParams["Content-Type"] = localVarHttpContentType 899 } 900 901 // to determine the Accept header 902 localVarHttpHeaderAccepts := []string{ 903 "application/json", 904 } 905 906 // set Accept header 907 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 908 if localVarHttpHeaderAccept != "" { 909 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 910 } 911 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 912 if err != nil { 913 return successPayload, nil, err 914 } 915 916 localVarHttpResponse, err := a.client.callAPI(r) 917 if err != nil || localVarHttpResponse == nil { 918 return successPayload, localVarHttpResponse, err 919 } 920 defer localVarHttpResponse.Body.Close() 921 if localVarHttpResponse.StatusCode >= 300 { 922 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 923 } 924 925 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 926 return successPayload, localVarHttpResponse, err 927 } 928 929 return successPayload, localVarHttpResponse, err 930 } 931 932 /* UpgradeApiService Return upgrade unit group information 933 Return upgrade unit group information 934 * @param ctx context.Context Authentication Context 935 @param groupId 936 @param optional (nil or map[string]interface{}) with one or more of: 937 @param "summary" (bool) Flag indicating whether to return the summary 938 @return upgrade.UpgradeUnitGroup*/ 939 func (a *UpgradeApiService) GetUpgradeUnitGroup(ctx context.Context, groupId string, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroup, *http.Response, error) { 940 var ( 941 localVarHttpMethod = strings.ToUpper("Get") 942 localVarPostBody interface{} 943 localVarFileName string 944 localVarFileBytes []byte 945 successPayload upgrade.UpgradeUnitGroup 946 ) 947 948 // create path and map variables 949 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}" 950 localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1) 951 952 localVarHeaderParams := make(map[string]string) 953 localVarQueryParams := url.Values{} 954 localVarFormParams := url.Values{} 955 956 if err := typeCheckParameter(localVarOptionals["summary"], "bool", "summary"); err != nil { 957 return successPayload, nil, err 958 } 959 960 if localVarTempParam, localVarOk := localVarOptionals["summary"].(bool); localVarOk { 961 localVarQueryParams.Add("summary", parameterToString(localVarTempParam, "")) 962 } 963 // to determine the Content-Type header 964 localVarHttpContentTypes := []string{"application/json"} 965 966 // set Content-Type header 967 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 968 if localVarHttpContentType != "" { 969 localVarHeaderParams["Content-Type"] = localVarHttpContentType 970 } 971 972 // to determine the Accept header 973 localVarHttpHeaderAccepts := []string{ 974 "application/json", 975 } 976 977 // set Accept header 978 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 979 if localVarHttpHeaderAccept != "" { 980 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 981 } 982 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 983 if err != nil { 984 return successPayload, nil, err 985 } 986 987 localVarHttpResponse, err := a.client.callAPI(r) 988 if err != nil || localVarHttpResponse == nil { 989 return successPayload, localVarHttpResponse, err 990 } 991 defer localVarHttpResponse.Body.Close() 992 if localVarHttpResponse.StatusCode >= 300 { 993 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 994 } 995 996 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 997 return successPayload, localVarHttpResponse, err 998 } 999 1000 return successPayload, localVarHttpResponse, err 1001 } 1002 1003 /* UpgradeApiService Return aggregate information of all upgrade unit groups 1004 Return aggregate information of all upgrade unit groups 1005 * @param ctx context.Context Authentication Context 1006 @param optional (nil or map[string]interface{}) with one or more of: 1007 @param "componentType" (string) Component type based on which upgrade unit groups to be filtered 1008 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1009 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1010 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1011 @param "sortAscending" (bool) 1012 @param "sortBy" (string) Field by which records are sorted 1013 @param "summary" (bool) Flag indicating whether to return summary 1014 @param "sync" (bool) Synchronize before returning upgrade unit groups 1015 @return upgrade.UpgradeUnitGroupAggregateInfoListResult*/ 1016 func (a *UpgradeApiService) GetUpgradeUnitGroupAggregateInfo(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroupAggregateInfoListResult, *http.Response, error) { 1017 var ( 1018 localVarHttpMethod = strings.ToUpper("Get") 1019 localVarPostBody interface{} 1020 localVarFileName string 1021 localVarFileBytes []byte 1022 successPayload upgrade.UpgradeUnitGroupAggregateInfoListResult 1023 ) 1024 1025 // create path and map variables 1026 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/aggregate-info" 1027 1028 localVarHeaderParams := make(map[string]string) 1029 localVarQueryParams := url.Values{} 1030 localVarFormParams := url.Values{} 1031 1032 if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil { 1033 return successPayload, nil, err 1034 } 1035 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1036 return successPayload, nil, err 1037 } 1038 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1039 return successPayload, nil, err 1040 } 1041 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1042 return successPayload, nil, err 1043 } 1044 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1045 return successPayload, nil, err 1046 } 1047 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1048 return successPayload, nil, err 1049 } 1050 if err := typeCheckParameter(localVarOptionals["summary"], "bool", "summary"); err != nil { 1051 return successPayload, nil, err 1052 } 1053 if err := typeCheckParameter(localVarOptionals["sync"], "bool", "sync"); err != nil { 1054 return successPayload, nil, err 1055 } 1056 1057 if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk { 1058 localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, "")) 1059 } 1060 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1061 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1062 } 1063 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1064 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1065 } 1066 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1067 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1068 } 1069 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1070 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1071 } 1072 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1073 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1074 } 1075 if localVarTempParam, localVarOk := localVarOptionals["summary"].(bool); localVarOk { 1076 localVarQueryParams.Add("summary", parameterToString(localVarTempParam, "")) 1077 } 1078 if localVarTempParam, localVarOk := localVarOptionals["sync"].(bool); localVarOk { 1079 localVarQueryParams.Add("sync", parameterToString(localVarTempParam, "")) 1080 } 1081 // to determine the Content-Type header 1082 localVarHttpContentTypes := []string{"application/json"} 1083 1084 // set Content-Type header 1085 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1086 if localVarHttpContentType != "" { 1087 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1088 } 1089 1090 // to determine the Accept header 1091 localVarHttpHeaderAccepts := []string{ 1092 "application/json", 1093 } 1094 1095 // set Accept header 1096 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1097 if localVarHttpHeaderAccept != "" { 1098 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1099 } 1100 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1101 if err != nil { 1102 return successPayload, nil, err 1103 } 1104 1105 localVarHttpResponse, err := a.client.callAPI(r) 1106 if err != nil || localVarHttpResponse == nil { 1107 return successPayload, localVarHttpResponse, err 1108 } 1109 defer localVarHttpResponse.Body.Close() 1110 if localVarHttpResponse.StatusCode >= 300 { 1111 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1112 } 1113 1114 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1115 return successPayload, localVarHttpResponse, err 1116 } 1117 1118 return successPayload, localVarHttpResponse, err 1119 } 1120 1121 /* UpgradeApiService Get upgrade status for group 1122 Get upgrade status for group 1123 * @param ctx context.Context Authentication Context 1124 @param groupId 1125 @param optional (nil or map[string]interface{}) with one or more of: 1126 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1127 @param "hasErrors" (bool) Flag to indicate whether to return only upgrade units with errors 1128 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1129 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1130 @param "sortAscending" (bool) 1131 @param "sortBy" (string) Field by which records are sorted 1132 @return UpgradeUnitStatusListResult*/ 1133 func (a *UpgradeApiService) GetUpgradeUnitGroupStatus(ctx context.Context, groupId string, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitStatusListResult, *http.Response, error) { 1134 var ( 1135 localVarHttpMethod = strings.ToUpper("Get") 1136 localVarPostBody interface{} 1137 localVarFileName string 1138 localVarFileBytes []byte 1139 successPayload upgrade.UpgradeUnitStatusListResult 1140 ) 1141 1142 // create path and map variables 1143 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}/status" 1144 localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1) 1145 1146 localVarHeaderParams := make(map[string]string) 1147 localVarQueryParams := url.Values{} 1148 localVarFormParams := url.Values{} 1149 1150 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1151 return successPayload, nil, err 1152 } 1153 if err := typeCheckParameter(localVarOptionals["hasErrors"], "bool", "hasErrors"); err != nil { 1154 return successPayload, nil, err 1155 } 1156 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1157 return successPayload, nil, err 1158 } 1159 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1160 return successPayload, nil, err 1161 } 1162 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1163 return successPayload, nil, err 1164 } 1165 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1166 return successPayload, nil, err 1167 } 1168 1169 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1170 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1171 } 1172 if localVarTempParam, localVarOk := localVarOptionals["hasErrors"].(bool); localVarOk { 1173 localVarQueryParams.Add("has_errors", parameterToString(localVarTempParam, "")) 1174 } 1175 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1176 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1177 } 1178 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1179 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1180 } 1181 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1182 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1183 } 1184 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1185 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1186 } 1187 // to determine the Content-Type header 1188 localVarHttpContentTypes := []string{"application/json"} 1189 1190 // set Content-Type header 1191 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1192 if localVarHttpContentType != "" { 1193 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1194 } 1195 1196 // to determine the Accept header 1197 localVarHttpHeaderAccepts := []string{ 1198 "application/json", 1199 } 1200 1201 // set Accept header 1202 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1203 if localVarHttpHeaderAccept != "" { 1204 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1205 } 1206 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1207 if err != nil { 1208 return successPayload, nil, err 1209 } 1210 1211 localVarHttpResponse, err := a.client.callAPI(r) 1212 if err != nil || localVarHttpResponse == nil { 1213 return successPayload, localVarHttpResponse, err 1214 } 1215 defer localVarHttpResponse.Body.Close() 1216 if localVarHttpResponse.StatusCode >= 300 { 1217 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1218 } 1219 1220 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1221 return successPayload, localVarHttpResponse, err 1222 } 1223 1224 return successPayload, localVarHttpResponse, err 1225 } 1226 1227 /* UpgradeApiService Return information of all upgrade unit groups 1228 Return information of all upgrade unit groups 1229 * @param ctx context.Context Authentication Context 1230 @param optional (nil or map[string]interface{}) with one or more of: 1231 @param "componentType" (string) Component type based on which upgrade unit groups to be filtered 1232 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1233 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1234 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1235 @param "sortAscending" (bool) 1236 @param "sortBy" (string) Field by which records are sorted 1237 @param "summary" (bool) Flag indicating whether to return summary 1238 @param "sync" (bool) Synchronize before returning upgrade unit groups 1239 @return upgrade.UpgradeUnitGroupListResult*/ 1240 func (a *UpgradeApiService) GetUpgradeUnitGroups(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroupListResult, *http.Response, error) { 1241 var ( 1242 localVarHttpMethod = strings.ToUpper("Get") 1243 localVarPostBody interface{} 1244 localVarFileName string 1245 localVarFileBytes []byte 1246 successPayload upgrade.UpgradeUnitGroupListResult 1247 ) 1248 1249 // create path and map variables 1250 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups" 1251 1252 localVarHeaderParams := make(map[string]string) 1253 localVarQueryParams := url.Values{} 1254 localVarFormParams := url.Values{} 1255 1256 if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil { 1257 return successPayload, nil, err 1258 } 1259 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1260 return successPayload, nil, err 1261 } 1262 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1263 return successPayload, nil, err 1264 } 1265 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1266 return successPayload, nil, err 1267 } 1268 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1269 return successPayload, nil, err 1270 } 1271 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1272 return successPayload, nil, err 1273 } 1274 if err := typeCheckParameter(localVarOptionals["summary"], "bool", "summary"); err != nil { 1275 return successPayload, nil, err 1276 } 1277 if err := typeCheckParameter(localVarOptionals["sync"], "bool", "sync"); err != nil { 1278 return successPayload, nil, err 1279 } 1280 1281 if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk { 1282 localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, "")) 1283 } 1284 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1285 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1286 } 1287 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1288 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1289 } 1290 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1291 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1292 } 1293 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1294 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1295 } 1296 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1297 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1298 } 1299 if localVarTempParam, localVarOk := localVarOptionals["summary"].(bool); localVarOk { 1300 localVarQueryParams.Add("summary", parameterToString(localVarTempParam, "")) 1301 } 1302 if localVarTempParam, localVarOk := localVarOptionals["sync"].(bool); localVarOk { 1303 localVarQueryParams.Add("sync", parameterToString(localVarTempParam, "")) 1304 } 1305 // to determine the Content-Type header 1306 localVarHttpContentTypes := []string{"application/json"} 1307 1308 // set Content-Type header 1309 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1310 if localVarHttpContentType != "" { 1311 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1312 } 1313 1314 // to determine the Accept header 1315 localVarHttpHeaderAccepts := []string{ 1316 "application/json", 1317 } 1318 1319 // set Accept header 1320 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1321 if localVarHttpHeaderAccept != "" { 1322 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1323 } 1324 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1325 if err != nil { 1326 return successPayload, nil, err 1327 } 1328 1329 localVarHttpResponse, err := a.client.callAPI(r) 1330 if err != nil || localVarHttpResponse == nil { 1331 return successPayload, localVarHttpResponse, err 1332 } 1333 defer localVarHttpResponse.Body.Close() 1334 if localVarHttpResponse.StatusCode >= 300 { 1335 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1336 } 1337 1338 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1339 return successPayload, localVarHttpResponse, err 1340 } 1341 1342 return successPayload, localVarHttpResponse, err 1343 } 1344 1345 /* UpgradeApiService Get upgrade status for upgrade unit groups 1346 Get upgrade status for upgrade unit groups 1347 * @param ctx context.Context Authentication Context 1348 @param optional (nil or map[string]interface{}) with one or more of: 1349 @param "componentType" (string) Component type based on which upgrade unit groups to be filtered 1350 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1351 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1352 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1353 @param "sortAscending" (bool) 1354 @param "sortBy" (string) Field by which records are sorted 1355 @return upgrade.UpgradeUnitGroupStatusListResult*/ 1356 func (a *UpgradeApiService) GetUpgradeUnitGroupsStatus(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitGroupStatusListResult, *http.Response, error) { 1357 var ( 1358 localVarHttpMethod = strings.ToUpper("Get") 1359 localVarPostBody interface{} 1360 localVarFileName string 1361 localVarFileBytes []byte 1362 successPayload upgrade.UpgradeUnitGroupStatusListResult 1363 ) 1364 1365 // create path and map variables 1366 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups-status" 1367 1368 localVarHeaderParams := make(map[string]string) 1369 localVarQueryParams := url.Values{} 1370 localVarFormParams := url.Values{} 1371 1372 if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil { 1373 return successPayload, nil, err 1374 } 1375 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1376 return successPayload, nil, err 1377 } 1378 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1379 return successPayload, nil, err 1380 } 1381 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1382 return successPayload, nil, err 1383 } 1384 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1385 return successPayload, nil, err 1386 } 1387 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1388 return successPayload, nil, err 1389 } 1390 1391 if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk { 1392 localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, "")) 1393 } 1394 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1395 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1396 } 1397 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1398 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1399 } 1400 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1401 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1402 } 1403 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1404 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1405 } 1406 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1407 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1408 } 1409 // to determine the Content-Type header 1410 localVarHttpContentTypes := []string{"application/json"} 1411 1412 // set Content-Type header 1413 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1414 if localVarHttpContentType != "" { 1415 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1416 } 1417 1418 // to determine the Accept header 1419 localVarHttpHeaderAccepts := []string{ 1420 "application/json", 1421 } 1422 1423 // set Accept header 1424 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1425 if localVarHttpHeaderAccept != "" { 1426 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1427 } 1428 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1429 if err != nil { 1430 return successPayload, nil, err 1431 } 1432 1433 localVarHttpResponse, err := a.client.callAPI(r) 1434 if err != nil || localVarHttpResponse == nil { 1435 return successPayload, localVarHttpResponse, err 1436 } 1437 defer localVarHttpResponse.Body.Close() 1438 if localVarHttpResponse.StatusCode >= 300 { 1439 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1440 } 1441 1442 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1443 return successPayload, localVarHttpResponse, err 1444 } 1445 1446 return successPayload, localVarHttpResponse, err 1447 } 1448 1449 /* UpgradeApiService Get upgrade units 1450 Get upgrade units 1451 * @param ctx context.Context Authentication Context 1452 @param optional (nil or map[string]interface{}) with one or more of: 1453 @param "componentType" (string) Component type based on which upgrade units to be filtered 1454 @param "currentVersion" (string) Current version of upgrade unit based on which upgrade units to be filtered 1455 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1456 @param "groupId" (string) UUID of group based on which upgrade units to be filtered 1457 @param "hasWarnings" (bool) Flag to indicate whether to return only upgrade units with warnings 1458 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1459 @param "metadata" (string) Metadata about upgrade unit to filter on 1460 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1461 @param "sortAscending" (bool) 1462 @param "sortBy" (string) Field by which records are sorted 1463 @param "upgradeUnitType" (string) Upgrade unit type based on which upgrade units to be filtered 1464 @return UpgradeUnitListResult*/ 1465 func (a *UpgradeApiService) GetUpgradeUnits(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitListResult, *http.Response, error) { 1466 var ( 1467 localVarHttpMethod = strings.ToUpper("Get") 1468 localVarPostBody interface{} 1469 localVarFileName string 1470 localVarFileBytes []byte 1471 successPayload upgrade.UpgradeUnitListResult 1472 ) 1473 1474 // create path and map variables 1475 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units" 1476 1477 localVarHeaderParams := make(map[string]string) 1478 localVarQueryParams := url.Values{} 1479 localVarFormParams := url.Values{} 1480 1481 if err := typeCheckParameter(localVarOptionals["componentType"], "string", "componentType"); err != nil { 1482 return successPayload, nil, err 1483 } 1484 if err := typeCheckParameter(localVarOptionals["currentVersion"], "string", "currentVersion"); err != nil { 1485 return successPayload, nil, err 1486 } 1487 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1488 return successPayload, nil, err 1489 } 1490 if err := typeCheckParameter(localVarOptionals["groupId"], "string", "groupId"); err != nil { 1491 return successPayload, nil, err 1492 } 1493 if err := typeCheckParameter(localVarOptionals["hasWarnings"], "bool", "hasWarnings"); err != nil { 1494 return successPayload, nil, err 1495 } 1496 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1497 return successPayload, nil, err 1498 } 1499 if err := typeCheckParameter(localVarOptionals["metadata"], "string", "metadata"); err != nil { 1500 return successPayload, nil, err 1501 } 1502 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1503 return successPayload, nil, err 1504 } 1505 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1506 return successPayload, nil, err 1507 } 1508 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1509 return successPayload, nil, err 1510 } 1511 if err := typeCheckParameter(localVarOptionals["upgradeUnitType"], "string", "upgradeUnitType"); err != nil { 1512 return successPayload, nil, err 1513 } 1514 1515 if localVarTempParam, localVarOk := localVarOptionals["componentType"].(string); localVarOk { 1516 localVarQueryParams.Add("component_type", parameterToString(localVarTempParam, "")) 1517 } 1518 if localVarTempParam, localVarOk := localVarOptionals["currentVersion"].(string); localVarOk { 1519 localVarQueryParams.Add("current_version", parameterToString(localVarTempParam, "")) 1520 } 1521 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1522 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1523 } 1524 if localVarTempParam, localVarOk := localVarOptionals["groupId"].(string); localVarOk { 1525 localVarQueryParams.Add("group_id", parameterToString(localVarTempParam, "")) 1526 } 1527 if localVarTempParam, localVarOk := localVarOptionals["hasWarnings"].(bool); localVarOk { 1528 localVarQueryParams.Add("has_warnings", parameterToString(localVarTempParam, "")) 1529 } 1530 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1531 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1532 } 1533 if localVarTempParam, localVarOk := localVarOptionals["metadata"].(string); localVarOk { 1534 localVarQueryParams.Add("metadata", parameterToString(localVarTempParam, "")) 1535 } 1536 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1537 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1538 } 1539 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1540 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1541 } 1542 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1543 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1544 } 1545 if localVarTempParam, localVarOk := localVarOptionals["upgradeUnitType"].(string); localVarOk { 1546 localVarQueryParams.Add("upgrade_unit_type", parameterToString(localVarTempParam, "")) 1547 } 1548 // to determine the Content-Type header 1549 localVarHttpContentTypes := []string{"application/json"} 1550 1551 // set Content-Type header 1552 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1553 if localVarHttpContentType != "" { 1554 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1555 } 1556 1557 // to determine the Accept header 1558 localVarHttpHeaderAccepts := []string{ 1559 "application/json", 1560 } 1561 1562 // set Accept header 1563 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1564 if localVarHttpHeaderAccept != "" { 1565 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1566 } 1567 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1568 if err != nil { 1569 return successPayload, nil, err 1570 } 1571 1572 localVarHttpResponse, err := a.client.callAPI(r) 1573 if err != nil || localVarHttpResponse == nil { 1574 return successPayload, localVarHttpResponse, err 1575 } 1576 defer localVarHttpResponse.Body.Close() 1577 if localVarHttpResponse.StatusCode >= 300 { 1578 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1579 } 1580 1581 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1582 return successPayload, localVarHttpResponse, err 1583 } 1584 1585 return successPayload, localVarHttpResponse, err 1586 } 1587 1588 /* UpgradeApiService Get upgrade units stats 1589 Get upgrade units stats 1590 * @param ctx context.Context Authentication Context 1591 @param optional (nil or map[string]interface{}) with one or more of: 1592 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1593 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1594 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1595 @param "sortAscending" (bool) 1596 @param "sortBy" (string) Field by which records are sorted 1597 @param "sync" (bool) Synchronize before returning upgrade unit stats 1598 @return UpgradeUnitTypeStatsList*/ 1599 func (a *UpgradeApiService) GetUpgradeUnitsStats(ctx context.Context, localVarOptionals map[string]interface{}) (upgrade.UpgradeUnitTypeStatsList, *http.Response, error) { 1600 var ( 1601 localVarHttpMethod = strings.ToUpper("Get") 1602 localVarPostBody interface{} 1603 localVarFileName string 1604 localVarFileBytes []byte 1605 successPayload upgrade.UpgradeUnitTypeStatsList 1606 ) 1607 1608 // create path and map variables 1609 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-units-stats" 1610 1611 localVarHeaderParams := make(map[string]string) 1612 localVarQueryParams := url.Values{} 1613 localVarFormParams := url.Values{} 1614 1615 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1616 return successPayload, nil, err 1617 } 1618 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1619 return successPayload, nil, err 1620 } 1621 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1622 return successPayload, nil, err 1623 } 1624 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1625 return successPayload, nil, err 1626 } 1627 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1628 return successPayload, nil, err 1629 } 1630 if err := typeCheckParameter(localVarOptionals["sync"], "bool", "sync"); err != nil { 1631 return successPayload, nil, err 1632 } 1633 1634 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1635 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1636 } 1637 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1638 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1639 } 1640 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1641 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1642 } 1643 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1644 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1645 } 1646 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1647 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1648 } 1649 if localVarTempParam, localVarOk := localVarOptionals["sync"].(bool); localVarOk { 1650 localVarQueryParams.Add("sync", parameterToString(localVarTempParam, "")) 1651 } 1652 // to determine the Content-Type header 1653 localVarHttpContentTypes := []string{"application/json"} 1654 1655 // set Content-Type header 1656 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1657 if localVarHttpContentType != "" { 1658 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1659 } 1660 1661 // to determine the Accept header 1662 localVarHttpHeaderAccepts := []string{ 1663 "application/json", 1664 } 1665 1666 // set Accept header 1667 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1668 if localVarHttpHeaderAccept != "" { 1669 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1670 } 1671 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1672 if err != nil { 1673 return successPayload, nil, err 1674 } 1675 1676 localVarHttpResponse, err := a.client.callAPI(r) 1677 if err != nil || localVarHttpResponse == nil { 1678 return successPayload, localVarHttpResponse, err 1679 } 1680 defer localVarHttpResponse.Body.Close() 1681 if localVarHttpResponse.StatusCode >= 300 { 1682 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1683 } 1684 1685 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1686 return successPayload, localVarHttpResponse, err 1687 } 1688 1689 return successPayload, localVarHttpResponse, err 1690 } 1691 1692 /* UpgradeApiService Get the version whitelist 1693 Get whitelist of versions for different components 1694 * @param ctx context.Context Authentication Context 1695 @return manager.AcceptableComponentVersionList*/ 1696 func (a *UpgradeApiService) GetVersionWhitelist(ctx context.Context) (upgrade.AcceptableComponentVersionList, *http.Response, error) { 1697 var ( 1698 localVarHttpMethod = strings.ToUpper("Get") 1699 localVarPostBody interface{} 1700 localVarFileName string 1701 localVarFileBytes []byte 1702 successPayload upgrade.AcceptableComponentVersionList 1703 ) 1704 1705 // create path and map variables 1706 localVarPath := a.client.cfg.BasePath + "/upgrade/version-whitelist" 1707 1708 localVarHeaderParams := make(map[string]string) 1709 localVarQueryParams := url.Values{} 1710 localVarFormParams := url.Values{} 1711 1712 // to determine the Content-Type header 1713 localVarHttpContentTypes := []string{"application/json"} 1714 1715 // set Content-Type header 1716 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1717 if localVarHttpContentType != "" { 1718 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1719 } 1720 1721 // to determine the Accept header 1722 localVarHttpHeaderAccepts := []string{ 1723 "application/json", 1724 } 1725 1726 // set Accept header 1727 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1728 if localVarHttpHeaderAccept != "" { 1729 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1730 } 1731 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1732 if err != nil { 1733 return successPayload, nil, err 1734 } 1735 1736 localVarHttpResponse, err := a.client.callAPI(r) 1737 if err != nil || localVarHttpResponse == nil { 1738 return successPayload, localVarHttpResponse, err 1739 } 1740 defer localVarHttpResponse.Body.Close() 1741 if localVarHttpResponse.StatusCode >= 300 { 1742 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1743 } 1744 1745 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1746 return successPayload, localVarHttpResponse, err 1747 } 1748 1749 return successPayload, localVarHttpResponse, err 1750 } 1751 1752 /* UpgradeApiService Get the version whitelist for the specified component 1753 Get whitelist of versions for a component. Component can include HOST, EDGE, CCP, MP 1754 * @param ctx context.Context Authentication Context 1755 @param componentType 1756 @return upgrade.AcceptableComponentVersion*/ 1757 func (a *UpgradeApiService) GetVersionWhitelistByComponent(ctx context.Context, componentType string) (upgrade.AcceptableComponentVersion, *http.Response, error) { 1758 var ( 1759 localVarHttpMethod = strings.ToUpper("Get") 1760 localVarPostBody interface{} 1761 localVarFileName string 1762 localVarFileBytes []byte 1763 successPayload upgrade.AcceptableComponentVersion 1764 ) 1765 1766 // create path and map variables 1767 localVarPath := a.client.cfg.BasePath + "/upgrade/version-whitelist/{component_type}" 1768 localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1) 1769 1770 localVarHeaderParams := make(map[string]string) 1771 localVarQueryParams := url.Values{} 1772 localVarFormParams := url.Values{} 1773 1774 // to determine the Content-Type header 1775 localVarHttpContentTypes := []string{"application/json"} 1776 1777 // set Content-Type header 1778 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1779 if localVarHttpContentType != "" { 1780 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1781 } 1782 1783 // to determine the Accept header 1784 localVarHttpHeaderAccepts := []string{ 1785 "application/json", 1786 } 1787 1788 // set Accept header 1789 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1790 if localVarHttpHeaderAccept != "" { 1791 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1792 } 1793 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1794 if err != nil { 1795 return successPayload, nil, err 1796 } 1797 1798 localVarHttpResponse, err := a.client.callAPI(r) 1799 if err != nil || localVarHttpResponse == nil { 1800 return successPayload, localVarHttpResponse, err 1801 } 1802 defer localVarHttpResponse.Body.Close() 1803 if localVarHttpResponse.StatusCode >= 300 { 1804 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1805 } 1806 1807 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1808 return successPayload, localVarHttpResponse, err 1809 } 1810 1811 return successPayload, localVarHttpResponse, err 1812 } 1813 1814 /* UpgradeApiService Pause upgrade 1815 Pause upgrade 1816 * @param ctx context.Context Authentication Context 1817 @return */ 1818 func (a *UpgradeApiService) PauseUpgradePause(ctx context.Context) (*http.Response, error) { 1819 var ( 1820 localVarHttpMethod = strings.ToUpper("Post") 1821 localVarPostBody interface{} 1822 localVarFileName string 1823 localVarFileBytes []byte 1824 ) 1825 1826 // create path and map variables 1827 localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=pause" 1828 1829 localVarHeaderParams := make(map[string]string) 1830 localVarQueryParams := url.Values{} 1831 localVarFormParams := url.Values{} 1832 1833 // to determine the Content-Type header 1834 localVarHttpContentTypes := []string{"application/json"} 1835 1836 // set Content-Type header 1837 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1838 if localVarHttpContentType != "" { 1839 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1840 } 1841 1842 // to determine the Accept header 1843 localVarHttpHeaderAccepts := []string{ 1844 "application/json", 1845 } 1846 1847 // set Accept header 1848 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1849 if localVarHttpHeaderAccept != "" { 1850 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1851 } 1852 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1853 if err != nil { 1854 return nil, err 1855 } 1856 1857 localVarHttpResponse, err := a.client.callAPI(r) 1858 if err != nil || localVarHttpResponse == nil { 1859 return localVarHttpResponse, err 1860 } 1861 defer localVarHttpResponse.Body.Close() 1862 if localVarHttpResponse.StatusCode >= 300 { 1863 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 1864 } 1865 1866 return localVarHttpResponse, err 1867 } 1868 1869 /* UpgradeApiService Reorder upgrade unit group 1870 Reorder upgrade unit group 1871 * @param ctx context.Context Authentication Context 1872 @param groupId 1873 @param reorderRequest 1874 @return */ 1875 func (a *UpgradeApiService) ReorderUpgradeUnitGroupReorder(ctx context.Context, groupId string, reorderRequest upgrade.ReorderRequest) (*http.Response, error) { 1876 var ( 1877 localVarHttpMethod = strings.ToUpper("Post") 1878 localVarPostBody interface{} 1879 localVarFileName string 1880 localVarFileBytes []byte 1881 ) 1882 1883 // create path and map variables 1884 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}?action=reorder" 1885 localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1) 1886 1887 localVarHeaderParams := make(map[string]string) 1888 localVarQueryParams := url.Values{} 1889 localVarFormParams := url.Values{} 1890 1891 // to determine the Content-Type header 1892 localVarHttpContentTypes := []string{"application/json"} 1893 1894 // set Content-Type header 1895 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1896 if localVarHttpContentType != "" { 1897 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1898 } 1899 1900 // to determine the Accept header 1901 localVarHttpHeaderAccepts := []string{ 1902 "application/json", 1903 } 1904 1905 // set Accept header 1906 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1907 if localVarHttpHeaderAccept != "" { 1908 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1909 } 1910 // body params 1911 localVarPostBody = &reorderRequest 1912 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1913 if err != nil { 1914 return nil, err 1915 } 1916 1917 localVarHttpResponse, err := a.client.callAPI(r) 1918 if err != nil || localVarHttpResponse == nil { 1919 return localVarHttpResponse, err 1920 } 1921 defer localVarHttpResponse.Body.Close() 1922 if localVarHttpResponse.StatusCode >= 300 { 1923 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 1924 } 1925 1926 return localVarHttpResponse, err 1927 } 1928 1929 /* UpgradeApiService Reorder an upgrade unit within the upgrade unit group 1930 Reorder an upgrade unit within the upgrade unit group 1931 * @param ctx context.Context Authentication Context 1932 @param groupId 1933 @param upgradeUnitId 1934 @param reorderRequest 1935 @return */ 1936 func (a *UpgradeApiService) ReorderUpgradeUnitReorder(ctx context.Context, groupId string, upgradeUnitId string, reorderRequest upgrade.ReorderRequest) (*http.Response, error) { 1937 var ( 1938 localVarHttpMethod = strings.ToUpper("Post") 1939 localVarPostBody interface{} 1940 localVarFileName string 1941 localVarFileBytes []byte 1942 ) 1943 1944 // create path and map variables 1945 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}/upgrade-unit/{upgrade-unit-id}?action=reorder" 1946 localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1) 1947 localVarPath = strings.Replace(localVarPath, "{"+"upgrade-unit-id"+"}", fmt.Sprintf("%v", upgradeUnitId), -1) 1948 1949 localVarHeaderParams := make(map[string]string) 1950 localVarQueryParams := url.Values{} 1951 localVarFormParams := url.Values{} 1952 1953 // to determine the Content-Type header 1954 localVarHttpContentTypes := []string{"application/json"} 1955 1956 // set Content-Type header 1957 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1958 if localVarHttpContentType != "" { 1959 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1960 } 1961 1962 // to determine the Accept header 1963 localVarHttpHeaderAccepts := []string{ 1964 "application/json", 1965 } 1966 1967 // set Accept header 1968 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1969 if localVarHttpHeaderAccept != "" { 1970 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1971 } 1972 // body params 1973 localVarPostBody = &reorderRequest 1974 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1975 if err != nil { 1976 return nil, err 1977 } 1978 1979 localVarHttpResponse, err := a.client.callAPI(r) 1980 if err != nil || localVarHttpResponse == nil { 1981 return localVarHttpResponse, err 1982 } 1983 defer localVarHttpResponse.Body.Close() 1984 if localVarHttpResponse.StatusCode >= 300 { 1985 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 1986 } 1987 1988 return localVarHttpResponse, err 1989 } 1990 1991 /* UpgradeApiService Reset upgrade plan to default plan 1992 Reset the upgrade plan to default plan. User has an option to change the default plan. But if after making changes, user wants to go back to the default plan, this is the way to do so. 1993 * @param ctx context.Context Authentication Context 1994 @param componentType Component type 1995 @return */ 1996 func (a *UpgradeApiService) ResetUpgradePlanReset(ctx context.Context, componentType string) (*http.Response, error) { 1997 var ( 1998 localVarHttpMethod = strings.ToUpper("Post") 1999 localVarPostBody interface{} 2000 localVarFileName string 2001 localVarFileBytes []byte 2002 ) 2003 2004 // create path and map variables 2005 localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=reset" 2006 2007 localVarHeaderParams := make(map[string]string) 2008 localVarQueryParams := url.Values{} 2009 localVarFormParams := url.Values{} 2010 2011 localVarQueryParams.Add("component_type", parameterToString(componentType, "")) 2012 // to determine the Content-Type header 2013 localVarHttpContentTypes := []string{"application/json"} 2014 2015 // set Content-Type header 2016 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2017 if localVarHttpContentType != "" { 2018 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2019 } 2020 2021 // to determine the Accept header 2022 localVarHttpHeaderAccepts := []string{ 2023 "application/json", 2024 } 2025 2026 // set Accept header 2027 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2028 if localVarHttpHeaderAccept != "" { 2029 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2030 } 2031 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2032 if err != nil { 2033 return nil, err 2034 } 2035 2036 localVarHttpResponse, err := a.client.callAPI(r) 2037 if err != nil || localVarHttpResponse == nil { 2038 return localVarHttpResponse, err 2039 } 2040 defer localVarHttpResponse.Body.Close() 2041 if localVarHttpResponse.StatusCode >= 300 { 2042 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 2043 } 2044 2045 return localVarHttpResponse, err 2046 } 2047 2048 /* UpgradeApiService Start upgrade 2049 Start upgrade 2050 * @param ctx context.Context Authentication Context 2051 @return */ 2052 func (a *UpgradeApiService) StartUpgradeStart(ctx context.Context) (*http.Response, error) { 2053 var ( 2054 localVarHttpMethod = strings.ToUpper("Post") 2055 localVarPostBody interface{} 2056 localVarFileName string 2057 localVarFileBytes []byte 2058 ) 2059 2060 // create path and map variables 2061 localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=start" 2062 2063 localVarHeaderParams := make(map[string]string) 2064 localVarQueryParams := url.Values{} 2065 localVarFormParams := url.Values{} 2066 2067 // to determine the Content-Type header 2068 localVarHttpContentTypes := []string{"application/json"} 2069 2070 // set Content-Type header 2071 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2072 if localVarHttpContentType != "" { 2073 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2074 } 2075 2076 // to determine the Accept header 2077 localVarHttpHeaderAccepts := []string{ 2078 "application/json", 2079 } 2080 2081 // set Accept header 2082 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2083 if localVarHttpHeaderAccept != "" { 2084 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2085 } 2086 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2087 if err != nil { 2088 return nil, err 2089 } 2090 2091 localVarHttpResponse, err := a.client.callAPI(r) 2092 if err != nil || localVarHttpResponse == nil { 2093 return localVarHttpResponse, err 2094 } 2095 defer localVarHttpResponse.Body.Close() 2096 if localVarHttpResponse.StatusCode >= 300 { 2097 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 2098 } 2099 2100 return localVarHttpResponse, err 2101 } 2102 2103 /* UpgradeApiService Upgrade the upgrade coordinator. 2104 Upgrade the upgrade coordinator. 2105 * @param ctx context.Context Authentication Context 2106 @return */ 2107 func (a *UpgradeApiService) TriggerUcUpgradeUpgradeUc(ctx context.Context) (*http.Response, error) { 2108 var ( 2109 localVarHttpMethod = strings.ToUpper("Post") 2110 localVarPostBody interface{} 2111 localVarFileName string 2112 localVarFileBytes []byte 2113 ) 2114 2115 // create path and map variables 2116 localVarPath := a.client.cfg.BasePath + "/upgrade?action=upgrade_uc" 2117 2118 localVarHeaderParams := make(map[string]string) 2119 localVarQueryParams := url.Values{} 2120 localVarFormParams := url.Values{} 2121 2122 // to determine the Content-Type header 2123 localVarHttpContentTypes := []string{"application/json"} 2124 2125 // set Content-Type header 2126 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2127 if localVarHttpContentType != "" { 2128 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2129 } 2130 2131 // to determine the Accept header 2132 localVarHttpHeaderAccepts := []string{ 2133 "application/json", 2134 } 2135 2136 // set Accept header 2137 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2138 if localVarHttpHeaderAccept != "" { 2139 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2140 } 2141 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2142 if err != nil { 2143 return nil, err 2144 } 2145 2146 localVarHttpResponse, err := a.client.callAPI(r) 2147 if err != nil || localVarHttpResponse == nil { 2148 return localVarHttpResponse, err 2149 } 2150 defer localVarHttpResponse.Body.Close() 2151 if localVarHttpResponse.StatusCode >= 300 { 2152 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 2153 } 2154 2155 return localVarHttpResponse, err 2156 } 2157 2158 /* UpgradeApiService Update upgrade plan settings for the component 2159 Update the upgrade plan settings for the component. 2160 * @param ctx context.Context Authentication Context 2161 @param componentType 2162 @param upgradePlanSettings 2163 @return UpgradePlanSettings*/ 2164 func (a *UpgradeApiService) UpdateUpgradePlanSettings(ctx context.Context, componentType string, upgradePlanSettings upgrade.UpgradePlanSettings) (upgrade.UpgradePlanSettings, *http.Response, error) { 2165 var ( 2166 localVarHttpMethod = strings.ToUpper("Put") 2167 localVarPostBody interface{} 2168 localVarFileName string 2169 localVarFileBytes []byte 2170 successPayload upgrade.UpgradePlanSettings 2171 ) 2172 2173 // create path and map variables 2174 localVarPath := a.client.cfg.BasePath + "/upgrade/plan/{component_type}/settings" 2175 localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1) 2176 2177 localVarHeaderParams := make(map[string]string) 2178 localVarQueryParams := url.Values{} 2179 localVarFormParams := url.Values{} 2180 2181 // to determine the Content-Type header 2182 localVarHttpContentTypes := []string{"application/json"} 2183 2184 // set Content-Type header 2185 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2186 if localVarHttpContentType != "" { 2187 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2188 } 2189 2190 // to determine the Accept header 2191 localVarHttpHeaderAccepts := []string{ 2192 "application/json", 2193 } 2194 2195 // set Accept header 2196 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2197 if localVarHttpHeaderAccept != "" { 2198 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2199 } 2200 // body params 2201 localVarPostBody = &upgradePlanSettings 2202 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2203 if err != nil { 2204 return successPayload, nil, err 2205 } 2206 2207 localVarHttpResponse, err := a.client.callAPI(r) 2208 if err != nil || localVarHttpResponse == nil { 2209 return successPayload, localVarHttpResponse, err 2210 } 2211 defer localVarHttpResponse.Body.Close() 2212 if localVarHttpResponse.StatusCode >= 300 { 2213 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2214 } 2215 2216 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2217 return successPayload, localVarHttpResponse, err 2218 } 2219 2220 return successPayload, localVarHttpResponse, err 2221 } 2222 2223 /* UpgradeApiService Update the upgrade unit group 2224 Update the upgrade unit group 2225 * @param ctx context.Context Authentication Context 2226 @param groupId 2227 @param upgradeUnitGroup 2228 @return upgrade.UpgradeUnitGroup*/ 2229 func (a *UpgradeApiService) UpdateUpgradeUnitGroup(ctx context.Context, groupId string, upgradeUnitGroup upgrade.UpgradeUnitGroup) (upgrade.UpgradeUnitGroup, *http.Response, error) { 2230 var ( 2231 localVarHttpMethod = strings.ToUpper("Put") 2232 localVarPostBody interface{} 2233 localVarFileName string 2234 localVarFileBytes []byte 2235 successPayload upgrade.UpgradeUnitGroup 2236 ) 2237 2238 // create path and map variables 2239 localVarPath := a.client.cfg.BasePath + "/upgrade/upgrade-unit-groups/{group-id}" 2240 localVarPath = strings.Replace(localVarPath, "{"+"group-id"+"}", fmt.Sprintf("%v", groupId), -1) 2241 2242 localVarHeaderParams := make(map[string]string) 2243 localVarQueryParams := url.Values{} 2244 localVarFormParams := url.Values{} 2245 2246 // to determine the Content-Type header 2247 localVarHttpContentTypes := []string{"application/json"} 2248 2249 // set Content-Type header 2250 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2251 if localVarHttpContentType != "" { 2252 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2253 } 2254 2255 // to determine the Accept header 2256 localVarHttpHeaderAccepts := []string{ 2257 "application/json", 2258 } 2259 2260 // set Accept header 2261 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2262 if localVarHttpHeaderAccept != "" { 2263 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2264 } 2265 // body params 2266 localVarPostBody = &upgradeUnitGroup 2267 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2268 if err != nil { 2269 return successPayload, nil, err 2270 } 2271 2272 localVarHttpResponse, err := a.client.callAPI(r) 2273 if err != nil || localVarHttpResponse == nil { 2274 return successPayload, localVarHttpResponse, err 2275 } 2276 defer localVarHttpResponse.Body.Close() 2277 if localVarHttpResponse.StatusCode >= 300 { 2278 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2279 } 2280 2281 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2282 return successPayload, localVarHttpResponse, err 2283 } 2284 2285 return successPayload, localVarHttpResponse, err 2286 } 2287 2288 /* UpgradeApiService Update the version whitelist for the specified component type 2289 Update the version whitelist for the specified component type (HOST, EDGE, CCP, MP). 2290 * @param ctx context.Context Authentication Context 2291 @param componentType 2292 @param versionList 2293 @return */ 2294 func (a *UpgradeApiService) UpdateVersionWhitelist(ctx context.Context, componentType string, versionList upgrade.VersionList) (*http.Response, error) { 2295 var ( 2296 localVarHttpMethod = strings.ToUpper("Put") 2297 localVarPostBody interface{} 2298 localVarFileName string 2299 localVarFileBytes []byte 2300 ) 2301 2302 // create path and map variables 2303 localVarPath := a.client.cfg.BasePath + "/upgrade/version-whitelist/{component_type}" 2304 localVarPath = strings.Replace(localVarPath, "{"+"component_type"+"}", fmt.Sprintf("%v", componentType), -1) 2305 2306 localVarHeaderParams := make(map[string]string) 2307 localVarQueryParams := url.Values{} 2308 localVarFormParams := url.Values{} 2309 2310 // to determine the Content-Type header 2311 localVarHttpContentTypes := []string{"application/json"} 2312 2313 // set Content-Type header 2314 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2315 if localVarHttpContentType != "" { 2316 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2317 } 2318 2319 // to determine the Accept header 2320 localVarHttpHeaderAccepts := []string{ 2321 "application/json", 2322 } 2323 2324 // set Accept header 2325 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2326 if localVarHttpHeaderAccept != "" { 2327 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2328 } 2329 // body params 2330 localVarPostBody = &versionList 2331 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2332 if err != nil { 2333 return nil, err 2334 } 2335 2336 localVarHttpResponse, err := a.client.callAPI(r) 2337 if err != nil || localVarHttpResponse == nil { 2338 return localVarHttpResponse, err 2339 } 2340 defer localVarHttpResponse.Body.Close() 2341 if localVarHttpResponse.StatusCode >= 300 { 2342 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 2343 } 2344 2345 return localVarHttpResponse, err 2346 } 2347 2348 /* UpgradeApiService Upgrade selected units 2349 Upgrade selected units 2350 * @param ctx context.Context Authentication Context 2351 @param upgradeUnitList 2352 @return */ 2353 func (a *UpgradeApiService) UpgradeSelectedUnitsUpgradeSelectedUnits(ctx context.Context, upgradeUnitList upgrade.UpgradeUnitList) (*http.Response, error) { 2354 var ( 2355 localVarHttpMethod = strings.ToUpper("Post") 2356 localVarPostBody interface{} 2357 localVarFileName string 2358 localVarFileBytes []byte 2359 ) 2360 2361 // create path and map variables 2362 localVarPath := a.client.cfg.BasePath + "/upgrade/plan?action=upgrade_selected_units" 2363 2364 localVarHeaderParams := make(map[string]string) 2365 localVarQueryParams := url.Values{} 2366 localVarFormParams := url.Values{} 2367 2368 // to determine the Content-Type header 2369 localVarHttpContentTypes := []string{"application/json"} 2370 2371 // set Content-Type header 2372 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2373 if localVarHttpContentType != "" { 2374 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2375 } 2376 2377 // to determine the Accept header 2378 localVarHttpHeaderAccepts := []string{ 2379 "application/json", 2380 } 2381 2382 // set Accept header 2383 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2384 if localVarHttpHeaderAccept != "" { 2385 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2386 } 2387 // body params 2388 localVarPostBody = &upgradeUnitList 2389 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2390 if err != nil { 2391 return nil, err 2392 } 2393 2394 localVarHttpResponse, err := a.client.callAPI(r) 2395 if err != nil || localVarHttpResponse == nil { 2396 return localVarHttpResponse, err 2397 } 2398 defer localVarHttpResponse.Body.Close() 2399 if localVarHttpResponse.StatusCode >= 300 { 2400 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 2401 } 2402 2403 return localVarHttpResponse, err 2404 }