github.com/NaverCloudPlatform/ncloud-sdk-go-v2@v1.6.13/services/server/v2_api.go (about) 1 /* 2 * server 3 * 4 * <br/>https://ncloud.apigw.ntruss.com/server/v2 5 * 6 * Generated by: Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git) 7 */ 8 9 package server 10 11 import ( 12 "encoding/base64" 13 "encoding/json" 14 "io/ioutil" 15 "net/url" 16 "reflect" 17 "strings" 18 "bytes" 19 20 "golang.org/x/net/context" 21 ) 22 23 // Linger please 24 var ( 25 _ context.Context 26 ) 27 28 type V2ApiService service 29 30 31 /* V2ApiService 32 @param addMemberServerImageSharingPermissionRequest addMemberServerImageSharingPermissionRequest 33 @return *AddMemberServerImageSharingPermissionResponse*/ 34 func (a *V2ApiService) AddMemberServerImageSharingPermission(addMemberServerImageSharingPermissionRequest *AddMemberServerImageSharingPermissionRequest) (*AddMemberServerImageSharingPermissionResponse, error) { 35 var ( 36 localVarHttpMethod = strings.ToUpper("Post") 37 localVarPostBody interface{} 38 localVarFileName string 39 localVarFileBytes []byte 40 successPayload AddMemberServerImageSharingPermissionResponse 41 ) 42 43 // create path and map variables 44 localVarPath := a.client.cfg.BasePath + "/addMemberServerImageSharingPermission" 45 46 localVarHeaderParams := make(map[string]string) 47 localVarQueryParams := url.Values{} 48 localVarFormParams := url.Values{} 49 50 51 // to determine the Content-Type header 52 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 53 54 // set Content-Type header 55 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 56 if localVarHttpContentType != "" { 57 localVarHeaderParams["Content-Type"] = localVarHttpContentType 58 } 59 60 // to determine the Accept header 61 localVarHttpHeaderAccepts := []string{ 62 } 63 64 // set Accept header 65 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 66 if localVarHttpHeaderAccept != "" { 67 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 68 } 69 // body params 70 localVarPostBody = addMemberServerImageSharingPermissionRequest 71 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 72 if v.IsValid() && v.CanAddr() { 73 ptr := v.Addr().Interface().(**string) 74 if *ptr != nil { 75 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 76 } 77 } 78 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 79 if err != nil { 80 return &successPayload, err 81 } 82 83 localVarHttpResponse, err := a.client.callAPI(r) 84 if err != nil || localVarHttpResponse == nil { 85 return &successPayload, err 86 } 87 defer localVarHttpResponse.Body.Close() 88 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 89 90 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 91 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 92 } 93 94 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 95 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 96 return &successPayload, err 97 } 98 } 99 100 101 return &successPayload, err 102 } 103 104 /* V2ApiService 105 @param addNasVolumeAccessControlRequest addNasVolumeAccessControlRequest 106 @return *AddNasVolumeAccessControlResponse*/ 107 func (a *V2ApiService) AddNasVolumeAccessControl(addNasVolumeAccessControlRequest *AddNasVolumeAccessControlRequest) (*AddNasVolumeAccessControlResponse, error) { 108 var ( 109 localVarHttpMethod = strings.ToUpper("Post") 110 localVarPostBody interface{} 111 localVarFileName string 112 localVarFileBytes []byte 113 successPayload AddNasVolumeAccessControlResponse 114 ) 115 116 // create path and map variables 117 localVarPath := a.client.cfg.BasePath + "/addNasVolumeAccessControl" 118 119 localVarHeaderParams := make(map[string]string) 120 localVarQueryParams := url.Values{} 121 localVarFormParams := url.Values{} 122 123 124 // to determine the Content-Type header 125 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 126 127 // set Content-Type header 128 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 129 if localVarHttpContentType != "" { 130 localVarHeaderParams["Content-Type"] = localVarHttpContentType 131 } 132 133 // to determine the Accept header 134 localVarHttpHeaderAccepts := []string{ 135 } 136 137 // set Accept header 138 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 139 if localVarHttpHeaderAccept != "" { 140 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 141 } 142 // body params 143 localVarPostBody = addNasVolumeAccessControlRequest 144 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 145 if v.IsValid() && v.CanAddr() { 146 ptr := v.Addr().Interface().(**string) 147 if *ptr != nil { 148 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 149 } 150 } 151 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 152 if err != nil { 153 return &successPayload, err 154 } 155 156 localVarHttpResponse, err := a.client.callAPI(r) 157 if err != nil || localVarHttpResponse == nil { 158 return &successPayload, err 159 } 160 defer localVarHttpResponse.Body.Close() 161 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 162 163 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 164 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 165 } 166 167 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 168 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 169 return &successPayload, err 170 } 171 } 172 173 174 return &successPayload, err 175 } 176 177 /* V2ApiService 178 @param addPortForwardingRulesRequest addPortForwardingRulesRequest 179 @return *AddPortForwardingRulesResponse*/ 180 func (a *V2ApiService) AddPortForwardingRules(addPortForwardingRulesRequest *AddPortForwardingRulesRequest) (*AddPortForwardingRulesResponse, error) { 181 var ( 182 localVarHttpMethod = strings.ToUpper("Post") 183 localVarPostBody interface{} 184 localVarFileName string 185 localVarFileBytes []byte 186 successPayload AddPortForwardingRulesResponse 187 ) 188 189 // create path and map variables 190 localVarPath := a.client.cfg.BasePath + "/addPortForwardingRules" 191 192 localVarHeaderParams := make(map[string]string) 193 localVarQueryParams := url.Values{} 194 localVarFormParams := url.Values{} 195 196 197 // to determine the Content-Type header 198 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 199 200 // set Content-Type header 201 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 202 if localVarHttpContentType != "" { 203 localVarHeaderParams["Content-Type"] = localVarHttpContentType 204 } 205 206 // to determine the Accept header 207 localVarHttpHeaderAccepts := []string{ 208 } 209 210 // set Accept header 211 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 212 if localVarHttpHeaderAccept != "" { 213 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 214 } 215 // body params 216 localVarPostBody = addPortForwardingRulesRequest 217 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 218 if v.IsValid() && v.CanAddr() { 219 ptr := v.Addr().Interface().(**string) 220 if *ptr != nil { 221 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 222 } 223 } 224 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 225 if err != nil { 226 return &successPayload, err 227 } 228 229 localVarHttpResponse, err := a.client.callAPI(r) 230 if err != nil || localVarHttpResponse == nil { 231 return &successPayload, err 232 } 233 defer localVarHttpResponse.Body.Close() 234 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 235 236 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 237 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 238 } 239 240 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 241 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 242 return &successPayload, err 243 } 244 } 245 246 247 return &successPayload, err 248 } 249 250 /* V2ApiService 251 @param associatePublicIpWithServerInstanceRequest associatePublicIpWithServerInstanceRequest 252 @return *AssociatePublicIpWithServerInstanceResponse*/ 253 func (a *V2ApiService) AssociatePublicIpWithServerInstance(associatePublicIpWithServerInstanceRequest *AssociatePublicIpWithServerInstanceRequest) (*AssociatePublicIpWithServerInstanceResponse, error) { 254 var ( 255 localVarHttpMethod = strings.ToUpper("Post") 256 localVarPostBody interface{} 257 localVarFileName string 258 localVarFileBytes []byte 259 successPayload AssociatePublicIpWithServerInstanceResponse 260 ) 261 262 // create path and map variables 263 localVarPath := a.client.cfg.BasePath + "/associatePublicIpWithServerInstance" 264 265 localVarHeaderParams := make(map[string]string) 266 localVarQueryParams := url.Values{} 267 localVarFormParams := url.Values{} 268 269 270 // to determine the Content-Type header 271 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 272 273 // set Content-Type header 274 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 275 if localVarHttpContentType != "" { 276 localVarHeaderParams["Content-Type"] = localVarHttpContentType 277 } 278 279 // to determine the Accept header 280 localVarHttpHeaderAccepts := []string{ 281 } 282 283 // set Accept header 284 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 285 if localVarHttpHeaderAccept != "" { 286 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 287 } 288 // body params 289 localVarPostBody = associatePublicIpWithServerInstanceRequest 290 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 291 if v.IsValid() && v.CanAddr() { 292 ptr := v.Addr().Interface().(**string) 293 if *ptr != nil { 294 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 295 } 296 } 297 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 298 if err != nil { 299 return &successPayload, err 300 } 301 302 localVarHttpResponse, err := a.client.callAPI(r) 303 if err != nil || localVarHttpResponse == nil { 304 return &successPayload, err 305 } 306 defer localVarHttpResponse.Body.Close() 307 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 308 309 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 310 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 311 } 312 313 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 314 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 315 return &successPayload, err 316 } 317 } 318 319 320 return &successPayload, err 321 } 322 323 /* V2ApiService 324 @param attachBlockStorageInstanceRequest attachBlockStorageInstanceRequest 325 @return *AttachBlockStorageInstanceResponse*/ 326 func (a *V2ApiService) AttachBlockStorageInstance(attachBlockStorageInstanceRequest *AttachBlockStorageInstanceRequest) (*AttachBlockStorageInstanceResponse, error) { 327 var ( 328 localVarHttpMethod = strings.ToUpper("Post") 329 localVarPostBody interface{} 330 localVarFileName string 331 localVarFileBytes []byte 332 successPayload AttachBlockStorageInstanceResponse 333 ) 334 335 // create path and map variables 336 localVarPath := a.client.cfg.BasePath + "/attachBlockStorageInstance" 337 338 localVarHeaderParams := make(map[string]string) 339 localVarQueryParams := url.Values{} 340 localVarFormParams := url.Values{} 341 342 343 // to determine the Content-Type header 344 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 345 346 // set Content-Type header 347 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 348 if localVarHttpContentType != "" { 349 localVarHeaderParams["Content-Type"] = localVarHttpContentType 350 } 351 352 // to determine the Accept header 353 localVarHttpHeaderAccepts := []string{ 354 } 355 356 // set Accept header 357 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 358 if localVarHttpHeaderAccept != "" { 359 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 360 } 361 // body params 362 localVarPostBody = attachBlockStorageInstanceRequest 363 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 364 if v.IsValid() && v.CanAddr() { 365 ptr := v.Addr().Interface().(**string) 366 if *ptr != nil { 367 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 368 } 369 } 370 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 371 if err != nil { 372 return &successPayload, err 373 } 374 375 localVarHttpResponse, err := a.client.callAPI(r) 376 if err != nil || localVarHttpResponse == nil { 377 return &successPayload, err 378 } 379 defer localVarHttpResponse.Body.Close() 380 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 381 382 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 383 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 384 } 385 386 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 387 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 388 return &successPayload, err 389 } 390 } 391 392 393 return &successPayload, err 394 } 395 396 /* V2ApiService 397 @param attachNetworkInterfaceRequest attachNetworkInterfaceRequest 398 @return *AttachNetworkInterfaceResponse*/ 399 func (a *V2ApiService) AttachNetworkInterface(attachNetworkInterfaceRequest *AttachNetworkInterfaceRequest) (*AttachNetworkInterfaceResponse, error) { 400 var ( 401 localVarHttpMethod = strings.ToUpper("Post") 402 localVarPostBody interface{} 403 localVarFileName string 404 localVarFileBytes []byte 405 successPayload AttachNetworkInterfaceResponse 406 ) 407 408 // create path and map variables 409 localVarPath := a.client.cfg.BasePath + "/attachNetworkInterface" 410 411 localVarHeaderParams := make(map[string]string) 412 localVarQueryParams := url.Values{} 413 localVarFormParams := url.Values{} 414 415 416 // to determine the Content-Type header 417 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 418 419 // set Content-Type header 420 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 421 if localVarHttpContentType != "" { 422 localVarHeaderParams["Content-Type"] = localVarHttpContentType 423 } 424 425 // to determine the Accept header 426 localVarHttpHeaderAccepts := []string{ 427 } 428 429 // set Accept header 430 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 431 if localVarHttpHeaderAccept != "" { 432 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 433 } 434 // body params 435 localVarPostBody = attachNetworkInterfaceRequest 436 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 437 if v.IsValid() && v.CanAddr() { 438 ptr := v.Addr().Interface().(**string) 439 if *ptr != nil { 440 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 441 } 442 } 443 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 444 if err != nil { 445 return &successPayload, err 446 } 447 448 localVarHttpResponse, err := a.client.callAPI(r) 449 if err != nil || localVarHttpResponse == nil { 450 return &successPayload, err 451 } 452 defer localVarHttpResponse.Body.Close() 453 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 454 455 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 456 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 457 } 458 459 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 460 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 461 return &successPayload, err 462 } 463 } 464 465 466 return &successPayload, err 467 } 468 469 /* V2ApiService 470 @param changeBlockStorageVolumeSizeRequest changeBlockStorageVolumeSizeRequest 471 @return *ChangeBlockStorageVolumeSizeResponse*/ 472 func (a *V2ApiService) ChangeBlockStorageVolumeSize(changeBlockStorageVolumeSizeRequest *ChangeBlockStorageVolumeSizeRequest) (*ChangeBlockStorageVolumeSizeResponse, error) { 473 var ( 474 localVarHttpMethod = strings.ToUpper("Post") 475 localVarPostBody interface{} 476 localVarFileName string 477 localVarFileBytes []byte 478 successPayload ChangeBlockStorageVolumeSizeResponse 479 ) 480 481 // create path and map variables 482 localVarPath := a.client.cfg.BasePath + "/changeBlockStorageVolumeSize" 483 484 localVarHeaderParams := make(map[string]string) 485 localVarQueryParams := url.Values{} 486 localVarFormParams := url.Values{} 487 488 489 // to determine the Content-Type header 490 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 491 492 // set Content-Type header 493 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 494 if localVarHttpContentType != "" { 495 localVarHeaderParams["Content-Type"] = localVarHttpContentType 496 } 497 498 // to determine the Accept header 499 localVarHttpHeaderAccepts := []string{ 500 } 501 502 // set Accept header 503 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 504 if localVarHttpHeaderAccept != "" { 505 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 506 } 507 // body params 508 localVarPostBody = changeBlockStorageVolumeSizeRequest 509 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 510 if v.IsValid() && v.CanAddr() { 511 ptr := v.Addr().Interface().(**string) 512 if *ptr != nil { 513 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 514 } 515 } 516 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 517 if err != nil { 518 return &successPayload, err 519 } 520 521 localVarHttpResponse, err := a.client.callAPI(r) 522 if err != nil || localVarHttpResponse == nil { 523 return &successPayload, err 524 } 525 defer localVarHttpResponse.Body.Close() 526 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 527 528 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 529 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 530 } 531 532 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 533 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 534 return &successPayload, err 535 } 536 } 537 538 539 return &successPayload, err 540 } 541 542 /* V2ApiService 543 @param changeNasVolumeSizeRequest changeNasVolumeSizeRequest 544 @return *ChangeNasVolumeSizeResponse*/ 545 func (a *V2ApiService) ChangeNasVolumeSize(changeNasVolumeSizeRequest *ChangeNasVolumeSizeRequest) (*ChangeNasVolumeSizeResponse, error) { 546 var ( 547 localVarHttpMethod = strings.ToUpper("Post") 548 localVarPostBody interface{} 549 localVarFileName string 550 localVarFileBytes []byte 551 successPayload ChangeNasVolumeSizeResponse 552 ) 553 554 // create path and map variables 555 localVarPath := a.client.cfg.BasePath + "/changeNasVolumeSize" 556 557 localVarHeaderParams := make(map[string]string) 558 localVarQueryParams := url.Values{} 559 localVarFormParams := url.Values{} 560 561 562 // to determine the Content-Type header 563 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 564 565 // set Content-Type header 566 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 567 if localVarHttpContentType != "" { 568 localVarHeaderParams["Content-Type"] = localVarHttpContentType 569 } 570 571 // to determine the Accept header 572 localVarHttpHeaderAccepts := []string{ 573 } 574 575 // set Accept header 576 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 577 if localVarHttpHeaderAccept != "" { 578 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 579 } 580 // body params 581 localVarPostBody = changeNasVolumeSizeRequest 582 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 583 if v.IsValid() && v.CanAddr() { 584 ptr := v.Addr().Interface().(**string) 585 if *ptr != nil { 586 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 587 } 588 } 589 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 590 if err != nil { 591 return &successPayload, err 592 } 593 594 localVarHttpResponse, err := a.client.callAPI(r) 595 if err != nil || localVarHttpResponse == nil { 596 return &successPayload, err 597 } 598 defer localVarHttpResponse.Body.Close() 599 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 600 601 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 602 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 603 } 604 605 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 606 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 607 return &successPayload, err 608 } 609 } 610 611 612 return &successPayload, err 613 } 614 615 /* V2ApiService 616 @param changeNasVolumeSnapshotConfigurationRequest changeNasVolumeSnapshotConfigurationRequest 617 @return *ChangeNasVolumeSnapshotConfigurationResponse*/ 618 func (a *V2ApiService) ChangeNasVolumeSnapshotConfiguration(changeNasVolumeSnapshotConfigurationRequest *ChangeNasVolumeSnapshotConfigurationRequest) (*ChangeNasVolumeSnapshotConfigurationResponse, error) { 619 var ( 620 localVarHttpMethod = strings.ToUpper("Post") 621 localVarPostBody interface{} 622 localVarFileName string 623 localVarFileBytes []byte 624 successPayload ChangeNasVolumeSnapshotConfigurationResponse 625 ) 626 627 // create path and map variables 628 localVarPath := a.client.cfg.BasePath + "/changeNasVolumeSnapshotConfiguration" 629 630 localVarHeaderParams := make(map[string]string) 631 localVarQueryParams := url.Values{} 632 localVarFormParams := url.Values{} 633 634 635 // to determine the Content-Type header 636 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 637 638 // set Content-Type header 639 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 640 if localVarHttpContentType != "" { 641 localVarHeaderParams["Content-Type"] = localVarHttpContentType 642 } 643 644 // to determine the Accept header 645 localVarHttpHeaderAccepts := []string{ 646 } 647 648 // set Accept header 649 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 650 if localVarHttpHeaderAccept != "" { 651 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 652 } 653 // body params 654 localVarPostBody = changeNasVolumeSnapshotConfigurationRequest 655 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 656 if v.IsValid() && v.CanAddr() { 657 ptr := v.Addr().Interface().(**string) 658 if *ptr != nil { 659 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 660 } 661 } 662 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 663 if err != nil { 664 return &successPayload, err 665 } 666 667 localVarHttpResponse, err := a.client.callAPI(r) 668 if err != nil || localVarHttpResponse == nil { 669 return &successPayload, err 670 } 671 defer localVarHttpResponse.Body.Close() 672 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 673 674 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 675 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 676 } 677 678 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 679 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 680 return &successPayload, err 681 } 682 } 683 684 685 return &successPayload, err 686 } 687 688 /* V2ApiService 689 @param changeServerInstanceSpecRequest changeServerInstanceSpecRequest 690 @return *ChangeServerInstanceSpecResponse*/ 691 func (a *V2ApiService) ChangeServerInstanceSpec(changeServerInstanceSpecRequest *ChangeServerInstanceSpecRequest) (*ChangeServerInstanceSpecResponse, error) { 692 var ( 693 localVarHttpMethod = strings.ToUpper("Post") 694 localVarPostBody interface{} 695 localVarFileName string 696 localVarFileBytes []byte 697 successPayload ChangeServerInstanceSpecResponse 698 ) 699 700 // create path and map variables 701 localVarPath := a.client.cfg.BasePath + "/changeServerInstanceSpec" 702 703 localVarHeaderParams := make(map[string]string) 704 localVarQueryParams := url.Values{} 705 localVarFormParams := url.Values{} 706 707 708 // to determine the Content-Type header 709 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 710 711 // set Content-Type header 712 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 713 if localVarHttpContentType != "" { 714 localVarHeaderParams["Content-Type"] = localVarHttpContentType 715 } 716 717 // to determine the Accept header 718 localVarHttpHeaderAccepts := []string{ 719 } 720 721 // set Accept header 722 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 723 if localVarHttpHeaderAccept != "" { 724 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 725 } 726 // body params 727 localVarPostBody = changeServerInstanceSpecRequest 728 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 729 if v.IsValid() && v.CanAddr() { 730 ptr := v.Addr().Interface().(**string) 731 if *ptr != nil { 732 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 733 } 734 } 735 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 736 if err != nil { 737 return &successPayload, err 738 } 739 740 localVarHttpResponse, err := a.client.callAPI(r) 741 if err != nil || localVarHttpResponse == nil { 742 return &successPayload, err 743 } 744 defer localVarHttpResponse.Body.Close() 745 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 746 747 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 748 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 749 } 750 751 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 752 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 753 return &successPayload, err 754 } 755 } 756 757 758 return &successPayload, err 759 } 760 761 /* V2ApiService 762 @param createBlockStorageInstanceRequest createBlockStorageInstanceRequest 763 @return *CreateBlockStorageInstanceResponse*/ 764 func (a *V2ApiService) CreateBlockStorageInstance(createBlockStorageInstanceRequest *CreateBlockStorageInstanceRequest) (*CreateBlockStorageInstanceResponse, error) { 765 var ( 766 localVarHttpMethod = strings.ToUpper("Post") 767 localVarPostBody interface{} 768 localVarFileName string 769 localVarFileBytes []byte 770 successPayload CreateBlockStorageInstanceResponse 771 ) 772 773 // create path and map variables 774 localVarPath := a.client.cfg.BasePath + "/createBlockStorageInstance" 775 776 localVarHeaderParams := make(map[string]string) 777 localVarQueryParams := url.Values{} 778 localVarFormParams := url.Values{} 779 780 781 // to determine the Content-Type header 782 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 783 784 // set Content-Type header 785 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 786 if localVarHttpContentType != "" { 787 localVarHeaderParams["Content-Type"] = localVarHttpContentType 788 } 789 790 // to determine the Accept header 791 localVarHttpHeaderAccepts := []string{ 792 } 793 794 // set Accept header 795 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 796 if localVarHttpHeaderAccept != "" { 797 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 798 } 799 // body params 800 localVarPostBody = createBlockStorageInstanceRequest 801 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 802 if v.IsValid() && v.CanAddr() { 803 ptr := v.Addr().Interface().(**string) 804 if *ptr != nil { 805 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 806 } 807 } 808 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 809 if err != nil { 810 return &successPayload, err 811 } 812 813 localVarHttpResponse, err := a.client.callAPI(r) 814 if err != nil || localVarHttpResponse == nil { 815 return &successPayload, err 816 } 817 defer localVarHttpResponse.Body.Close() 818 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 819 820 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 821 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 822 } 823 824 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 825 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 826 return &successPayload, err 827 } 828 } 829 830 831 return &successPayload, err 832 } 833 834 /* V2ApiService 835 @param createBlockStorageSnapshotInstanceRequest createBlockStorageSnapshotInstanceRequest 836 @return *CreateBlockStorageSnapshotInstanceResponse*/ 837 func (a *V2ApiService) CreateBlockStorageSnapshotInstance(createBlockStorageSnapshotInstanceRequest *CreateBlockStorageSnapshotInstanceRequest) (*CreateBlockStorageSnapshotInstanceResponse, error) { 838 var ( 839 localVarHttpMethod = strings.ToUpper("Post") 840 localVarPostBody interface{} 841 localVarFileName string 842 localVarFileBytes []byte 843 successPayload CreateBlockStorageSnapshotInstanceResponse 844 ) 845 846 // create path and map variables 847 localVarPath := a.client.cfg.BasePath + "/createBlockStorageSnapshotInstance" 848 849 localVarHeaderParams := make(map[string]string) 850 localVarQueryParams := url.Values{} 851 localVarFormParams := url.Values{} 852 853 854 // to determine the Content-Type header 855 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 856 857 // set Content-Type header 858 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 859 if localVarHttpContentType != "" { 860 localVarHeaderParams["Content-Type"] = localVarHttpContentType 861 } 862 863 // to determine the Accept header 864 localVarHttpHeaderAccepts := []string{ 865 } 866 867 // set Accept header 868 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 869 if localVarHttpHeaderAccept != "" { 870 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 871 } 872 // body params 873 localVarPostBody = createBlockStorageSnapshotInstanceRequest 874 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 875 if v.IsValid() && v.CanAddr() { 876 ptr := v.Addr().Interface().(**string) 877 if *ptr != nil { 878 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 879 } 880 } 881 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 882 if err != nil { 883 return &successPayload, err 884 } 885 886 localVarHttpResponse, err := a.client.callAPI(r) 887 if err != nil || localVarHttpResponse == nil { 888 return &successPayload, err 889 } 890 defer localVarHttpResponse.Body.Close() 891 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 892 893 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 894 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 895 } 896 897 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 898 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 899 return &successPayload, err 900 } 901 } 902 903 904 return &successPayload, err 905 } 906 907 /* V2ApiService 908 @param createInstanceTagsRequest createInstanceTagsRequest 909 @return *CreateInstanceTagsResponse*/ 910 func (a *V2ApiService) CreateInstanceTags(createInstanceTagsRequest *CreateInstanceTagsRequest) (*CreateInstanceTagsResponse, error) { 911 var ( 912 localVarHttpMethod = strings.ToUpper("Post") 913 localVarPostBody interface{} 914 localVarFileName string 915 localVarFileBytes []byte 916 successPayload CreateInstanceTagsResponse 917 ) 918 919 // create path and map variables 920 localVarPath := a.client.cfg.BasePath + "/createInstanceTags" 921 922 localVarHeaderParams := make(map[string]string) 923 localVarQueryParams := url.Values{} 924 localVarFormParams := url.Values{} 925 926 927 // to determine the Content-Type header 928 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 929 930 // set Content-Type header 931 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 932 if localVarHttpContentType != "" { 933 localVarHeaderParams["Content-Type"] = localVarHttpContentType 934 } 935 936 // to determine the Accept header 937 localVarHttpHeaderAccepts := []string{ 938 } 939 940 // set Accept header 941 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 942 if localVarHttpHeaderAccept != "" { 943 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 944 } 945 // body params 946 localVarPostBody = createInstanceTagsRequest 947 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 948 if v.IsValid() && v.CanAddr() { 949 ptr := v.Addr().Interface().(**string) 950 if *ptr != nil { 951 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 952 } 953 } 954 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 955 if err != nil { 956 return &successPayload, err 957 } 958 959 localVarHttpResponse, err := a.client.callAPI(r) 960 if err != nil || localVarHttpResponse == nil { 961 return &successPayload, err 962 } 963 defer localVarHttpResponse.Body.Close() 964 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 965 966 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 967 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 968 } 969 970 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 971 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 972 return &successPayload, err 973 } 974 } 975 976 977 return &successPayload, err 978 } 979 980 /* V2ApiService 981 @param createLoginKeyRequest createLoginKeyRequest 982 @return *CreateLoginKeyResponse*/ 983 func (a *V2ApiService) CreateLoginKey(createLoginKeyRequest *CreateLoginKeyRequest) (*CreateLoginKeyResponse, error) { 984 var ( 985 localVarHttpMethod = strings.ToUpper("Post") 986 localVarPostBody interface{} 987 localVarFileName string 988 localVarFileBytes []byte 989 successPayload CreateLoginKeyResponse 990 ) 991 992 // create path and map variables 993 localVarPath := a.client.cfg.BasePath + "/createLoginKey" 994 995 localVarHeaderParams := make(map[string]string) 996 localVarQueryParams := url.Values{} 997 localVarFormParams := url.Values{} 998 999 1000 // to determine the Content-Type header 1001 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1002 1003 // set Content-Type header 1004 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1005 if localVarHttpContentType != "" { 1006 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1007 } 1008 1009 // to determine the Accept header 1010 localVarHttpHeaderAccepts := []string{ 1011 } 1012 1013 // set Accept header 1014 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1015 if localVarHttpHeaderAccept != "" { 1016 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1017 } 1018 // body params 1019 localVarPostBody = createLoginKeyRequest 1020 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1021 if v.IsValid() && v.CanAddr() { 1022 ptr := v.Addr().Interface().(**string) 1023 if *ptr != nil { 1024 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1025 } 1026 } 1027 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1028 if err != nil { 1029 return &successPayload, err 1030 } 1031 1032 localVarHttpResponse, err := a.client.callAPI(r) 1033 if err != nil || localVarHttpResponse == nil { 1034 return &successPayload, err 1035 } 1036 defer localVarHttpResponse.Body.Close() 1037 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1038 1039 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1040 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1041 } 1042 1043 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1044 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1045 return &successPayload, err 1046 } 1047 } 1048 1049 1050 return &successPayload, err 1051 } 1052 1053 /* V2ApiService 1054 @param createMemberServerImageRequest createMemberServerImageRequest 1055 @return *CreateMemberServerImageResponse*/ 1056 func (a *V2ApiService) CreateMemberServerImage(createMemberServerImageRequest *CreateMemberServerImageRequest) (*CreateMemberServerImageResponse, error) { 1057 var ( 1058 localVarHttpMethod = strings.ToUpper("Post") 1059 localVarPostBody interface{} 1060 localVarFileName string 1061 localVarFileBytes []byte 1062 successPayload CreateMemberServerImageResponse 1063 ) 1064 1065 // create path and map variables 1066 localVarPath := a.client.cfg.BasePath + "/createMemberServerImage" 1067 1068 localVarHeaderParams := make(map[string]string) 1069 localVarQueryParams := url.Values{} 1070 localVarFormParams := url.Values{} 1071 1072 1073 // to determine the Content-Type header 1074 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1075 1076 // set Content-Type header 1077 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1078 if localVarHttpContentType != "" { 1079 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1080 } 1081 1082 // to determine the Accept header 1083 localVarHttpHeaderAccepts := []string{ 1084 } 1085 1086 // set Accept header 1087 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1088 if localVarHttpHeaderAccept != "" { 1089 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1090 } 1091 // body params 1092 localVarPostBody = createMemberServerImageRequest 1093 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1094 if v.IsValid() && v.CanAddr() { 1095 ptr := v.Addr().Interface().(**string) 1096 if *ptr != nil { 1097 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1098 } 1099 } 1100 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1101 if err != nil { 1102 return &successPayload, err 1103 } 1104 1105 localVarHttpResponse, err := a.client.callAPI(r) 1106 if err != nil || localVarHttpResponse == nil { 1107 return &successPayload, err 1108 } 1109 defer localVarHttpResponse.Body.Close() 1110 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1111 1112 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1113 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1114 } 1115 1116 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1117 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1118 return &successPayload, err 1119 } 1120 } 1121 1122 1123 return &successPayload, err 1124 } 1125 1126 /* V2ApiService 1127 @param createNasVolumeInstanceRequest createNasVolumeInstanceRequest 1128 @return *CreateNasVolumeInstanceResponse*/ 1129 func (a *V2ApiService) CreateNasVolumeInstance(createNasVolumeInstanceRequest *CreateNasVolumeInstanceRequest) (*CreateNasVolumeInstanceResponse, error) { 1130 var ( 1131 localVarHttpMethod = strings.ToUpper("Post") 1132 localVarPostBody interface{} 1133 localVarFileName string 1134 localVarFileBytes []byte 1135 successPayload CreateNasVolumeInstanceResponse 1136 ) 1137 1138 // create path and map variables 1139 localVarPath := a.client.cfg.BasePath + "/createNasVolumeInstance" 1140 1141 localVarHeaderParams := make(map[string]string) 1142 localVarQueryParams := url.Values{} 1143 localVarFormParams := url.Values{} 1144 1145 1146 // to determine the Content-Type header 1147 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1148 1149 // set Content-Type header 1150 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1151 if localVarHttpContentType != "" { 1152 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1153 } 1154 1155 // to determine the Accept header 1156 localVarHttpHeaderAccepts := []string{ 1157 } 1158 1159 // set Accept header 1160 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1161 if localVarHttpHeaderAccept != "" { 1162 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1163 } 1164 // body params 1165 localVarPostBody = createNasVolumeInstanceRequest 1166 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1167 if v.IsValid() && v.CanAddr() { 1168 ptr := v.Addr().Interface().(**string) 1169 if *ptr != nil { 1170 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1171 } 1172 } 1173 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1174 if err != nil { 1175 return &successPayload, err 1176 } 1177 1178 localVarHttpResponse, err := a.client.callAPI(r) 1179 if err != nil || localVarHttpResponse == nil { 1180 return &successPayload, err 1181 } 1182 defer localVarHttpResponse.Body.Close() 1183 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1184 1185 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1186 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1187 } 1188 1189 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1190 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1191 return &successPayload, err 1192 } 1193 } 1194 1195 1196 return &successPayload, err 1197 } 1198 1199 /* V2ApiService 1200 @param createNasVolumeSnapshotRequest createNasVolumeSnapshotRequest 1201 @return *CreateNasVolumeSnapshotResponse*/ 1202 func (a *V2ApiService) CreateNasVolumeSnapshot(createNasVolumeSnapshotRequest *CreateNasVolumeSnapshotRequest) (*CreateNasVolumeSnapshotResponse, error) { 1203 var ( 1204 localVarHttpMethod = strings.ToUpper("Post") 1205 localVarPostBody interface{} 1206 localVarFileName string 1207 localVarFileBytes []byte 1208 successPayload CreateNasVolumeSnapshotResponse 1209 ) 1210 1211 // create path and map variables 1212 localVarPath := a.client.cfg.BasePath + "/createNasVolumeSnapshot" 1213 1214 localVarHeaderParams := make(map[string]string) 1215 localVarQueryParams := url.Values{} 1216 localVarFormParams := url.Values{} 1217 1218 1219 // to determine the Content-Type header 1220 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1221 1222 // set Content-Type header 1223 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1224 if localVarHttpContentType != "" { 1225 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1226 } 1227 1228 // to determine the Accept header 1229 localVarHttpHeaderAccepts := []string{ 1230 } 1231 1232 // set Accept header 1233 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1234 if localVarHttpHeaderAccept != "" { 1235 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1236 } 1237 // body params 1238 localVarPostBody = createNasVolumeSnapshotRequest 1239 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1240 if v.IsValid() && v.CanAddr() { 1241 ptr := v.Addr().Interface().(**string) 1242 if *ptr != nil { 1243 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1244 } 1245 } 1246 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1247 if err != nil { 1248 return &successPayload, err 1249 } 1250 1251 localVarHttpResponse, err := a.client.callAPI(r) 1252 if err != nil || localVarHttpResponse == nil { 1253 return &successPayload, err 1254 } 1255 defer localVarHttpResponse.Body.Close() 1256 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1257 1258 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1259 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1260 } 1261 1262 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1263 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1264 return &successPayload, err 1265 } 1266 } 1267 1268 1269 return &successPayload, err 1270 } 1271 1272 /* V2ApiService 1273 @param createNetworkInterfaceRequest createNetworkInterfaceRequest 1274 @return *CreateNetworkInterfaceResponse*/ 1275 func (a *V2ApiService) CreateNetworkInterface(createNetworkInterfaceRequest *CreateNetworkInterfaceRequest) (*CreateNetworkInterfaceResponse, error) { 1276 var ( 1277 localVarHttpMethod = strings.ToUpper("Post") 1278 localVarPostBody interface{} 1279 localVarFileName string 1280 localVarFileBytes []byte 1281 successPayload CreateNetworkInterfaceResponse 1282 ) 1283 1284 // create path and map variables 1285 localVarPath := a.client.cfg.BasePath + "/createNetworkInterface" 1286 1287 localVarHeaderParams := make(map[string]string) 1288 localVarQueryParams := url.Values{} 1289 localVarFormParams := url.Values{} 1290 1291 1292 // to determine the Content-Type header 1293 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1294 1295 // set Content-Type header 1296 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1297 if localVarHttpContentType != "" { 1298 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1299 } 1300 1301 // to determine the Accept header 1302 localVarHttpHeaderAccepts := []string{ 1303 } 1304 1305 // set Accept header 1306 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1307 if localVarHttpHeaderAccept != "" { 1308 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1309 } 1310 // body params 1311 localVarPostBody = createNetworkInterfaceRequest 1312 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1313 if v.IsValid() && v.CanAddr() { 1314 ptr := v.Addr().Interface().(**string) 1315 if *ptr != nil { 1316 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1317 } 1318 } 1319 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1320 if err != nil { 1321 return &successPayload, err 1322 } 1323 1324 localVarHttpResponse, err := a.client.callAPI(r) 1325 if err != nil || localVarHttpResponse == nil { 1326 return &successPayload, err 1327 } 1328 defer localVarHttpResponse.Body.Close() 1329 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1330 1331 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1332 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1333 } 1334 1335 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1336 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1337 return &successPayload, err 1338 } 1339 } 1340 1341 1342 return &successPayload, err 1343 } 1344 1345 /* V2ApiService 1346 @param createPublicIpInstanceRequest createPublicIpInstanceRequest 1347 @return *CreatePublicIpInstanceResponse*/ 1348 func (a *V2ApiService) CreatePublicIpInstance(createPublicIpInstanceRequest *CreatePublicIpInstanceRequest) (*CreatePublicIpInstanceResponse, error) { 1349 var ( 1350 localVarHttpMethod = strings.ToUpper("Post") 1351 localVarPostBody interface{} 1352 localVarFileName string 1353 localVarFileBytes []byte 1354 successPayload CreatePublicIpInstanceResponse 1355 ) 1356 1357 // create path and map variables 1358 localVarPath := a.client.cfg.BasePath + "/createPublicIpInstance" 1359 1360 localVarHeaderParams := make(map[string]string) 1361 localVarQueryParams := url.Values{} 1362 localVarFormParams := url.Values{} 1363 1364 1365 // to determine the Content-Type header 1366 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1367 1368 // set Content-Type header 1369 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1370 if localVarHttpContentType != "" { 1371 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1372 } 1373 1374 // to determine the Accept header 1375 localVarHttpHeaderAccepts := []string{ 1376 } 1377 1378 // set Accept header 1379 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1380 if localVarHttpHeaderAccept != "" { 1381 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1382 } 1383 // body params 1384 localVarPostBody = createPublicIpInstanceRequest 1385 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1386 if v.IsValid() && v.CanAddr() { 1387 ptr := v.Addr().Interface().(**string) 1388 if *ptr != nil { 1389 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1390 } 1391 } 1392 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1393 if err != nil { 1394 return &successPayload, err 1395 } 1396 1397 localVarHttpResponse, err := a.client.callAPI(r) 1398 if err != nil || localVarHttpResponse == nil { 1399 return &successPayload, err 1400 } 1401 defer localVarHttpResponse.Body.Close() 1402 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1403 1404 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1405 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1406 } 1407 1408 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1409 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1410 return &successPayload, err 1411 } 1412 } 1413 1414 1415 return &successPayload, err 1416 } 1417 1418 /* V2ApiService 1419 @param createServerInstancesRequest createServerInstancesRequest 1420 @return *CreateServerInstancesResponse*/ 1421 func (a *V2ApiService) CreateServerInstances(createServerInstancesRequest *CreateServerInstancesRequest) (*CreateServerInstancesResponse, error) { 1422 var ( 1423 localVarHttpMethod = strings.ToUpper("Post") 1424 localVarPostBody interface{} 1425 localVarFileName string 1426 localVarFileBytes []byte 1427 successPayload CreateServerInstancesResponse 1428 ) 1429 1430 // create path and map variables 1431 localVarPath := a.client.cfg.BasePath + "/createServerInstances" 1432 1433 localVarHeaderParams := make(map[string]string) 1434 localVarQueryParams := url.Values{} 1435 localVarFormParams := url.Values{} 1436 1437 1438 // to determine the Content-Type header 1439 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1440 1441 // set Content-Type header 1442 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1443 if localVarHttpContentType != "" { 1444 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1445 } 1446 1447 // to determine the Accept header 1448 localVarHttpHeaderAccepts := []string{ 1449 } 1450 1451 // set Accept header 1452 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1453 if localVarHttpHeaderAccept != "" { 1454 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1455 } 1456 // body params 1457 localVarPostBody = createServerInstancesRequest 1458 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1459 if v.IsValid() && v.CanAddr() { 1460 ptr := v.Addr().Interface().(**string) 1461 if *ptr != nil { 1462 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1463 } 1464 } 1465 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1466 if err != nil { 1467 return &successPayload, err 1468 } 1469 1470 localVarHttpResponse, err := a.client.callAPI(r) 1471 if err != nil || localVarHttpResponse == nil { 1472 return &successPayload, err 1473 } 1474 defer localVarHttpResponse.Body.Close() 1475 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1476 1477 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1478 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1479 } 1480 1481 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1482 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1483 return &successPayload, err 1484 } 1485 } 1486 1487 1488 return &successPayload, err 1489 } 1490 1491 /* V2ApiService 1492 @param deleteBlockStorageInstancesRequest deleteBlockStorageInstancesRequest 1493 @return *DeleteBlockStorageInstancesResponse*/ 1494 func (a *V2ApiService) DeleteBlockStorageInstances(deleteBlockStorageInstancesRequest *DeleteBlockStorageInstancesRequest) (*DeleteBlockStorageInstancesResponse, error) { 1495 var ( 1496 localVarHttpMethod = strings.ToUpper("Post") 1497 localVarPostBody interface{} 1498 localVarFileName string 1499 localVarFileBytes []byte 1500 successPayload DeleteBlockStorageInstancesResponse 1501 ) 1502 1503 // create path and map variables 1504 localVarPath := a.client.cfg.BasePath + "/deleteBlockStorageInstances" 1505 1506 localVarHeaderParams := make(map[string]string) 1507 localVarQueryParams := url.Values{} 1508 localVarFormParams := url.Values{} 1509 1510 1511 // to determine the Content-Type header 1512 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1513 1514 // set Content-Type header 1515 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1516 if localVarHttpContentType != "" { 1517 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1518 } 1519 1520 // to determine the Accept header 1521 localVarHttpHeaderAccepts := []string{ 1522 } 1523 1524 // set Accept header 1525 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1526 if localVarHttpHeaderAccept != "" { 1527 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1528 } 1529 // body params 1530 localVarPostBody = deleteBlockStorageInstancesRequest 1531 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1532 if v.IsValid() && v.CanAddr() { 1533 ptr := v.Addr().Interface().(**string) 1534 if *ptr != nil { 1535 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1536 } 1537 } 1538 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1539 if err != nil { 1540 return &successPayload, err 1541 } 1542 1543 localVarHttpResponse, err := a.client.callAPI(r) 1544 if err != nil || localVarHttpResponse == nil { 1545 return &successPayload, err 1546 } 1547 defer localVarHttpResponse.Body.Close() 1548 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1549 1550 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1551 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1552 } 1553 1554 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1555 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1556 return &successPayload, err 1557 } 1558 } 1559 1560 1561 return &successPayload, err 1562 } 1563 1564 /* V2ApiService 1565 @param deleteBlockStorageSnapshotInstancesRequest deleteBlockStorageSnapshotInstancesRequest 1566 @return *DeleteBlockStorageSnapshotInstancesResponse*/ 1567 func (a *V2ApiService) DeleteBlockStorageSnapshotInstances(deleteBlockStorageSnapshotInstancesRequest *DeleteBlockStorageSnapshotInstancesRequest) (*DeleteBlockStorageSnapshotInstancesResponse, error) { 1568 var ( 1569 localVarHttpMethod = strings.ToUpper("Post") 1570 localVarPostBody interface{} 1571 localVarFileName string 1572 localVarFileBytes []byte 1573 successPayload DeleteBlockStorageSnapshotInstancesResponse 1574 ) 1575 1576 // create path and map variables 1577 localVarPath := a.client.cfg.BasePath + "/deleteBlockStorageSnapshotInstances" 1578 1579 localVarHeaderParams := make(map[string]string) 1580 localVarQueryParams := url.Values{} 1581 localVarFormParams := url.Values{} 1582 1583 1584 // to determine the Content-Type header 1585 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1586 1587 // set Content-Type header 1588 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1589 if localVarHttpContentType != "" { 1590 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1591 } 1592 1593 // to determine the Accept header 1594 localVarHttpHeaderAccepts := []string{ 1595 } 1596 1597 // set Accept header 1598 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1599 if localVarHttpHeaderAccept != "" { 1600 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1601 } 1602 // body params 1603 localVarPostBody = deleteBlockStorageSnapshotInstancesRequest 1604 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1605 if v.IsValid() && v.CanAddr() { 1606 ptr := v.Addr().Interface().(**string) 1607 if *ptr != nil { 1608 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1609 } 1610 } 1611 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1612 if err != nil { 1613 return &successPayload, err 1614 } 1615 1616 localVarHttpResponse, err := a.client.callAPI(r) 1617 if err != nil || localVarHttpResponse == nil { 1618 return &successPayload, err 1619 } 1620 defer localVarHttpResponse.Body.Close() 1621 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1622 1623 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1624 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1625 } 1626 1627 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1628 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1629 return &successPayload, err 1630 } 1631 } 1632 1633 1634 return &successPayload, err 1635 } 1636 1637 /* V2ApiService 1638 @param deleteInstanceTagsRequest deleteInstanceTagsRequest 1639 @return *DeleteInstanceTagsResponse*/ 1640 func (a *V2ApiService) DeleteInstanceTags(deleteInstanceTagsRequest *DeleteInstanceTagsRequest) (*DeleteInstanceTagsResponse, error) { 1641 var ( 1642 localVarHttpMethod = strings.ToUpper("Post") 1643 localVarPostBody interface{} 1644 localVarFileName string 1645 localVarFileBytes []byte 1646 successPayload DeleteInstanceTagsResponse 1647 ) 1648 1649 // create path and map variables 1650 localVarPath := a.client.cfg.BasePath + "/deleteInstanceTags" 1651 1652 localVarHeaderParams := make(map[string]string) 1653 localVarQueryParams := url.Values{} 1654 localVarFormParams := url.Values{} 1655 1656 1657 // to determine the Content-Type header 1658 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1659 1660 // set Content-Type header 1661 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1662 if localVarHttpContentType != "" { 1663 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1664 } 1665 1666 // to determine the Accept header 1667 localVarHttpHeaderAccepts := []string{ 1668 } 1669 1670 // set Accept header 1671 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1672 if localVarHttpHeaderAccept != "" { 1673 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1674 } 1675 // body params 1676 localVarPostBody = deleteInstanceTagsRequest 1677 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1678 if v.IsValid() && v.CanAddr() { 1679 ptr := v.Addr().Interface().(**string) 1680 if *ptr != nil { 1681 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1682 } 1683 } 1684 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1685 if err != nil { 1686 return &successPayload, err 1687 } 1688 1689 localVarHttpResponse, err := a.client.callAPI(r) 1690 if err != nil || localVarHttpResponse == nil { 1691 return &successPayload, err 1692 } 1693 defer localVarHttpResponse.Body.Close() 1694 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1695 1696 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1697 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1698 } 1699 1700 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1701 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1702 return &successPayload, err 1703 } 1704 } 1705 1706 1707 return &successPayload, err 1708 } 1709 1710 /* V2ApiService 1711 @param deleteLoginKeyRequest deleteLoginKeyRequest 1712 @return *DeleteLoginKeyResponse*/ 1713 func (a *V2ApiService) DeleteLoginKey(deleteLoginKeyRequest *DeleteLoginKeyRequest) (*DeleteLoginKeyResponse, error) { 1714 var ( 1715 localVarHttpMethod = strings.ToUpper("Post") 1716 localVarPostBody interface{} 1717 localVarFileName string 1718 localVarFileBytes []byte 1719 successPayload DeleteLoginKeyResponse 1720 ) 1721 1722 // create path and map variables 1723 localVarPath := a.client.cfg.BasePath + "/deleteLoginKey" 1724 1725 localVarHeaderParams := make(map[string]string) 1726 localVarQueryParams := url.Values{} 1727 localVarFormParams := url.Values{} 1728 1729 1730 // to determine the Content-Type header 1731 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1732 1733 // set Content-Type header 1734 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1735 if localVarHttpContentType != "" { 1736 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1737 } 1738 1739 // to determine the Accept header 1740 localVarHttpHeaderAccepts := []string{ 1741 } 1742 1743 // set Accept header 1744 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1745 if localVarHttpHeaderAccept != "" { 1746 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1747 } 1748 // body params 1749 localVarPostBody = deleteLoginKeyRequest 1750 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1751 if v.IsValid() && v.CanAddr() { 1752 ptr := v.Addr().Interface().(**string) 1753 if *ptr != nil { 1754 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1755 } 1756 } 1757 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1758 if err != nil { 1759 return &successPayload, err 1760 } 1761 1762 localVarHttpResponse, err := a.client.callAPI(r) 1763 if err != nil || localVarHttpResponse == nil { 1764 return &successPayload, err 1765 } 1766 defer localVarHttpResponse.Body.Close() 1767 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1768 1769 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1770 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1771 } 1772 1773 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1774 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1775 return &successPayload, err 1776 } 1777 } 1778 1779 1780 return &successPayload, err 1781 } 1782 1783 /* V2ApiService 1784 @param deleteMemberServerImagesRequest deleteMemberServerImagesRequest 1785 @return *DeleteMemberServerImagesResponse*/ 1786 func (a *V2ApiService) DeleteMemberServerImages(deleteMemberServerImagesRequest *DeleteMemberServerImagesRequest) (*DeleteMemberServerImagesResponse, error) { 1787 var ( 1788 localVarHttpMethod = strings.ToUpper("Post") 1789 localVarPostBody interface{} 1790 localVarFileName string 1791 localVarFileBytes []byte 1792 successPayload DeleteMemberServerImagesResponse 1793 ) 1794 1795 // create path and map variables 1796 localVarPath := a.client.cfg.BasePath + "/deleteMemberServerImages" 1797 1798 localVarHeaderParams := make(map[string]string) 1799 localVarQueryParams := url.Values{} 1800 localVarFormParams := url.Values{} 1801 1802 1803 // to determine the Content-Type header 1804 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1805 1806 // set Content-Type header 1807 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1808 if localVarHttpContentType != "" { 1809 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1810 } 1811 1812 // to determine the Accept header 1813 localVarHttpHeaderAccepts := []string{ 1814 } 1815 1816 // set Accept header 1817 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1818 if localVarHttpHeaderAccept != "" { 1819 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1820 } 1821 // body params 1822 localVarPostBody = deleteMemberServerImagesRequest 1823 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1824 if v.IsValid() && v.CanAddr() { 1825 ptr := v.Addr().Interface().(**string) 1826 if *ptr != nil { 1827 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1828 } 1829 } 1830 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1831 if err != nil { 1832 return &successPayload, err 1833 } 1834 1835 localVarHttpResponse, err := a.client.callAPI(r) 1836 if err != nil || localVarHttpResponse == nil { 1837 return &successPayload, err 1838 } 1839 defer localVarHttpResponse.Body.Close() 1840 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1841 1842 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1843 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1844 } 1845 1846 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1847 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1848 return &successPayload, err 1849 } 1850 } 1851 1852 1853 return &successPayload, err 1854 } 1855 1856 /* V2ApiService 1857 @param deleteNasVolumeInstanceRequest deleteNasVolumeInstanceRequest 1858 @return *DeleteNasVolumeInstanceResponse*/ 1859 func (a *V2ApiService) DeleteNasVolumeInstance(deleteNasVolumeInstanceRequest *DeleteNasVolumeInstanceRequest) (*DeleteNasVolumeInstanceResponse, error) { 1860 var ( 1861 localVarHttpMethod = strings.ToUpper("Post") 1862 localVarPostBody interface{} 1863 localVarFileName string 1864 localVarFileBytes []byte 1865 successPayload DeleteNasVolumeInstanceResponse 1866 ) 1867 1868 // create path and map variables 1869 localVarPath := a.client.cfg.BasePath + "/deleteNasVolumeInstance" 1870 1871 localVarHeaderParams := make(map[string]string) 1872 localVarQueryParams := url.Values{} 1873 localVarFormParams := url.Values{} 1874 1875 1876 // to determine the Content-Type header 1877 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1878 1879 // set Content-Type header 1880 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1881 if localVarHttpContentType != "" { 1882 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1883 } 1884 1885 // to determine the Accept header 1886 localVarHttpHeaderAccepts := []string{ 1887 } 1888 1889 // set Accept header 1890 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1891 if localVarHttpHeaderAccept != "" { 1892 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1893 } 1894 // body params 1895 localVarPostBody = deleteNasVolumeInstanceRequest 1896 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1897 if v.IsValid() && v.CanAddr() { 1898 ptr := v.Addr().Interface().(**string) 1899 if *ptr != nil { 1900 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1901 } 1902 } 1903 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1904 if err != nil { 1905 return &successPayload, err 1906 } 1907 1908 localVarHttpResponse, err := a.client.callAPI(r) 1909 if err != nil || localVarHttpResponse == nil { 1910 return &successPayload, err 1911 } 1912 defer localVarHttpResponse.Body.Close() 1913 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1914 1915 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1916 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1917 } 1918 1919 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1920 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1921 return &successPayload, err 1922 } 1923 } 1924 1925 1926 return &successPayload, err 1927 } 1928 1929 /* V2ApiService 1930 @param deleteNasVolumeSnapshotRequest deleteNasVolumeSnapshotRequest 1931 @return *DeleteNasVolumeSnapshotResponse*/ 1932 func (a *V2ApiService) DeleteNasVolumeSnapshot(deleteNasVolumeSnapshotRequest *DeleteNasVolumeSnapshotRequest) (*DeleteNasVolumeSnapshotResponse, error) { 1933 var ( 1934 localVarHttpMethod = strings.ToUpper("Post") 1935 localVarPostBody interface{} 1936 localVarFileName string 1937 localVarFileBytes []byte 1938 successPayload DeleteNasVolumeSnapshotResponse 1939 ) 1940 1941 // create path and map variables 1942 localVarPath := a.client.cfg.BasePath + "/deleteNasVolumeSnapshot" 1943 1944 localVarHeaderParams := make(map[string]string) 1945 localVarQueryParams := url.Values{} 1946 localVarFormParams := url.Values{} 1947 1948 1949 // to determine the Content-Type header 1950 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 1951 1952 // set Content-Type header 1953 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1954 if localVarHttpContentType != "" { 1955 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1956 } 1957 1958 // to determine the Accept header 1959 localVarHttpHeaderAccepts := []string{ 1960 } 1961 1962 // set Accept header 1963 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1964 if localVarHttpHeaderAccept != "" { 1965 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1966 } 1967 // body params 1968 localVarPostBody = deleteNasVolumeSnapshotRequest 1969 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 1970 if v.IsValid() && v.CanAddr() { 1971 ptr := v.Addr().Interface().(**string) 1972 if *ptr != nil { 1973 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 1974 } 1975 } 1976 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1977 if err != nil { 1978 return &successPayload, err 1979 } 1980 1981 localVarHttpResponse, err := a.client.callAPI(r) 1982 if err != nil || localVarHttpResponse == nil { 1983 return &successPayload, err 1984 } 1985 defer localVarHttpResponse.Body.Close() 1986 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 1987 1988 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 1989 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 1990 } 1991 1992 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 1993 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 1994 return &successPayload, err 1995 } 1996 } 1997 1998 1999 return &successPayload, err 2000 } 2001 2002 /* V2ApiService 2003 @param deleteNetworkInterfaceRequest deleteNetworkInterfaceRequest 2004 @return *DeleteNetworkInterfaceResponse*/ 2005 func (a *V2ApiService) DeleteNetworkInterface(deleteNetworkInterfaceRequest *DeleteNetworkInterfaceRequest) (*DeleteNetworkInterfaceResponse, error) { 2006 var ( 2007 localVarHttpMethod = strings.ToUpper("Post") 2008 localVarPostBody interface{} 2009 localVarFileName string 2010 localVarFileBytes []byte 2011 successPayload DeleteNetworkInterfaceResponse 2012 ) 2013 2014 // create path and map variables 2015 localVarPath := a.client.cfg.BasePath + "/deleteNetworkInterface" 2016 2017 localVarHeaderParams := make(map[string]string) 2018 localVarQueryParams := url.Values{} 2019 localVarFormParams := url.Values{} 2020 2021 2022 // to determine the Content-Type header 2023 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2024 2025 // set Content-Type header 2026 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2027 if localVarHttpContentType != "" { 2028 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2029 } 2030 2031 // to determine the Accept header 2032 localVarHttpHeaderAccepts := []string{ 2033 } 2034 2035 // set Accept header 2036 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2037 if localVarHttpHeaderAccept != "" { 2038 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2039 } 2040 // body params 2041 localVarPostBody = deleteNetworkInterfaceRequest 2042 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2043 if v.IsValid() && v.CanAddr() { 2044 ptr := v.Addr().Interface().(**string) 2045 if *ptr != nil { 2046 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2047 } 2048 } 2049 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2050 if err != nil { 2051 return &successPayload, err 2052 } 2053 2054 localVarHttpResponse, err := a.client.callAPI(r) 2055 if err != nil || localVarHttpResponse == nil { 2056 return &successPayload, err 2057 } 2058 defer localVarHttpResponse.Body.Close() 2059 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2060 2061 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2062 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2063 } 2064 2065 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2066 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2067 return &successPayload, err 2068 } 2069 } 2070 2071 2072 return &successPayload, err 2073 } 2074 2075 /* V2ApiService 2076 @param deletePortForwardingRulesRequest deletePortForwardingRulesRequest 2077 @return *DeletePortForwardingRulesResponse*/ 2078 func (a *V2ApiService) DeletePortForwardingRules(deletePortForwardingRulesRequest *DeletePortForwardingRulesRequest) (*DeletePortForwardingRulesResponse, error) { 2079 var ( 2080 localVarHttpMethod = strings.ToUpper("Post") 2081 localVarPostBody interface{} 2082 localVarFileName string 2083 localVarFileBytes []byte 2084 successPayload DeletePortForwardingRulesResponse 2085 ) 2086 2087 // create path and map variables 2088 localVarPath := a.client.cfg.BasePath + "/deletePortForwardingRules" 2089 2090 localVarHeaderParams := make(map[string]string) 2091 localVarQueryParams := url.Values{} 2092 localVarFormParams := url.Values{} 2093 2094 2095 // to determine the Content-Type header 2096 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2097 2098 // set Content-Type header 2099 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2100 if localVarHttpContentType != "" { 2101 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2102 } 2103 2104 // to determine the Accept header 2105 localVarHttpHeaderAccepts := []string{ 2106 } 2107 2108 // set Accept header 2109 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2110 if localVarHttpHeaderAccept != "" { 2111 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2112 } 2113 // body params 2114 localVarPostBody = deletePortForwardingRulesRequest 2115 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2116 if v.IsValid() && v.CanAddr() { 2117 ptr := v.Addr().Interface().(**string) 2118 if *ptr != nil { 2119 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2120 } 2121 } 2122 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2123 if err != nil { 2124 return &successPayload, err 2125 } 2126 2127 localVarHttpResponse, err := a.client.callAPI(r) 2128 if err != nil || localVarHttpResponse == nil { 2129 return &successPayload, err 2130 } 2131 defer localVarHttpResponse.Body.Close() 2132 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2133 2134 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2135 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2136 } 2137 2138 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2139 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2140 return &successPayload, err 2141 } 2142 } 2143 2144 2145 return &successPayload, err 2146 } 2147 2148 /* V2ApiService 2149 @param deletePublicIpInstancesRequest deletePublicIpInstancesRequest 2150 @return *DeletePublicIpInstancesResponse*/ 2151 func (a *V2ApiService) DeletePublicIpInstances(deletePublicIpInstancesRequest *DeletePublicIpInstancesRequest) (*DeletePublicIpInstancesResponse, error) { 2152 var ( 2153 localVarHttpMethod = strings.ToUpper("Post") 2154 localVarPostBody interface{} 2155 localVarFileName string 2156 localVarFileBytes []byte 2157 successPayload DeletePublicIpInstancesResponse 2158 ) 2159 2160 // create path and map variables 2161 localVarPath := a.client.cfg.BasePath + "/deletePublicIpInstances" 2162 2163 localVarHeaderParams := make(map[string]string) 2164 localVarQueryParams := url.Values{} 2165 localVarFormParams := url.Values{} 2166 2167 2168 // to determine the Content-Type header 2169 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2170 2171 // set Content-Type header 2172 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2173 if localVarHttpContentType != "" { 2174 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2175 } 2176 2177 // to determine the Accept header 2178 localVarHttpHeaderAccepts := []string{ 2179 } 2180 2181 // set Accept header 2182 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2183 if localVarHttpHeaderAccept != "" { 2184 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2185 } 2186 // body params 2187 localVarPostBody = deletePublicIpInstancesRequest 2188 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2189 if v.IsValid() && v.CanAddr() { 2190 ptr := v.Addr().Interface().(**string) 2191 if *ptr != nil { 2192 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2193 } 2194 } 2195 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2196 if err != nil { 2197 return &successPayload, err 2198 } 2199 2200 localVarHttpResponse, err := a.client.callAPI(r) 2201 if err != nil || localVarHttpResponse == nil { 2202 return &successPayload, err 2203 } 2204 defer localVarHttpResponse.Body.Close() 2205 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2206 2207 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2208 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2209 } 2210 2211 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2212 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2213 return &successPayload, err 2214 } 2215 } 2216 2217 2218 return &successPayload, err 2219 } 2220 2221 /* V2ApiService 2222 @param detachBlockStorageInstancesRequest detachBlockStorageInstancesRequest 2223 @return *DetachBlockStorageInstancesResponse*/ 2224 func (a *V2ApiService) DetachBlockStorageInstances(detachBlockStorageInstancesRequest *DetachBlockStorageInstancesRequest) (*DetachBlockStorageInstancesResponse, error) { 2225 var ( 2226 localVarHttpMethod = strings.ToUpper("Post") 2227 localVarPostBody interface{} 2228 localVarFileName string 2229 localVarFileBytes []byte 2230 successPayload DetachBlockStorageInstancesResponse 2231 ) 2232 2233 // create path and map variables 2234 localVarPath := a.client.cfg.BasePath + "/detachBlockStorageInstances" 2235 2236 localVarHeaderParams := make(map[string]string) 2237 localVarQueryParams := url.Values{} 2238 localVarFormParams := url.Values{} 2239 2240 2241 // to determine the Content-Type header 2242 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2243 2244 // set Content-Type header 2245 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2246 if localVarHttpContentType != "" { 2247 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2248 } 2249 2250 // to determine the Accept header 2251 localVarHttpHeaderAccepts := []string{ 2252 } 2253 2254 // set Accept header 2255 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2256 if localVarHttpHeaderAccept != "" { 2257 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2258 } 2259 // body params 2260 localVarPostBody = detachBlockStorageInstancesRequest 2261 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2262 if v.IsValid() && v.CanAddr() { 2263 ptr := v.Addr().Interface().(**string) 2264 if *ptr != nil { 2265 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2266 } 2267 } 2268 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2269 if err != nil { 2270 return &successPayload, err 2271 } 2272 2273 localVarHttpResponse, err := a.client.callAPI(r) 2274 if err != nil || localVarHttpResponse == nil { 2275 return &successPayload, err 2276 } 2277 defer localVarHttpResponse.Body.Close() 2278 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2279 2280 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2281 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2282 } 2283 2284 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2285 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2286 return &successPayload, err 2287 } 2288 } 2289 2290 2291 return &successPayload, err 2292 } 2293 2294 /* V2ApiService 2295 @param detachNetworkInterfaceRequest detachNetworkInterfaceRequest 2296 @return *DetachNetworkInterfaceResponse*/ 2297 func (a *V2ApiService) DetachNetworkInterface(detachNetworkInterfaceRequest *DetachNetworkInterfaceRequest) (*DetachNetworkInterfaceResponse, error) { 2298 var ( 2299 localVarHttpMethod = strings.ToUpper("Post") 2300 localVarPostBody interface{} 2301 localVarFileName string 2302 localVarFileBytes []byte 2303 successPayload DetachNetworkInterfaceResponse 2304 ) 2305 2306 // create path and map variables 2307 localVarPath := a.client.cfg.BasePath + "/detachNetworkInterface" 2308 2309 localVarHeaderParams := make(map[string]string) 2310 localVarQueryParams := url.Values{} 2311 localVarFormParams := url.Values{} 2312 2313 2314 // to determine the Content-Type header 2315 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2316 2317 // set Content-Type header 2318 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2319 if localVarHttpContentType != "" { 2320 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2321 } 2322 2323 // to determine the Accept header 2324 localVarHttpHeaderAccepts := []string{ 2325 } 2326 2327 // set Accept header 2328 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2329 if localVarHttpHeaderAccept != "" { 2330 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2331 } 2332 // body params 2333 localVarPostBody = detachNetworkInterfaceRequest 2334 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2335 if v.IsValid() && v.CanAddr() { 2336 ptr := v.Addr().Interface().(**string) 2337 if *ptr != nil { 2338 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2339 } 2340 } 2341 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2342 if err != nil { 2343 return &successPayload, err 2344 } 2345 2346 localVarHttpResponse, err := a.client.callAPI(r) 2347 if err != nil || localVarHttpResponse == nil { 2348 return &successPayload, err 2349 } 2350 defer localVarHttpResponse.Body.Close() 2351 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2352 2353 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2354 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2355 } 2356 2357 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2358 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2359 return &successPayload, err 2360 } 2361 } 2362 2363 2364 return &successPayload, err 2365 } 2366 2367 /* V2ApiService 2368 @param disassociatePublicIpFromServerInstanceRequest disassociatePublicIpFromServerInstanceRequest 2369 @return *DisassociatePublicIpFromServerInstanceResponse*/ 2370 func (a *V2ApiService) DisassociatePublicIpFromServerInstance(disassociatePublicIpFromServerInstanceRequest *DisassociatePublicIpFromServerInstanceRequest) (*DisassociatePublicIpFromServerInstanceResponse, error) { 2371 var ( 2372 localVarHttpMethod = strings.ToUpper("Post") 2373 localVarPostBody interface{} 2374 localVarFileName string 2375 localVarFileBytes []byte 2376 successPayload DisassociatePublicIpFromServerInstanceResponse 2377 ) 2378 2379 // create path and map variables 2380 localVarPath := a.client.cfg.BasePath + "/disassociatePublicIpFromServerInstance" 2381 2382 localVarHeaderParams := make(map[string]string) 2383 localVarQueryParams := url.Values{} 2384 localVarFormParams := url.Values{} 2385 2386 2387 // to determine the Content-Type header 2388 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2389 2390 // set Content-Type header 2391 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2392 if localVarHttpContentType != "" { 2393 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2394 } 2395 2396 // to determine the Accept header 2397 localVarHttpHeaderAccepts := []string{ 2398 } 2399 2400 // set Accept header 2401 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2402 if localVarHttpHeaderAccept != "" { 2403 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2404 } 2405 // body params 2406 localVarPostBody = disassociatePublicIpFromServerInstanceRequest 2407 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2408 if v.IsValid() && v.CanAddr() { 2409 ptr := v.Addr().Interface().(**string) 2410 if *ptr != nil { 2411 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2412 } 2413 } 2414 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2415 if err != nil { 2416 return &successPayload, err 2417 } 2418 2419 localVarHttpResponse, err := a.client.callAPI(r) 2420 if err != nil || localVarHttpResponse == nil { 2421 return &successPayload, err 2422 } 2423 defer localVarHttpResponse.Body.Close() 2424 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2425 2426 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2427 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2428 } 2429 2430 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2431 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2432 return &successPayload, err 2433 } 2434 } 2435 2436 2437 return &successPayload, err 2438 } 2439 2440 /* V2ApiService 2441 @param getAccessControlGroupListRequest getAccessControlGroupListRequest 2442 @return *GetAccessControlGroupListResponse*/ 2443 func (a *V2ApiService) GetAccessControlGroupList(getAccessControlGroupListRequest *GetAccessControlGroupListRequest) (*GetAccessControlGroupListResponse, error) { 2444 var ( 2445 localVarHttpMethod = strings.ToUpper("Post") 2446 localVarPostBody interface{} 2447 localVarFileName string 2448 localVarFileBytes []byte 2449 successPayload GetAccessControlGroupListResponse 2450 ) 2451 2452 // create path and map variables 2453 localVarPath := a.client.cfg.BasePath + "/getAccessControlGroupList" 2454 2455 localVarHeaderParams := make(map[string]string) 2456 localVarQueryParams := url.Values{} 2457 localVarFormParams := url.Values{} 2458 2459 2460 // to determine the Content-Type header 2461 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2462 2463 // set Content-Type header 2464 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2465 if localVarHttpContentType != "" { 2466 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2467 } 2468 2469 // to determine the Accept header 2470 localVarHttpHeaderAccepts := []string{ 2471 } 2472 2473 // set Accept header 2474 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2475 if localVarHttpHeaderAccept != "" { 2476 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2477 } 2478 // body params 2479 localVarPostBody = getAccessControlGroupListRequest 2480 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2481 if v.IsValid() && v.CanAddr() { 2482 ptr := v.Addr().Interface().(**string) 2483 if *ptr != nil { 2484 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2485 } 2486 } 2487 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2488 if err != nil { 2489 return &successPayload, err 2490 } 2491 2492 localVarHttpResponse, err := a.client.callAPI(r) 2493 if err != nil || localVarHttpResponse == nil { 2494 return &successPayload, err 2495 } 2496 defer localVarHttpResponse.Body.Close() 2497 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2498 2499 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2500 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2501 } 2502 2503 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2504 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2505 return &successPayload, err 2506 } 2507 } 2508 2509 2510 return &successPayload, err 2511 } 2512 2513 /* V2ApiService 2514 @param getAccessControlGroupServerInstanceListRequest getAccessControlGroupServerInstanceListRequest 2515 @return *GetAccessControlGroupServerInstanceListResponse*/ 2516 func (a *V2ApiService) GetAccessControlGroupServerInstanceList(getAccessControlGroupServerInstanceListRequest *GetAccessControlGroupServerInstanceListRequest) (*GetAccessControlGroupServerInstanceListResponse, error) { 2517 var ( 2518 localVarHttpMethod = strings.ToUpper("Post") 2519 localVarPostBody interface{} 2520 localVarFileName string 2521 localVarFileBytes []byte 2522 successPayload GetAccessControlGroupServerInstanceListResponse 2523 ) 2524 2525 // create path and map variables 2526 localVarPath := a.client.cfg.BasePath + "/getAccessControlGroupServerInstanceList" 2527 2528 localVarHeaderParams := make(map[string]string) 2529 localVarQueryParams := url.Values{} 2530 localVarFormParams := url.Values{} 2531 2532 2533 // to determine the Content-Type header 2534 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2535 2536 // set Content-Type header 2537 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2538 if localVarHttpContentType != "" { 2539 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2540 } 2541 2542 // to determine the Accept header 2543 localVarHttpHeaderAccepts := []string{ 2544 } 2545 2546 // set Accept header 2547 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2548 if localVarHttpHeaderAccept != "" { 2549 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2550 } 2551 // body params 2552 localVarPostBody = getAccessControlGroupServerInstanceListRequest 2553 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2554 if v.IsValid() && v.CanAddr() { 2555 ptr := v.Addr().Interface().(**string) 2556 if *ptr != nil { 2557 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2558 } 2559 } 2560 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2561 if err != nil { 2562 return &successPayload, err 2563 } 2564 2565 localVarHttpResponse, err := a.client.callAPI(r) 2566 if err != nil || localVarHttpResponse == nil { 2567 return &successPayload, err 2568 } 2569 defer localVarHttpResponse.Body.Close() 2570 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2571 2572 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2573 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2574 } 2575 2576 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2577 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2578 return &successPayload, err 2579 } 2580 } 2581 2582 2583 return &successPayload, err 2584 } 2585 2586 /* V2ApiService 2587 @param getAccessControlRuleListRequest getAccessControlRuleListRequest 2588 @return *GetAccessControlRuleListResponse*/ 2589 func (a *V2ApiService) GetAccessControlRuleList(getAccessControlRuleListRequest *GetAccessControlRuleListRequest) (*GetAccessControlRuleListResponse, error) { 2590 var ( 2591 localVarHttpMethod = strings.ToUpper("Post") 2592 localVarPostBody interface{} 2593 localVarFileName string 2594 localVarFileBytes []byte 2595 successPayload GetAccessControlRuleListResponse 2596 ) 2597 2598 // create path and map variables 2599 localVarPath := a.client.cfg.BasePath + "/getAccessControlRuleList" 2600 2601 localVarHeaderParams := make(map[string]string) 2602 localVarQueryParams := url.Values{} 2603 localVarFormParams := url.Values{} 2604 2605 2606 // to determine the Content-Type header 2607 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2608 2609 // set Content-Type header 2610 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2611 if localVarHttpContentType != "" { 2612 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2613 } 2614 2615 // to determine the Accept header 2616 localVarHttpHeaderAccepts := []string{ 2617 } 2618 2619 // set Accept header 2620 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2621 if localVarHttpHeaderAccept != "" { 2622 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2623 } 2624 // body params 2625 localVarPostBody = getAccessControlRuleListRequest 2626 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2627 if v.IsValid() && v.CanAddr() { 2628 ptr := v.Addr().Interface().(**string) 2629 if *ptr != nil { 2630 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2631 } 2632 } 2633 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2634 if err != nil { 2635 return &successPayload, err 2636 } 2637 2638 localVarHttpResponse, err := a.client.callAPI(r) 2639 if err != nil || localVarHttpResponse == nil { 2640 return &successPayload, err 2641 } 2642 defer localVarHttpResponse.Body.Close() 2643 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2644 2645 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2646 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2647 } 2648 2649 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2650 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2651 return &successPayload, err 2652 } 2653 } 2654 2655 2656 return &successPayload, err 2657 } 2658 2659 /* V2ApiService 2660 @param getBlockStorageInstanceListRequest getBlockStorageInstanceListRequest 2661 @return *GetBlockStorageInstanceListResponse*/ 2662 func (a *V2ApiService) GetBlockStorageInstanceList(getBlockStorageInstanceListRequest *GetBlockStorageInstanceListRequest) (*GetBlockStorageInstanceListResponse, error) { 2663 var ( 2664 localVarHttpMethod = strings.ToUpper("Post") 2665 localVarPostBody interface{} 2666 localVarFileName string 2667 localVarFileBytes []byte 2668 successPayload GetBlockStorageInstanceListResponse 2669 ) 2670 2671 // create path and map variables 2672 localVarPath := a.client.cfg.BasePath + "/getBlockStorageInstanceList" 2673 2674 localVarHeaderParams := make(map[string]string) 2675 localVarQueryParams := url.Values{} 2676 localVarFormParams := url.Values{} 2677 2678 2679 // to determine the Content-Type header 2680 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2681 2682 // set Content-Type header 2683 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2684 if localVarHttpContentType != "" { 2685 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2686 } 2687 2688 // to determine the Accept header 2689 localVarHttpHeaderAccepts := []string{ 2690 } 2691 2692 // set Accept header 2693 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2694 if localVarHttpHeaderAccept != "" { 2695 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2696 } 2697 // body params 2698 localVarPostBody = getBlockStorageInstanceListRequest 2699 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2700 if v.IsValid() && v.CanAddr() { 2701 ptr := v.Addr().Interface().(**string) 2702 if *ptr != nil { 2703 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2704 } 2705 } 2706 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2707 if err != nil { 2708 return &successPayload, err 2709 } 2710 2711 localVarHttpResponse, err := a.client.callAPI(r) 2712 if err != nil || localVarHttpResponse == nil { 2713 return &successPayload, err 2714 } 2715 defer localVarHttpResponse.Body.Close() 2716 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2717 2718 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2719 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2720 } 2721 2722 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2723 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2724 return &successPayload, err 2725 } 2726 } 2727 2728 2729 return &successPayload, err 2730 } 2731 2732 /* V2ApiService 2733 @param getBlockStorageSnapshotInstanceListRequest getBlockStorageSnapshotInstanceListRequest 2734 @return *GetBlockStorageSnapshotInstanceListResponse*/ 2735 func (a *V2ApiService) GetBlockStorageSnapshotInstanceList(getBlockStorageSnapshotInstanceListRequest *GetBlockStorageSnapshotInstanceListRequest) (*GetBlockStorageSnapshotInstanceListResponse, error) { 2736 var ( 2737 localVarHttpMethod = strings.ToUpper("Post") 2738 localVarPostBody interface{} 2739 localVarFileName string 2740 localVarFileBytes []byte 2741 successPayload GetBlockStorageSnapshotInstanceListResponse 2742 ) 2743 2744 // create path and map variables 2745 localVarPath := a.client.cfg.BasePath + "/getBlockStorageSnapshotInstanceList" 2746 2747 localVarHeaderParams := make(map[string]string) 2748 localVarQueryParams := url.Values{} 2749 localVarFormParams := url.Values{} 2750 2751 2752 // to determine the Content-Type header 2753 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2754 2755 // set Content-Type header 2756 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2757 if localVarHttpContentType != "" { 2758 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2759 } 2760 2761 // to determine the Accept header 2762 localVarHttpHeaderAccepts := []string{ 2763 } 2764 2765 // set Accept header 2766 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2767 if localVarHttpHeaderAccept != "" { 2768 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2769 } 2770 // body params 2771 localVarPostBody = getBlockStorageSnapshotInstanceListRequest 2772 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2773 if v.IsValid() && v.CanAddr() { 2774 ptr := v.Addr().Interface().(**string) 2775 if *ptr != nil { 2776 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2777 } 2778 } 2779 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2780 if err != nil { 2781 return &successPayload, err 2782 } 2783 2784 localVarHttpResponse, err := a.client.callAPI(r) 2785 if err != nil || localVarHttpResponse == nil { 2786 return &successPayload, err 2787 } 2788 defer localVarHttpResponse.Body.Close() 2789 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2790 2791 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2792 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2793 } 2794 2795 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2796 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2797 return &successPayload, err 2798 } 2799 } 2800 2801 2802 return &successPayload, err 2803 } 2804 2805 /* V2ApiService 2806 @param getInitScriptListRqeust getInitScriptListRqeust 2807 @return *GetInitScriptListResponse*/ 2808 func (a *V2ApiService) GetInitScriptList(getInitScriptListRqeust *GetInitScriptListRequest) (*GetInitScriptListResponse, error) { 2809 var ( 2810 localVarHttpMethod = strings.ToUpper("Post") 2811 localVarPostBody interface{} 2812 localVarFileName string 2813 localVarFileBytes []byte 2814 successPayload GetInitScriptListResponse 2815 ) 2816 2817 // create path and map variables 2818 localVarPath := a.client.cfg.BasePath + "/getInitScriptList" 2819 2820 localVarHeaderParams := make(map[string]string) 2821 localVarQueryParams := url.Values{} 2822 localVarFormParams := url.Values{} 2823 2824 2825 // to determine the Content-Type header 2826 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2827 2828 // set Content-Type header 2829 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2830 if localVarHttpContentType != "" { 2831 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2832 } 2833 2834 // to determine the Accept header 2835 localVarHttpHeaderAccepts := []string{ 2836 } 2837 2838 // set Accept header 2839 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2840 if localVarHttpHeaderAccept != "" { 2841 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2842 } 2843 // body params 2844 localVarPostBody = getInitScriptListRqeust 2845 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2846 if v.IsValid() && v.CanAddr() { 2847 ptr := v.Addr().Interface().(**string) 2848 if *ptr != nil { 2849 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2850 } 2851 } 2852 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2853 if err != nil { 2854 return &successPayload, err 2855 } 2856 2857 localVarHttpResponse, err := a.client.callAPI(r) 2858 if err != nil || localVarHttpResponse == nil { 2859 return &successPayload, err 2860 } 2861 defer localVarHttpResponse.Body.Close() 2862 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2863 2864 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2865 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2866 } 2867 2868 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2869 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2870 return &successPayload, err 2871 } 2872 } 2873 2874 2875 return &successPayload, err 2876 } 2877 2878 /* V2ApiService 2879 @param getInstanceTagListRequest getInstanceTagListRequest 2880 @return *GetInstanceTagListResponse*/ 2881 func (a *V2ApiService) GetInstanceTagList(getInstanceTagListRequest *GetInstanceTagListRequest) (*GetInstanceTagListResponse, error) { 2882 var ( 2883 localVarHttpMethod = strings.ToUpper("Post") 2884 localVarPostBody interface{} 2885 localVarFileName string 2886 localVarFileBytes []byte 2887 successPayload GetInstanceTagListResponse 2888 ) 2889 2890 // create path and map variables 2891 localVarPath := a.client.cfg.BasePath + "/getInstanceTagList" 2892 2893 localVarHeaderParams := make(map[string]string) 2894 localVarQueryParams := url.Values{} 2895 localVarFormParams := url.Values{} 2896 2897 2898 // to determine the Content-Type header 2899 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2900 2901 // set Content-Type header 2902 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2903 if localVarHttpContentType != "" { 2904 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2905 } 2906 2907 // to determine the Accept header 2908 localVarHttpHeaderAccepts := []string{ 2909 } 2910 2911 // set Accept header 2912 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2913 if localVarHttpHeaderAccept != "" { 2914 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2915 } 2916 // body params 2917 localVarPostBody = getInstanceTagListRequest 2918 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2919 if v.IsValid() && v.CanAddr() { 2920 ptr := v.Addr().Interface().(**string) 2921 if *ptr != nil { 2922 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2923 } 2924 } 2925 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2926 if err != nil { 2927 return &successPayload, err 2928 } 2929 2930 localVarHttpResponse, err := a.client.callAPI(r) 2931 if err != nil || localVarHttpResponse == nil { 2932 return &successPayload, err 2933 } 2934 defer localVarHttpResponse.Body.Close() 2935 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 2936 2937 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 2938 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 2939 } 2940 2941 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 2942 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 2943 return &successPayload, err 2944 } 2945 } 2946 2947 2948 return &successPayload, err 2949 } 2950 2951 /* V2ApiService 2952 @param getLoginKeyListRequest getLoginKeyListRequest 2953 @return *GetLoginKeyListResponse*/ 2954 func (a *V2ApiService) GetLoginKeyList(getLoginKeyListRequest *GetLoginKeyListRequest) (*GetLoginKeyListResponse, error) { 2955 var ( 2956 localVarHttpMethod = strings.ToUpper("Post") 2957 localVarPostBody interface{} 2958 localVarFileName string 2959 localVarFileBytes []byte 2960 successPayload GetLoginKeyListResponse 2961 ) 2962 2963 // create path and map variables 2964 localVarPath := a.client.cfg.BasePath + "/getLoginKeyList" 2965 2966 localVarHeaderParams := make(map[string]string) 2967 localVarQueryParams := url.Values{} 2968 localVarFormParams := url.Values{} 2969 2970 2971 // to determine the Content-Type header 2972 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 2973 2974 // set Content-Type header 2975 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2976 if localVarHttpContentType != "" { 2977 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2978 } 2979 2980 // to determine the Accept header 2981 localVarHttpHeaderAccepts := []string{ 2982 } 2983 2984 // set Accept header 2985 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2986 if localVarHttpHeaderAccept != "" { 2987 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2988 } 2989 // body params 2990 localVarPostBody = getLoginKeyListRequest 2991 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 2992 if v.IsValid() && v.CanAddr() { 2993 ptr := v.Addr().Interface().(**string) 2994 if *ptr != nil { 2995 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 2996 } 2997 } 2998 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2999 if err != nil { 3000 return &successPayload, err 3001 } 3002 3003 localVarHttpResponse, err := a.client.callAPI(r) 3004 if err != nil || localVarHttpResponse == nil { 3005 return &successPayload, err 3006 } 3007 defer localVarHttpResponse.Body.Close() 3008 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3009 3010 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3011 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3012 } 3013 3014 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3015 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3016 return &successPayload, err 3017 } 3018 } 3019 3020 3021 return &successPayload, err 3022 } 3023 3024 /* V2ApiService 3025 @param getMemberServerImageListRequest getMemberServerImageListRequest 3026 @return *GetMemberServerImageListResponse*/ 3027 func (a *V2ApiService) GetMemberServerImageList(getMemberServerImageListRequest *GetMemberServerImageListRequest) (*GetMemberServerImageListResponse, error) { 3028 var ( 3029 localVarHttpMethod = strings.ToUpper("Post") 3030 localVarPostBody interface{} 3031 localVarFileName string 3032 localVarFileBytes []byte 3033 successPayload GetMemberServerImageListResponse 3034 ) 3035 3036 // create path and map variables 3037 localVarPath := a.client.cfg.BasePath + "/getMemberServerImageList" 3038 3039 localVarHeaderParams := make(map[string]string) 3040 localVarQueryParams := url.Values{} 3041 localVarFormParams := url.Values{} 3042 3043 3044 // to determine the Content-Type header 3045 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3046 3047 // set Content-Type header 3048 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3049 if localVarHttpContentType != "" { 3050 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3051 } 3052 3053 // to determine the Accept header 3054 localVarHttpHeaderAccepts := []string{ 3055 } 3056 3057 // set Accept header 3058 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3059 if localVarHttpHeaderAccept != "" { 3060 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3061 } 3062 // body params 3063 localVarPostBody = getMemberServerImageListRequest 3064 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3065 if v.IsValid() && v.CanAddr() { 3066 ptr := v.Addr().Interface().(**string) 3067 if *ptr != nil { 3068 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3069 } 3070 } 3071 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3072 if err != nil { 3073 return &successPayload, err 3074 } 3075 3076 localVarHttpResponse, err := a.client.callAPI(r) 3077 if err != nil || localVarHttpResponse == nil { 3078 return &successPayload, err 3079 } 3080 defer localVarHttpResponse.Body.Close() 3081 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3082 3083 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3084 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3085 } 3086 3087 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3088 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3089 return &successPayload, err 3090 } 3091 } 3092 3093 3094 return &successPayload, err 3095 } 3096 3097 /* V2ApiService 3098 @param getNasVolumeAccessControlRuleListRequest getNasVolumeAccessControlRuleListRequest 3099 @return *GetNasVolumeAccessControlRuleListResponse*/ 3100 func (a *V2ApiService) GetNasVolumeAccessControlRuleList(getNasVolumeAccessControlRuleListRequest *GetNasVolumeAccessControlRuleListRequest) (*GetNasVolumeAccessControlRuleListResponse, error) { 3101 var ( 3102 localVarHttpMethod = strings.ToUpper("Post") 3103 localVarPostBody interface{} 3104 localVarFileName string 3105 localVarFileBytes []byte 3106 successPayload GetNasVolumeAccessControlRuleListResponse 3107 ) 3108 3109 // create path and map variables 3110 localVarPath := a.client.cfg.BasePath + "/getNasVolumeAccessControlRuleList" 3111 3112 localVarHeaderParams := make(map[string]string) 3113 localVarQueryParams := url.Values{} 3114 localVarFormParams := url.Values{} 3115 3116 3117 // to determine the Content-Type header 3118 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3119 3120 // set Content-Type header 3121 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3122 if localVarHttpContentType != "" { 3123 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3124 } 3125 3126 // to determine the Accept header 3127 localVarHttpHeaderAccepts := []string{ 3128 } 3129 3130 // set Accept header 3131 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3132 if localVarHttpHeaderAccept != "" { 3133 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3134 } 3135 // body params 3136 localVarPostBody = getNasVolumeAccessControlRuleListRequest 3137 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3138 if v.IsValid() && v.CanAddr() { 3139 ptr := v.Addr().Interface().(**string) 3140 if *ptr != nil { 3141 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3142 } 3143 } 3144 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3145 if err != nil { 3146 return &successPayload, err 3147 } 3148 3149 localVarHttpResponse, err := a.client.callAPI(r) 3150 if err != nil || localVarHttpResponse == nil { 3151 return &successPayload, err 3152 } 3153 defer localVarHttpResponse.Body.Close() 3154 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3155 3156 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3157 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3158 } 3159 3160 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3161 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3162 return &successPayload, err 3163 } 3164 } 3165 3166 3167 return &successPayload, err 3168 } 3169 3170 /* V2ApiService 3171 @param getNasVolumeInstanceListRequest getNasVolumeInstanceListRequest 3172 @return *GetNasVolumeInstanceListResponse*/ 3173 func (a *V2ApiService) GetNasVolumeInstanceList(getNasVolumeInstanceListRequest *GetNasVolumeInstanceListRequest) (*GetNasVolumeInstanceListResponse, error) { 3174 var ( 3175 localVarHttpMethod = strings.ToUpper("Post") 3176 localVarPostBody interface{} 3177 localVarFileName string 3178 localVarFileBytes []byte 3179 successPayload GetNasVolumeInstanceListResponse 3180 ) 3181 3182 // create path and map variables 3183 localVarPath := a.client.cfg.BasePath + "/getNasVolumeInstanceList" 3184 3185 localVarHeaderParams := make(map[string]string) 3186 localVarQueryParams := url.Values{} 3187 localVarFormParams := url.Values{} 3188 3189 3190 // to determine the Content-Type header 3191 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3192 3193 // set Content-Type header 3194 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3195 if localVarHttpContentType != "" { 3196 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3197 } 3198 3199 // to determine the Accept header 3200 localVarHttpHeaderAccepts := []string{ 3201 } 3202 3203 // set Accept header 3204 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3205 if localVarHttpHeaderAccept != "" { 3206 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3207 } 3208 // body params 3209 localVarPostBody = getNasVolumeInstanceListRequest 3210 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3211 if v.IsValid() && v.CanAddr() { 3212 ptr := v.Addr().Interface().(**string) 3213 if *ptr != nil { 3214 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3215 } 3216 } 3217 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3218 if err != nil { 3219 return &successPayload, err 3220 } 3221 3222 localVarHttpResponse, err := a.client.callAPI(r) 3223 if err != nil || localVarHttpResponse == nil { 3224 return &successPayload, err 3225 } 3226 defer localVarHttpResponse.Body.Close() 3227 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3228 3229 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3230 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3231 } 3232 3233 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3234 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3235 return &successPayload, err 3236 } 3237 } 3238 3239 3240 return &successPayload, err 3241 } 3242 3243 /* V2ApiService 3244 @param getNasVolumeInstanceRatingListRequest getNasVolumeInstanceRatingListRequest 3245 @return *GetNasVolumeInstanceRatingListResponse*/ 3246 func (a *V2ApiService) GetNasVolumeInstanceRatingList(getNasVolumeInstanceRatingListRequest *GetNasVolumeInstanceRatingListRequest) (*GetNasVolumeInstanceRatingListResponse, error) { 3247 var ( 3248 localVarHttpMethod = strings.ToUpper("Post") 3249 localVarPostBody interface{} 3250 localVarFileName string 3251 localVarFileBytes []byte 3252 successPayload GetNasVolumeInstanceRatingListResponse 3253 ) 3254 3255 // create path and map variables 3256 localVarPath := a.client.cfg.BasePath + "/getNasVolumeInstanceRatingList" 3257 3258 localVarHeaderParams := make(map[string]string) 3259 localVarQueryParams := url.Values{} 3260 localVarFormParams := url.Values{} 3261 3262 3263 // to determine the Content-Type header 3264 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3265 3266 // set Content-Type header 3267 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3268 if localVarHttpContentType != "" { 3269 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3270 } 3271 3272 // to determine the Accept header 3273 localVarHttpHeaderAccepts := []string{ 3274 } 3275 3276 // set Accept header 3277 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3278 if localVarHttpHeaderAccept != "" { 3279 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3280 } 3281 // body params 3282 localVarPostBody = getNasVolumeInstanceRatingListRequest 3283 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3284 if v.IsValid() && v.CanAddr() { 3285 ptr := v.Addr().Interface().(**string) 3286 if *ptr != nil { 3287 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3288 } 3289 } 3290 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3291 if err != nil { 3292 return &successPayload, err 3293 } 3294 3295 localVarHttpResponse, err := a.client.callAPI(r) 3296 if err != nil || localVarHttpResponse == nil { 3297 return &successPayload, err 3298 } 3299 defer localVarHttpResponse.Body.Close() 3300 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3301 3302 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3303 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3304 } 3305 3306 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3307 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3308 return &successPayload, err 3309 } 3310 } 3311 3312 3313 return &successPayload, err 3314 } 3315 3316 /* V2ApiService 3317 @param getNasVolumeSnapshotConfigurationHistoryListRequest getNasVolumeSnapshotConfigurationHistoryListRequest 3318 @return *GetNasVolumeSnapshotConfigurationHistoryListResponse*/ 3319 func (a *V2ApiService) GetNasVolumeSnapshotConfigurationHistoryList(getNasVolumeSnapshotConfigurationHistoryListRequest *GetNasVolumeSnapshotConfigurationHistoryListRequest) (*GetNasVolumeSnapshotConfigurationHistoryListResponse, error) { 3320 var ( 3321 localVarHttpMethod = strings.ToUpper("Post") 3322 localVarPostBody interface{} 3323 localVarFileName string 3324 localVarFileBytes []byte 3325 successPayload GetNasVolumeSnapshotConfigurationHistoryListResponse 3326 ) 3327 3328 // create path and map variables 3329 localVarPath := a.client.cfg.BasePath + "/getNasVolumeSnapshotConfigurationHistoryList" 3330 3331 localVarHeaderParams := make(map[string]string) 3332 localVarQueryParams := url.Values{} 3333 localVarFormParams := url.Values{} 3334 3335 3336 // to determine the Content-Type header 3337 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3338 3339 // set Content-Type header 3340 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3341 if localVarHttpContentType != "" { 3342 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3343 } 3344 3345 // to determine the Accept header 3346 localVarHttpHeaderAccepts := []string{ 3347 } 3348 3349 // set Accept header 3350 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3351 if localVarHttpHeaderAccept != "" { 3352 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3353 } 3354 // body params 3355 localVarPostBody = getNasVolumeSnapshotConfigurationHistoryListRequest 3356 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3357 if v.IsValid() && v.CanAddr() { 3358 ptr := v.Addr().Interface().(**string) 3359 if *ptr != nil { 3360 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3361 } 3362 } 3363 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3364 if err != nil { 3365 return &successPayload, err 3366 } 3367 3368 localVarHttpResponse, err := a.client.callAPI(r) 3369 if err != nil || localVarHttpResponse == nil { 3370 return &successPayload, err 3371 } 3372 defer localVarHttpResponse.Body.Close() 3373 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3374 3375 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3376 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3377 } 3378 3379 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3380 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3381 return &successPayload, err 3382 } 3383 } 3384 3385 3386 return &successPayload, err 3387 } 3388 3389 /* V2ApiService 3390 @param getNasVolumeSnapshotListRequest getNasVolumeSnapshotListRequest 3391 @return *GetNasVolumeSnapshotListResponse*/ 3392 func (a *V2ApiService) GetNasVolumeSnapshotList(getNasVolumeSnapshotListRequest *GetNasVolumeSnapshotListRequest) (*GetNasVolumeSnapshotListResponse, error) { 3393 var ( 3394 localVarHttpMethod = strings.ToUpper("Post") 3395 localVarPostBody interface{} 3396 localVarFileName string 3397 localVarFileBytes []byte 3398 successPayload GetNasVolumeSnapshotListResponse 3399 ) 3400 3401 // create path and map variables 3402 localVarPath := a.client.cfg.BasePath + "/getNasVolumeSnapshotList" 3403 3404 localVarHeaderParams := make(map[string]string) 3405 localVarQueryParams := url.Values{} 3406 localVarFormParams := url.Values{} 3407 3408 3409 // to determine the Content-Type header 3410 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3411 3412 // set Content-Type header 3413 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3414 if localVarHttpContentType != "" { 3415 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3416 } 3417 3418 // to determine the Accept header 3419 localVarHttpHeaderAccepts := []string{ 3420 } 3421 3422 // set Accept header 3423 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3424 if localVarHttpHeaderAccept != "" { 3425 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3426 } 3427 // body params 3428 localVarPostBody = getNasVolumeSnapshotListRequest 3429 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3430 if v.IsValid() && v.CanAddr() { 3431 ptr := v.Addr().Interface().(**string) 3432 if *ptr != nil { 3433 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3434 } 3435 } 3436 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3437 if err != nil { 3438 return &successPayload, err 3439 } 3440 3441 localVarHttpResponse, err := a.client.callAPI(r) 3442 if err != nil || localVarHttpResponse == nil { 3443 return &successPayload, err 3444 } 3445 defer localVarHttpResponse.Body.Close() 3446 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3447 3448 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3449 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3450 } 3451 3452 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3453 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3454 return &successPayload, err 3455 } 3456 } 3457 3458 3459 return &successPayload, err 3460 } 3461 3462 /* V2ApiService 3463 @param getNetworkInterfaceListRequest getNetworkInterfaceListRequest 3464 @return *GetNetworkInterfaceListResponse*/ 3465 func (a *V2ApiService) GetNetworkInterfaceList(getNetworkInterfaceListRequest *GetNetworkInterfaceListRequest) (*GetNetworkInterfaceListResponse, error) { 3466 var ( 3467 localVarHttpMethod = strings.ToUpper("Post") 3468 localVarPostBody interface{} 3469 localVarFileName string 3470 localVarFileBytes []byte 3471 successPayload GetNetworkInterfaceListResponse 3472 ) 3473 3474 // create path and map variables 3475 localVarPath := a.client.cfg.BasePath + "/getNetworkInterfaceList" 3476 3477 localVarHeaderParams := make(map[string]string) 3478 localVarQueryParams := url.Values{} 3479 localVarFormParams := url.Values{} 3480 3481 3482 // to determine the Content-Type header 3483 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3484 3485 // set Content-Type header 3486 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3487 if localVarHttpContentType != "" { 3488 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3489 } 3490 3491 // to determine the Accept header 3492 localVarHttpHeaderAccepts := []string{ 3493 } 3494 3495 // set Accept header 3496 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3497 if localVarHttpHeaderAccept != "" { 3498 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3499 } 3500 // body params 3501 localVarPostBody = getNetworkInterfaceListRequest 3502 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3503 if v.IsValid() && v.CanAddr() { 3504 ptr := v.Addr().Interface().(**string) 3505 if *ptr != nil { 3506 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3507 } 3508 } 3509 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3510 if err != nil { 3511 return &successPayload, err 3512 } 3513 3514 localVarHttpResponse, err := a.client.callAPI(r) 3515 if err != nil || localVarHttpResponse == nil { 3516 return &successPayload, err 3517 } 3518 defer localVarHttpResponse.Body.Close() 3519 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3520 3521 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3522 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3523 } 3524 3525 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3526 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3527 return &successPayload, err 3528 } 3529 } 3530 3531 3532 return &successPayload, err 3533 } 3534 3535 /* V2ApiService 3536 @param getPortForwardingConfigurationListRequest getPortForwardingConfigurationListRequest 3537 @return *GetPortForwardingConfigurationListResponse*/ 3538 func (a *V2ApiService) GetPortForwardingConfigurationList(getPortForwardingConfigurationListRequest *GetPortForwardingConfigurationListRequest) (*GetPortForwardingConfigurationListResponse, error) { 3539 var ( 3540 localVarHttpMethod = strings.ToUpper("Post") 3541 localVarPostBody interface{} 3542 localVarFileName string 3543 localVarFileBytes []byte 3544 successPayload GetPortForwardingConfigurationListResponse 3545 ) 3546 3547 // create path and map variables 3548 localVarPath := a.client.cfg.BasePath + "/getPortForwardingConfigurationList" 3549 3550 localVarHeaderParams := make(map[string]string) 3551 localVarQueryParams := url.Values{} 3552 localVarFormParams := url.Values{} 3553 3554 3555 // to determine the Content-Type header 3556 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3557 3558 // set Content-Type header 3559 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3560 if localVarHttpContentType != "" { 3561 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3562 } 3563 3564 // to determine the Accept header 3565 localVarHttpHeaderAccepts := []string{ 3566 } 3567 3568 // set Accept header 3569 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3570 if localVarHttpHeaderAccept != "" { 3571 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3572 } 3573 // body params 3574 localVarPostBody = getPortForwardingConfigurationListRequest 3575 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3576 if v.IsValid() && v.CanAddr() { 3577 ptr := v.Addr().Interface().(**string) 3578 if *ptr != nil { 3579 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3580 } 3581 } 3582 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3583 if err != nil { 3584 return &successPayload, err 3585 } 3586 3587 localVarHttpResponse, err := a.client.callAPI(r) 3588 if err != nil || localVarHttpResponse == nil { 3589 return &successPayload, err 3590 } 3591 defer localVarHttpResponse.Body.Close() 3592 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3593 3594 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3595 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3596 } 3597 3598 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3599 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3600 return &successPayload, err 3601 } 3602 } 3603 3604 3605 return &successPayload, err 3606 } 3607 3608 /* V2ApiService 3609 @param getPortForwardingRuleListRequest getPortForwardingRuleListRequest 3610 @return *GetPortForwardingRuleListResponse*/ 3611 func (a *V2ApiService) GetPortForwardingRuleList(getPortForwardingRuleListRequest *GetPortForwardingRuleListRequest) (*GetPortForwardingRuleListResponse, error) { 3612 var ( 3613 localVarHttpMethod = strings.ToUpper("Post") 3614 localVarPostBody interface{} 3615 localVarFileName string 3616 localVarFileBytes []byte 3617 successPayload GetPortForwardingRuleListResponse 3618 ) 3619 3620 // create path and map variables 3621 localVarPath := a.client.cfg.BasePath + "/getPortForwardingRuleList" 3622 3623 localVarHeaderParams := make(map[string]string) 3624 localVarQueryParams := url.Values{} 3625 localVarFormParams := url.Values{} 3626 3627 3628 // to determine the Content-Type header 3629 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3630 3631 // set Content-Type header 3632 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3633 if localVarHttpContentType != "" { 3634 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3635 } 3636 3637 // to determine the Accept header 3638 localVarHttpHeaderAccepts := []string{ 3639 } 3640 3641 // set Accept header 3642 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3643 if localVarHttpHeaderAccept != "" { 3644 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3645 } 3646 // body params 3647 localVarPostBody = getPortForwardingRuleListRequest 3648 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3649 if v.IsValid() && v.CanAddr() { 3650 ptr := v.Addr().Interface().(**string) 3651 if *ptr != nil { 3652 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3653 } 3654 } 3655 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3656 if err != nil { 3657 return &successPayload, err 3658 } 3659 3660 localVarHttpResponse, err := a.client.callAPI(r) 3661 if err != nil || localVarHttpResponse == nil { 3662 return &successPayload, err 3663 } 3664 defer localVarHttpResponse.Body.Close() 3665 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3666 3667 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3668 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3669 } 3670 3671 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3672 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3673 return &successPayload, err 3674 } 3675 } 3676 3677 3678 return &successPayload, err 3679 } 3680 3681 /* V2ApiService 3682 @param getPrivateSubnetInstanceListRequest getPrivateSubnetInstanceListRequest 3683 @return *GetPrivateSubnetInstanceListResponse*/ 3684 func (a *V2ApiService) GetPrivateSubnetInstanceList(getPrivateSubnetInstanceListRequest *GetPrivateSubnetInstanceListRequest) (*GetPrivateSubnetInstanceListResponse, error) { 3685 var ( 3686 localVarHttpMethod = strings.ToUpper("Post") 3687 localVarPostBody interface{} 3688 localVarFileName string 3689 localVarFileBytes []byte 3690 successPayload GetPrivateSubnetInstanceListResponse 3691 ) 3692 3693 // create path and map variables 3694 localVarPath := a.client.cfg.BasePath + "/getPrivateSubnetInstanceList" 3695 3696 localVarHeaderParams := make(map[string]string) 3697 localVarQueryParams := url.Values{} 3698 localVarFormParams := url.Values{} 3699 3700 3701 // to determine the Content-Type header 3702 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3703 3704 // set Content-Type header 3705 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3706 if localVarHttpContentType != "" { 3707 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3708 } 3709 3710 // to determine the Accept header 3711 localVarHttpHeaderAccepts := []string{ 3712 } 3713 3714 // set Accept header 3715 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3716 if localVarHttpHeaderAccept != "" { 3717 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3718 } 3719 // body params 3720 localVarPostBody = getPrivateSubnetInstanceListRequest 3721 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3722 if v.IsValid() && v.CanAddr() { 3723 ptr := v.Addr().Interface().(**string) 3724 if *ptr != nil { 3725 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3726 } 3727 } 3728 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3729 if err != nil { 3730 return &successPayload, err 3731 } 3732 3733 localVarHttpResponse, err := a.client.callAPI(r) 3734 if err != nil || localVarHttpResponse == nil { 3735 return &successPayload, err 3736 } 3737 defer localVarHttpResponse.Body.Close() 3738 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3739 3740 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3741 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3742 } 3743 3744 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3745 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3746 return &successPayload, err 3747 } 3748 } 3749 3750 3751 return &successPayload, err 3752 } 3753 3754 /* V2ApiService 3755 @param getPublicIpInstanceListRequest getPublicIpInstanceListRequest 3756 @return *GetPublicIpInstanceListResponse*/ 3757 func (a *V2ApiService) GetPublicIpInstanceList(getPublicIpInstanceListRequest *GetPublicIpInstanceListRequest) (*GetPublicIpInstanceListResponse, error) { 3758 var ( 3759 localVarHttpMethod = strings.ToUpper("Post") 3760 localVarPostBody interface{} 3761 localVarFileName string 3762 localVarFileBytes []byte 3763 successPayload GetPublicIpInstanceListResponse 3764 ) 3765 3766 // create path and map variables 3767 localVarPath := a.client.cfg.BasePath + "/getPublicIpInstanceList" 3768 3769 localVarHeaderParams := make(map[string]string) 3770 localVarQueryParams := url.Values{} 3771 localVarFormParams := url.Values{} 3772 3773 3774 // to determine the Content-Type header 3775 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3776 3777 // set Content-Type header 3778 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3779 if localVarHttpContentType != "" { 3780 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3781 } 3782 3783 // to determine the Accept header 3784 localVarHttpHeaderAccepts := []string{ 3785 } 3786 3787 // set Accept header 3788 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3789 if localVarHttpHeaderAccept != "" { 3790 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3791 } 3792 // body params 3793 localVarPostBody = getPublicIpInstanceListRequest 3794 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3795 if v.IsValid() && v.CanAddr() { 3796 ptr := v.Addr().Interface().(**string) 3797 if *ptr != nil { 3798 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3799 } 3800 } 3801 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3802 if err != nil { 3803 return &successPayload, err 3804 } 3805 3806 localVarHttpResponse, err := a.client.callAPI(r) 3807 if err != nil || localVarHttpResponse == nil { 3808 return &successPayload, err 3809 } 3810 defer localVarHttpResponse.Body.Close() 3811 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3812 3813 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3814 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3815 } 3816 3817 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3818 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3819 return &successPayload, err 3820 } 3821 } 3822 3823 3824 return &successPayload, err 3825 } 3826 3827 /* V2ApiService 3828 @param getPublicIpTargetServerInstanceListRequest getPublicIpTargetServerInstanceListRequest 3829 @return *GetPublicIpTargetServerInstanceListResponse*/ 3830 func (a *V2ApiService) GetPublicIpTargetServerInstanceList(getPublicIpTargetServerInstanceListRequest *GetPublicIpTargetServerInstanceListRequest) (*GetPublicIpTargetServerInstanceListResponse, error) { 3831 var ( 3832 localVarHttpMethod = strings.ToUpper("Post") 3833 localVarPostBody interface{} 3834 localVarFileName string 3835 localVarFileBytes []byte 3836 successPayload GetPublicIpTargetServerInstanceListResponse 3837 ) 3838 3839 // create path and map variables 3840 localVarPath := a.client.cfg.BasePath + "/getPublicIpTargetServerInstanceList" 3841 3842 localVarHeaderParams := make(map[string]string) 3843 localVarQueryParams := url.Values{} 3844 localVarFormParams := url.Values{} 3845 3846 3847 // to determine the Content-Type header 3848 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3849 3850 // set Content-Type header 3851 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3852 if localVarHttpContentType != "" { 3853 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3854 } 3855 3856 // to determine the Accept header 3857 localVarHttpHeaderAccepts := []string{ 3858 } 3859 3860 // set Accept header 3861 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3862 if localVarHttpHeaderAccept != "" { 3863 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3864 } 3865 // body params 3866 localVarPostBody = getPublicIpTargetServerInstanceListRequest 3867 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3868 if v.IsValid() && v.CanAddr() { 3869 ptr := v.Addr().Interface().(**string) 3870 if *ptr != nil { 3871 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3872 } 3873 } 3874 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3875 if err != nil { 3876 return &successPayload, err 3877 } 3878 3879 localVarHttpResponse, err := a.client.callAPI(r) 3880 if err != nil || localVarHttpResponse == nil { 3881 return &successPayload, err 3882 } 3883 defer localVarHttpResponse.Body.Close() 3884 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3885 3886 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3887 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3888 } 3889 3890 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3891 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3892 return &successPayload, err 3893 } 3894 } 3895 3896 3897 return &successPayload, err 3898 } 3899 3900 /* V2ApiService 3901 @param getRaidListRequest getRaidListRequest 3902 @return *GetRaidListResponse*/ 3903 func (a *V2ApiService) GetRaidList(getRaidListRequest *GetRaidListRequest) (*GetRaidListResponse, error) { 3904 var ( 3905 localVarHttpMethod = strings.ToUpper("Post") 3906 localVarPostBody interface{} 3907 localVarFileName string 3908 localVarFileBytes []byte 3909 successPayload GetRaidListResponse 3910 ) 3911 3912 // create path and map variables 3913 localVarPath := a.client.cfg.BasePath + "/getRaidList" 3914 3915 localVarHeaderParams := make(map[string]string) 3916 localVarQueryParams := url.Values{} 3917 localVarFormParams := url.Values{} 3918 3919 3920 // to determine the Content-Type header 3921 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3922 3923 // set Content-Type header 3924 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3925 if localVarHttpContentType != "" { 3926 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3927 } 3928 3929 // to determine the Accept header 3930 localVarHttpHeaderAccepts := []string{ 3931 } 3932 3933 // set Accept header 3934 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3935 if localVarHttpHeaderAccept != "" { 3936 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3937 } 3938 // body params 3939 localVarPostBody = getRaidListRequest 3940 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 3941 if v.IsValid() && v.CanAddr() { 3942 ptr := v.Addr().Interface().(**string) 3943 if *ptr != nil { 3944 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 3945 } 3946 } 3947 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3948 if err != nil { 3949 return &successPayload, err 3950 } 3951 3952 localVarHttpResponse, err := a.client.callAPI(r) 3953 if err != nil || localVarHttpResponse == nil { 3954 return &successPayload, err 3955 } 3956 defer localVarHttpResponse.Body.Close() 3957 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 3958 3959 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 3960 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 3961 } 3962 3963 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 3964 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 3965 return &successPayload, err 3966 } 3967 } 3968 3969 3970 return &successPayload, err 3971 } 3972 3973 /* V2ApiService 3974 @param getRegionListRequest getRegionListRequest 3975 @return *GetRegionListResponse*/ 3976 func (a *V2ApiService) GetRegionList(getRegionListRequest *GetRegionListRequest) (*GetRegionListResponse, error) { 3977 var ( 3978 localVarHttpMethod = strings.ToUpper("Post") 3979 localVarPostBody interface{} 3980 localVarFileName string 3981 localVarFileBytes []byte 3982 successPayload GetRegionListResponse 3983 ) 3984 3985 // create path and map variables 3986 localVarPath := a.client.cfg.BasePath + "/getRegionList" 3987 3988 localVarHeaderParams := make(map[string]string) 3989 localVarQueryParams := url.Values{} 3990 localVarFormParams := url.Values{} 3991 3992 3993 // to determine the Content-Type header 3994 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 3995 3996 // set Content-Type header 3997 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3998 if localVarHttpContentType != "" { 3999 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4000 } 4001 4002 // to determine the Accept header 4003 localVarHttpHeaderAccepts := []string{ 4004 } 4005 4006 // set Accept header 4007 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4008 if localVarHttpHeaderAccept != "" { 4009 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4010 } 4011 // body params 4012 localVarPostBody = getRegionListRequest 4013 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4014 if v.IsValid() && v.CanAddr() { 4015 ptr := v.Addr().Interface().(**string) 4016 if *ptr != nil { 4017 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4018 } 4019 } 4020 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4021 if err != nil { 4022 return &successPayload, err 4023 } 4024 4025 localVarHttpResponse, err := a.client.callAPI(r) 4026 if err != nil || localVarHttpResponse == nil { 4027 return &successPayload, err 4028 } 4029 defer localVarHttpResponse.Body.Close() 4030 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4031 4032 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4033 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4034 } 4035 4036 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4037 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4038 return &successPayload, err 4039 } 4040 } 4041 4042 4043 return &successPayload, err 4044 } 4045 4046 /* V2ApiService 4047 @param getRootPasswordRequest getRootPasswordRequest 4048 @return *GetRootPasswordResponse*/ 4049 func (a *V2ApiService) GetRootPassword(getRootPasswordRequest *GetRootPasswordRequest) (*GetRootPasswordResponse, error) { 4050 var ( 4051 localVarHttpMethod = strings.ToUpper("Post") 4052 localVarPostBody interface{} 4053 localVarFileName string 4054 localVarFileBytes []byte 4055 successPayload GetRootPasswordResponse 4056 ) 4057 4058 // create path and map variables 4059 localVarPath := a.client.cfg.BasePath + "/getRootPassword" 4060 4061 localVarHeaderParams := make(map[string]string) 4062 localVarQueryParams := url.Values{} 4063 localVarFormParams := url.Values{} 4064 4065 4066 // to determine the Content-Type header 4067 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4068 4069 // set Content-Type header 4070 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4071 if localVarHttpContentType != "" { 4072 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4073 } 4074 4075 // to determine the Accept header 4076 localVarHttpHeaderAccepts := []string{ 4077 } 4078 4079 // set Accept header 4080 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4081 if localVarHttpHeaderAccept != "" { 4082 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4083 } 4084 // body params 4085 localVarPostBody = getRootPasswordRequest 4086 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4087 if v.IsValid() && v.CanAddr() { 4088 ptr := v.Addr().Interface().(**string) 4089 if *ptr != nil { 4090 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4091 } 4092 } 4093 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4094 if err != nil { 4095 return &successPayload, err 4096 } 4097 4098 localVarHttpResponse, err := a.client.callAPI(r) 4099 if err != nil || localVarHttpResponse == nil { 4100 return &successPayload, err 4101 } 4102 defer localVarHttpResponse.Body.Close() 4103 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4104 4105 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4106 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4107 } 4108 4109 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4110 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4111 return &successPayload, err 4112 } 4113 } 4114 4115 4116 return &successPayload, err 4117 } 4118 4119 /* V2ApiService 4120 @param getRootPasswordServerInstanceListRequest getRootPasswordServerInstanceListRequest 4121 @return *GetRootPasswordServerInstanceListResponse*/ 4122 func (a *V2ApiService) GetRootPasswordServerInstanceList(getRootPasswordServerInstanceListRequest *GetRootPasswordServerInstanceListRequest) (*GetRootPasswordServerInstanceListResponse, error) { 4123 var ( 4124 localVarHttpMethod = strings.ToUpper("Post") 4125 localVarPostBody interface{} 4126 localVarFileName string 4127 localVarFileBytes []byte 4128 successPayload GetRootPasswordServerInstanceListResponse 4129 ) 4130 4131 // create path and map variables 4132 localVarPath := a.client.cfg.BasePath + "/getRootPasswordServerInstanceList" 4133 4134 localVarHeaderParams := make(map[string]string) 4135 localVarQueryParams := url.Values{} 4136 localVarFormParams := url.Values{} 4137 4138 4139 // to determine the Content-Type header 4140 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4141 4142 // set Content-Type header 4143 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4144 if localVarHttpContentType != "" { 4145 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4146 } 4147 4148 // to determine the Accept header 4149 localVarHttpHeaderAccepts := []string{ 4150 } 4151 4152 // set Accept header 4153 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4154 if localVarHttpHeaderAccept != "" { 4155 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4156 } 4157 // body params 4158 localVarPostBody = getRootPasswordServerInstanceListRequest 4159 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4160 if v.IsValid() && v.CanAddr() { 4161 ptr := v.Addr().Interface().(**string) 4162 if *ptr != nil { 4163 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4164 } 4165 } 4166 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4167 if err != nil { 4168 return &successPayload, err 4169 } 4170 4171 localVarHttpResponse, err := a.client.callAPI(r) 4172 if err != nil || localVarHttpResponse == nil { 4173 return &successPayload, err 4174 } 4175 defer localVarHttpResponse.Body.Close() 4176 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4177 4178 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4179 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4180 } 4181 4182 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4183 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4184 return &successPayload, err 4185 } 4186 } 4187 4188 4189 return &successPayload, err 4190 } 4191 4192 /* V2ApiService 4193 @param getServerImageProductListRequest getServerImageProductListRequest 4194 @return *GetServerImageProductListResponse*/ 4195 func (a *V2ApiService) GetServerImageProductList(getServerImageProductListRequest *GetServerImageProductListRequest) (*GetServerImageProductListResponse, error) { 4196 var ( 4197 localVarHttpMethod = strings.ToUpper("Post") 4198 localVarPostBody interface{} 4199 localVarFileName string 4200 localVarFileBytes []byte 4201 successPayload GetServerImageProductListResponse 4202 ) 4203 4204 // create path and map variables 4205 localVarPath := a.client.cfg.BasePath + "/getServerImageProductList" 4206 4207 localVarHeaderParams := make(map[string]string) 4208 localVarQueryParams := url.Values{} 4209 localVarFormParams := url.Values{} 4210 4211 4212 // to determine the Content-Type header 4213 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4214 4215 // set Content-Type header 4216 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4217 if localVarHttpContentType != "" { 4218 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4219 } 4220 4221 // to determine the Accept header 4222 localVarHttpHeaderAccepts := []string{ 4223 } 4224 4225 // set Accept header 4226 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4227 if localVarHttpHeaderAccept != "" { 4228 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4229 } 4230 // body params 4231 localVarPostBody = getServerImageProductListRequest 4232 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4233 if v.IsValid() && v.CanAddr() { 4234 ptr := v.Addr().Interface().(**string) 4235 if *ptr != nil { 4236 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4237 } 4238 } 4239 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4240 if err != nil { 4241 return &successPayload, err 4242 } 4243 4244 localVarHttpResponse, err := a.client.callAPI(r) 4245 if err != nil || localVarHttpResponse == nil { 4246 return &successPayload, err 4247 } 4248 defer localVarHttpResponse.Body.Close() 4249 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4250 4251 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4252 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4253 } 4254 4255 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4256 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4257 return &successPayload, err 4258 } 4259 } 4260 4261 4262 return &successPayload, err 4263 } 4264 4265 /* V2ApiService 4266 @param getServerInstanceListRequest getServerInstanceListRequest 4267 @return *GetServerInstanceListResponse*/ 4268 func (a *V2ApiService) GetServerInstanceList(getServerInstanceListRequest *GetServerInstanceListRequest) (*GetServerInstanceListResponse, error) { 4269 var ( 4270 localVarHttpMethod = strings.ToUpper("Post") 4271 localVarPostBody interface{} 4272 localVarFileName string 4273 localVarFileBytes []byte 4274 successPayload GetServerInstanceListResponse 4275 ) 4276 4277 // create path and map variables 4278 localVarPath := a.client.cfg.BasePath + "/getServerInstanceList" 4279 4280 localVarHeaderParams := make(map[string]string) 4281 localVarQueryParams := url.Values{} 4282 localVarFormParams := url.Values{} 4283 4284 4285 // to determine the Content-Type header 4286 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4287 4288 // set Content-Type header 4289 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4290 if localVarHttpContentType != "" { 4291 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4292 } 4293 4294 // to determine the Accept header 4295 localVarHttpHeaderAccepts := []string{ 4296 } 4297 4298 // set Accept header 4299 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4300 if localVarHttpHeaderAccept != "" { 4301 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4302 } 4303 // body params 4304 localVarPostBody = getServerInstanceListRequest 4305 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4306 if v.IsValid() && v.CanAddr() { 4307 ptr := v.Addr().Interface().(**string) 4308 if *ptr != nil { 4309 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4310 } 4311 } 4312 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4313 if err != nil { 4314 return &successPayload, err 4315 } 4316 4317 localVarHttpResponse, err := a.client.callAPI(r) 4318 if err != nil || localVarHttpResponse == nil { 4319 return &successPayload, err 4320 } 4321 defer localVarHttpResponse.Body.Close() 4322 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4323 4324 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4325 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4326 } 4327 4328 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4329 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4330 return &successPayload, err 4331 } 4332 } 4333 4334 4335 return &successPayload, err 4336 } 4337 4338 /* V2ApiService 4339 @param getServerProductListRequest getServerProductListRequest 4340 @return *GetServerProductListResponse*/ 4341 func (a *V2ApiService) GetServerProductList(getServerProductListRequest *GetServerProductListRequest) (*GetServerProductListResponse, error) { 4342 var ( 4343 localVarHttpMethod = strings.ToUpper("Post") 4344 localVarPostBody interface{} 4345 localVarFileName string 4346 localVarFileBytes []byte 4347 successPayload GetServerProductListResponse 4348 ) 4349 4350 // create path and map variables 4351 localVarPath := a.client.cfg.BasePath + "/getServerProductList" 4352 4353 localVarHeaderParams := make(map[string]string) 4354 localVarQueryParams := url.Values{} 4355 localVarFormParams := url.Values{} 4356 4357 4358 // to determine the Content-Type header 4359 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4360 4361 // set Content-Type header 4362 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4363 if localVarHttpContentType != "" { 4364 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4365 } 4366 4367 // to determine the Accept header 4368 localVarHttpHeaderAccepts := []string{ 4369 } 4370 4371 // set Accept header 4372 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4373 if localVarHttpHeaderAccept != "" { 4374 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4375 } 4376 // body params 4377 localVarPostBody = getServerProductListRequest 4378 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4379 if v.IsValid() && v.CanAddr() { 4380 ptr := v.Addr().Interface().(**string) 4381 if *ptr != nil { 4382 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4383 } 4384 } 4385 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4386 if err != nil { 4387 return &successPayload, err 4388 } 4389 4390 localVarHttpResponse, err := a.client.callAPI(r) 4391 if err != nil || localVarHttpResponse == nil { 4392 return &successPayload, err 4393 } 4394 defer localVarHttpResponse.Body.Close() 4395 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4396 4397 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4398 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4399 } 4400 4401 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4402 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4403 return &successPayload, err 4404 } 4405 } 4406 4407 4408 return &successPayload, err 4409 } 4410 4411 /* V2ApiService 4412 @param getZoneListRequest getZoneListRequest 4413 @return *GetZoneListResponse*/ 4414 func (a *V2ApiService) GetZoneList(getZoneListRequest *GetZoneListRequest) (*GetZoneListResponse, error) { 4415 var ( 4416 localVarHttpMethod = strings.ToUpper("Post") 4417 localVarPostBody interface{} 4418 localVarFileName string 4419 localVarFileBytes []byte 4420 successPayload GetZoneListResponse 4421 ) 4422 4423 // create path and map variables 4424 localVarPath := a.client.cfg.BasePath + "/getZoneList" 4425 4426 localVarHeaderParams := make(map[string]string) 4427 localVarQueryParams := url.Values{} 4428 localVarFormParams := url.Values{} 4429 4430 4431 // to determine the Content-Type header 4432 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4433 4434 // set Content-Type header 4435 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4436 if localVarHttpContentType != "" { 4437 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4438 } 4439 4440 // to determine the Accept header 4441 localVarHttpHeaderAccepts := []string{ 4442 } 4443 4444 // set Accept header 4445 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4446 if localVarHttpHeaderAccept != "" { 4447 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4448 } 4449 // body params 4450 localVarPostBody = getZoneListRequest 4451 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4452 if v.IsValid() && v.CanAddr() { 4453 ptr := v.Addr().Interface().(**string) 4454 if *ptr != nil { 4455 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4456 } 4457 } 4458 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4459 if err != nil { 4460 return &successPayload, err 4461 } 4462 4463 localVarHttpResponse, err := a.client.callAPI(r) 4464 if err != nil || localVarHttpResponse == nil { 4465 return &successPayload, err 4466 } 4467 defer localVarHttpResponse.Body.Close() 4468 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4469 4470 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4471 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4472 } 4473 4474 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4475 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4476 return &successPayload, err 4477 } 4478 } 4479 4480 4481 return &successPayload, err 4482 } 4483 4484 /* V2ApiService 4485 @param importLoginKeyRequest importLoginKeyRequest 4486 @return *ImportLoginKeyResponse*/ 4487 func (a *V2ApiService) ImportLoginKey(importLoginKeyRequest *ImportLoginKeyRequest) (*ImportLoginKeyResponse, error) { 4488 var ( 4489 localVarHttpMethod = strings.ToUpper("Post") 4490 localVarPostBody interface{} 4491 localVarFileName string 4492 localVarFileBytes []byte 4493 successPayload ImportLoginKeyResponse 4494 ) 4495 4496 // create path and map variables 4497 localVarPath := a.client.cfg.BasePath + "/importLoginKey" 4498 4499 localVarHeaderParams := make(map[string]string) 4500 localVarQueryParams := url.Values{} 4501 localVarFormParams := url.Values{} 4502 4503 4504 // to determine the Content-Type header 4505 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4506 4507 // set Content-Type header 4508 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4509 if localVarHttpContentType != "" { 4510 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4511 } 4512 4513 // to determine the Accept header 4514 localVarHttpHeaderAccepts := []string{ 4515 } 4516 4517 // set Accept header 4518 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4519 if localVarHttpHeaderAccept != "" { 4520 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4521 } 4522 // body params 4523 localVarPostBody = importLoginKeyRequest 4524 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4525 if v.IsValid() && v.CanAddr() { 4526 ptr := v.Addr().Interface().(**string) 4527 if *ptr != nil { 4528 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4529 } 4530 } 4531 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4532 if err != nil { 4533 return &successPayload, err 4534 } 4535 4536 localVarHttpResponse, err := a.client.callAPI(r) 4537 if err != nil || localVarHttpResponse == nil { 4538 return &successPayload, err 4539 } 4540 defer localVarHttpResponse.Body.Close() 4541 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4542 4543 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4544 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4545 } 4546 4547 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4548 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4549 return &successPayload, err 4550 } 4551 } 4552 4553 4554 return &successPayload, err 4555 } 4556 4557 /* V2ApiService 4558 @param interruptServerInstanceRequest 4559 @return *InterruptServerInstanceResponse*/ 4560 func (a *V2ApiService) InterruptServerInstance(interruptServerInstanceRequest *InterruptServerInstanceRequest) (*InterruptServerInstanceResponse, error) { 4561 var ( 4562 localVarHttpMethod = strings.ToUpper("Post") 4563 localVarPostBody interface{} 4564 localVarFileName string 4565 localVarFileBytes []byte 4566 successPayload InterruptServerInstanceResponse 4567 ) 4568 4569 // create path and map variables 4570 localVarPath := a.client.cfg.BasePath + "/interruptServerInstance" 4571 4572 localVarHeaderParams := make(map[string]string) 4573 localVarQueryParams := url.Values{} 4574 localVarFormParams := url.Values{} 4575 4576 4577 // to determine the Content-Type header 4578 localVarHttpContentTypes := []string{ } 4579 4580 // set Content-Type header 4581 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4582 if localVarHttpContentType != "" { 4583 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4584 } 4585 4586 // to determine the Accept header 4587 localVarHttpHeaderAccepts := []string{ 4588 } 4589 4590 // set Accept header 4591 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4592 if localVarHttpHeaderAccept != "" { 4593 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4594 } 4595 // body params 4596 localVarPostBody = interruptServerInstanceRequest 4597 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4598 if v.IsValid() && v.CanAddr() { 4599 ptr := v.Addr().Interface().(**string) 4600 if *ptr != nil { 4601 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4602 } 4603 } 4604 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4605 if err != nil { 4606 return &successPayload, err 4607 } 4608 4609 localVarHttpResponse, err := a.client.callAPI(r) 4610 if err != nil || localVarHttpResponse == nil { 4611 return &successPayload, err 4612 } 4613 defer localVarHttpResponse.Body.Close() 4614 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4615 4616 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4617 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4618 } 4619 4620 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4621 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4622 return &successPayload, err 4623 } 4624 } 4625 4626 4627 return &successPayload, err 4628 } 4629 4630 /* V2ApiService 4631 @param rebootServerInstancesRequest rebootServerInstancesRequest 4632 @return *RebootServerInstancesResponse*/ 4633 func (a *V2ApiService) RebootServerInstances(rebootServerInstancesRequest *RebootServerInstancesRequest) (*RebootServerInstancesResponse, error) { 4634 var ( 4635 localVarHttpMethod = strings.ToUpper("Post") 4636 localVarPostBody interface{} 4637 localVarFileName string 4638 localVarFileBytes []byte 4639 successPayload RebootServerInstancesResponse 4640 ) 4641 4642 // create path and map variables 4643 localVarPath := a.client.cfg.BasePath + "/rebootServerInstances" 4644 4645 localVarHeaderParams := make(map[string]string) 4646 localVarQueryParams := url.Values{} 4647 localVarFormParams := url.Values{} 4648 4649 4650 // to determine the Content-Type header 4651 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4652 4653 // set Content-Type header 4654 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4655 if localVarHttpContentType != "" { 4656 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4657 } 4658 4659 // to determine the Accept header 4660 localVarHttpHeaderAccepts := []string{ 4661 } 4662 4663 // set Accept header 4664 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4665 if localVarHttpHeaderAccept != "" { 4666 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4667 } 4668 // body params 4669 localVarPostBody = rebootServerInstancesRequest 4670 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4671 if v.IsValid() && v.CanAddr() { 4672 ptr := v.Addr().Interface().(**string) 4673 if *ptr != nil { 4674 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4675 } 4676 } 4677 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4678 if err != nil { 4679 return &successPayload, err 4680 } 4681 4682 localVarHttpResponse, err := a.client.callAPI(r) 4683 if err != nil || localVarHttpResponse == nil { 4684 return &successPayload, err 4685 } 4686 defer localVarHttpResponse.Body.Close() 4687 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4688 4689 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4690 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4691 } 4692 4693 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4694 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4695 return &successPayload, err 4696 } 4697 } 4698 4699 4700 return &successPayload, err 4701 } 4702 4703 /* V2ApiService 4704 @param recreateServerInstanceRequest recreateServerInstanceRequest 4705 @return *RecreateServerInstanceResponse*/ 4706 func (a *V2ApiService) RecreateServerInstance(recreateServerInstanceRequest *RecreateServerInstanceRequest) (*RecreateServerInstanceResponse, error) { 4707 var ( 4708 localVarHttpMethod = strings.ToUpper("Post") 4709 localVarPostBody interface{} 4710 localVarFileName string 4711 localVarFileBytes []byte 4712 successPayload RecreateServerInstanceResponse 4713 ) 4714 4715 // create path and map variables 4716 localVarPath := a.client.cfg.BasePath + "/recreateServerInstance" 4717 4718 localVarHeaderParams := make(map[string]string) 4719 localVarQueryParams := url.Values{} 4720 localVarFormParams := url.Values{} 4721 4722 4723 // to determine the Content-Type header 4724 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4725 4726 // set Content-Type header 4727 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4728 if localVarHttpContentType != "" { 4729 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4730 } 4731 4732 // to determine the Accept header 4733 localVarHttpHeaderAccepts := []string{ 4734 } 4735 4736 // set Accept header 4737 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4738 if localVarHttpHeaderAccept != "" { 4739 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4740 } 4741 // body params 4742 localVarPostBody = recreateServerInstanceRequest 4743 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4744 if v.IsValid() && v.CanAddr() { 4745 ptr := v.Addr().Interface().(**string) 4746 if *ptr != nil { 4747 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4748 } 4749 } 4750 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4751 if err != nil { 4752 return &successPayload, err 4753 } 4754 4755 localVarHttpResponse, err := a.client.callAPI(r) 4756 if err != nil || localVarHttpResponse == nil { 4757 return &successPayload, err 4758 } 4759 defer localVarHttpResponse.Body.Close() 4760 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4761 4762 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4763 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4764 } 4765 4766 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4767 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4768 return &successPayload, err 4769 } 4770 } 4771 4772 4773 return &successPayload, err 4774 } 4775 4776 /* V2ApiService 4777 @param removeMemberServerImageSharingPermissionRequest removeMemberServerImageSharingPermissionRequest 4778 @return *RemoveMemberServerImageSharingPermissionResponse*/ 4779 func (a *V2ApiService) RemoveMemberServerImageSharingPermission(removeMemberServerImageSharingPermissionRequest *RemoveMemberServerImageSharingPermissionRequest) (*RemoveMemberServerImageSharingPermissionResponse, error) { 4780 var ( 4781 localVarHttpMethod = strings.ToUpper("Post") 4782 localVarPostBody interface{} 4783 localVarFileName string 4784 localVarFileBytes []byte 4785 successPayload RemoveMemberServerImageSharingPermissionResponse 4786 ) 4787 4788 // create path and map variables 4789 localVarPath := a.client.cfg.BasePath + "/removeMemberServerImageSharingPermission" 4790 4791 localVarHeaderParams := make(map[string]string) 4792 localVarQueryParams := url.Values{} 4793 localVarFormParams := url.Values{} 4794 4795 4796 // to determine the Content-Type header 4797 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4798 4799 // set Content-Type header 4800 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4801 if localVarHttpContentType != "" { 4802 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4803 } 4804 4805 // to determine the Accept header 4806 localVarHttpHeaderAccepts := []string{ 4807 } 4808 4809 // set Accept header 4810 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4811 if localVarHttpHeaderAccept != "" { 4812 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4813 } 4814 // body params 4815 localVarPostBody = removeMemberServerImageSharingPermissionRequest 4816 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4817 if v.IsValid() && v.CanAddr() { 4818 ptr := v.Addr().Interface().(**string) 4819 if *ptr != nil { 4820 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4821 } 4822 } 4823 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4824 if err != nil { 4825 return &successPayload, err 4826 } 4827 4828 localVarHttpResponse, err := a.client.callAPI(r) 4829 if err != nil || localVarHttpResponse == nil { 4830 return &successPayload, err 4831 } 4832 defer localVarHttpResponse.Body.Close() 4833 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4834 4835 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4836 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4837 } 4838 4839 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4840 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4841 return &successPayload, err 4842 } 4843 } 4844 4845 4846 return &successPayload, err 4847 } 4848 4849 /* V2ApiService 4850 @param removeNasVolumeAccessControlRequest removeNasVolumeAccessControlRequest 4851 @return *RemoveNasVolumeAccessControlResponse*/ 4852 func (a *V2ApiService) RemoveNasVolumeAccessControl(removeNasVolumeAccessControlRequest *RemoveNasVolumeAccessControlRequest) (*RemoveNasVolumeAccessControlResponse, error) { 4853 var ( 4854 localVarHttpMethod = strings.ToUpper("Post") 4855 localVarPostBody interface{} 4856 localVarFileName string 4857 localVarFileBytes []byte 4858 successPayload RemoveNasVolumeAccessControlResponse 4859 ) 4860 4861 // create path and map variables 4862 localVarPath := a.client.cfg.BasePath + "/removeNasVolumeAccessControl" 4863 4864 localVarHeaderParams := make(map[string]string) 4865 localVarQueryParams := url.Values{} 4866 localVarFormParams := url.Values{} 4867 4868 4869 // to determine the Content-Type header 4870 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4871 4872 // set Content-Type header 4873 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4874 if localVarHttpContentType != "" { 4875 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4876 } 4877 4878 // to determine the Accept header 4879 localVarHttpHeaderAccepts := []string{ 4880 } 4881 4882 // set Accept header 4883 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4884 if localVarHttpHeaderAccept != "" { 4885 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4886 } 4887 // body params 4888 localVarPostBody = removeNasVolumeAccessControlRequest 4889 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4890 if v.IsValid() && v.CanAddr() { 4891 ptr := v.Addr().Interface().(**string) 4892 if *ptr != nil { 4893 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4894 } 4895 } 4896 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4897 if err != nil { 4898 return &successPayload, err 4899 } 4900 4901 localVarHttpResponse, err := a.client.callAPI(r) 4902 if err != nil || localVarHttpResponse == nil { 4903 return &successPayload, err 4904 } 4905 defer localVarHttpResponse.Body.Close() 4906 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4907 4908 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4909 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4910 } 4911 4912 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4913 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4914 return &successPayload, err 4915 } 4916 } 4917 4918 4919 return &successPayload, err 4920 } 4921 4922 /* V2ApiService 4923 @param replaceServerInstanceAssociatedWithPublicIpRequest replaceServerInstanceAssociatedWithPublicIpRequest 4924 @return *ReplaceServerInstanceAssociatedWithPublicIpResponse*/ 4925 func (a *V2ApiService) ReplaceServerInstanceAssociatedWithPublicIp(replaceServerInstanceAssociatedWithPublicIpRequest *ReplaceServerInstanceAssociatedWithPublicIpRequest) (*ReplaceServerInstanceAssociatedWithPublicIpResponse, error) { 4926 var ( 4927 localVarHttpMethod = strings.ToUpper("Post") 4928 localVarPostBody interface{} 4929 localVarFileName string 4930 localVarFileBytes []byte 4931 successPayload ReplaceServerInstanceAssociatedWithPublicIpResponse 4932 ) 4933 4934 // create path and map variables 4935 localVarPath := a.client.cfg.BasePath + "/replaceServerInstanceAssociatedWithPublicIp" 4936 4937 localVarHeaderParams := make(map[string]string) 4938 localVarQueryParams := url.Values{} 4939 localVarFormParams := url.Values{} 4940 4941 4942 // to determine the Content-Type header 4943 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 4944 4945 // set Content-Type header 4946 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 4947 if localVarHttpContentType != "" { 4948 localVarHeaderParams["Content-Type"] = localVarHttpContentType 4949 } 4950 4951 // to determine the Accept header 4952 localVarHttpHeaderAccepts := []string{ 4953 } 4954 4955 // set Accept header 4956 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 4957 if localVarHttpHeaderAccept != "" { 4958 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 4959 } 4960 // body params 4961 localVarPostBody = replaceServerInstanceAssociatedWithPublicIpRequest 4962 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 4963 if v.IsValid() && v.CanAddr() { 4964 ptr := v.Addr().Interface().(**string) 4965 if *ptr != nil { 4966 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 4967 } 4968 } 4969 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 4970 if err != nil { 4971 return &successPayload, err 4972 } 4973 4974 localVarHttpResponse, err := a.client.callAPI(r) 4975 if err != nil || localVarHttpResponse == nil { 4976 return &successPayload, err 4977 } 4978 defer localVarHttpResponse.Body.Close() 4979 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 4980 4981 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 4982 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 4983 } 4984 4985 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 4986 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 4987 return &successPayload, err 4988 } 4989 } 4990 4991 4992 return &successPayload, err 4993 } 4994 4995 /* V2ApiService 4996 @param restoreNasVolumeWithSnapshotRequest restoreNasVolumeWithSnapshotRequest 4997 @return *RestoreNasVolumeWithSnapshotResponse*/ 4998 func (a *V2ApiService) RestoreNasVolumeWithSnapshot(restoreNasVolumeWithSnapshotRequest *RestoreNasVolumeWithSnapshotRequest) (*RestoreNasVolumeWithSnapshotResponse, error) { 4999 var ( 5000 localVarHttpMethod = strings.ToUpper("Post") 5001 localVarPostBody interface{} 5002 localVarFileName string 5003 localVarFileBytes []byte 5004 successPayload RestoreNasVolumeWithSnapshotResponse 5005 ) 5006 5007 // create path and map variables 5008 localVarPath := a.client.cfg.BasePath + "/restoreNasVolumeWithSnapshot" 5009 5010 localVarHeaderParams := make(map[string]string) 5011 localVarQueryParams := url.Values{} 5012 localVarFormParams := url.Values{} 5013 5014 5015 // to determine the Content-Type header 5016 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5017 5018 // set Content-Type header 5019 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5020 if localVarHttpContentType != "" { 5021 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5022 } 5023 5024 // to determine the Accept header 5025 localVarHttpHeaderAccepts := []string{ 5026 } 5027 5028 // set Accept header 5029 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5030 if localVarHttpHeaderAccept != "" { 5031 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5032 } 5033 // body params 5034 localVarPostBody = restoreNasVolumeWithSnapshotRequest 5035 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5036 if v.IsValid() && v.CanAddr() { 5037 ptr := v.Addr().Interface().(**string) 5038 if *ptr != nil { 5039 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5040 } 5041 } 5042 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5043 if err != nil { 5044 return &successPayload, err 5045 } 5046 5047 localVarHttpResponse, err := a.client.callAPI(r) 5048 if err != nil || localVarHttpResponse == nil { 5049 return &successPayload, err 5050 } 5051 defer localVarHttpResponse.Body.Close() 5052 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5053 5054 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5055 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5056 } 5057 5058 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5059 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5060 return &successPayload, err 5061 } 5062 } 5063 5064 5065 return &successPayload, err 5066 } 5067 5068 /* V2ApiService 5069 @param setMemberServerImageSharingPermissionRequest setMemberServerImageSharingPermissionRequest 5070 @return *SetMemberServerImageSharingPermissionResponse*/ 5071 func (a *V2ApiService) SetMemberServerImageSharingPermission(setMemberServerImageSharingPermissionRequest *SetMemberServerImageSharingPermissionRequest) (*SetMemberServerImageSharingPermissionResponse, error) { 5072 var ( 5073 localVarHttpMethod = strings.ToUpper("Post") 5074 localVarPostBody interface{} 5075 localVarFileName string 5076 localVarFileBytes []byte 5077 successPayload SetMemberServerImageSharingPermissionResponse 5078 ) 5079 5080 // create path and map variables 5081 localVarPath := a.client.cfg.BasePath + "/setMemberServerImageSharingPermission" 5082 5083 localVarHeaderParams := make(map[string]string) 5084 localVarQueryParams := url.Values{} 5085 localVarFormParams := url.Values{} 5086 5087 5088 // to determine the Content-Type header 5089 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5090 5091 // set Content-Type header 5092 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5093 if localVarHttpContentType != "" { 5094 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5095 } 5096 5097 // to determine the Accept header 5098 localVarHttpHeaderAccepts := []string{ 5099 } 5100 5101 // set Accept header 5102 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5103 if localVarHttpHeaderAccept != "" { 5104 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5105 } 5106 // body params 5107 localVarPostBody = setMemberServerImageSharingPermissionRequest 5108 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5109 if v.IsValid() && v.CanAddr() { 5110 ptr := v.Addr().Interface().(**string) 5111 if *ptr != nil { 5112 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5113 } 5114 } 5115 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5116 if err != nil { 5117 return &successPayload, err 5118 } 5119 5120 localVarHttpResponse, err := a.client.callAPI(r) 5121 if err != nil || localVarHttpResponse == nil { 5122 return &successPayload, err 5123 } 5124 defer localVarHttpResponse.Body.Close() 5125 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5126 5127 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5128 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5129 } 5130 5131 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5132 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5133 return &successPayload, err 5134 } 5135 } 5136 5137 5138 return &successPayload, err 5139 } 5140 5141 /* V2ApiService 5142 @param setNasVolumeAccessControlRequest setNasVolumeAccessControlRequest 5143 @return *SetNasVolumeAccessControlResponse*/ 5144 func (a *V2ApiService) SetNasVolumeAccessControl(setNasVolumeAccessControlRequest *SetNasVolumeAccessControlRequest) (*SetNasVolumeAccessControlResponse, error) { 5145 var ( 5146 localVarHttpMethod = strings.ToUpper("Post") 5147 localVarPostBody interface{} 5148 localVarFileName string 5149 localVarFileBytes []byte 5150 successPayload SetNasVolumeAccessControlResponse 5151 ) 5152 5153 // create path and map variables 5154 localVarPath := a.client.cfg.BasePath + "/setNasVolumeAccessControl" 5155 5156 localVarHeaderParams := make(map[string]string) 5157 localVarQueryParams := url.Values{} 5158 localVarFormParams := url.Values{} 5159 5160 5161 // to determine the Content-Type header 5162 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5163 5164 // set Content-Type header 5165 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5166 if localVarHttpContentType != "" { 5167 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5168 } 5169 5170 // to determine the Accept header 5171 localVarHttpHeaderAccepts := []string{ 5172 } 5173 5174 // set Accept header 5175 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5176 if localVarHttpHeaderAccept != "" { 5177 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5178 } 5179 // body params 5180 localVarPostBody = setNasVolumeAccessControlRequest 5181 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5182 if v.IsValid() && v.CanAddr() { 5183 ptr := v.Addr().Interface().(**string) 5184 if *ptr != nil { 5185 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5186 } 5187 } 5188 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5189 if err != nil { 5190 return &successPayload, err 5191 } 5192 5193 localVarHttpResponse, err := a.client.callAPI(r) 5194 if err != nil || localVarHttpResponse == nil { 5195 return &successPayload, err 5196 } 5197 defer localVarHttpResponse.Body.Close() 5198 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5199 5200 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5201 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5202 } 5203 5204 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5205 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5206 return &successPayload, err 5207 } 5208 } 5209 5210 5211 return &successPayload, err 5212 } 5213 5214 /* V2ApiService 5215 @param setNasVolumeReturnProtectionRequest setNasVolumeReturnProtectionRequest 5216 @return *SetNasVolumeReturnProtectionResponse*/ 5217 func (a *V2ApiService) SetNasVolumeReturnProtection(setNasVolumeReturnProtectionRequest *SetNasVolumeReturnProtectionRequest) (*SetNasVolumeReturnProtectionResponse, error) { 5218 var ( 5219 localVarHttpMethod = strings.ToUpper("Post") 5220 localVarPostBody interface{} 5221 localVarFileName string 5222 localVarFileBytes []byte 5223 successPayload SetNasVolumeReturnProtectionResponse 5224 ) 5225 5226 // create path and map variables 5227 localVarPath := a.client.cfg.BasePath + "/setNasVolumeReturnProtection" 5228 5229 localVarHeaderParams := make(map[string]string) 5230 localVarQueryParams := url.Values{} 5231 localVarFormParams := url.Values{} 5232 5233 5234 // to determine the Content-Type header 5235 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5236 5237 // set Content-Type header 5238 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5239 if localVarHttpContentType != "" { 5240 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5241 } 5242 5243 // to determine the Accept header 5244 localVarHttpHeaderAccepts := []string{ 5245 } 5246 5247 // set Accept header 5248 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5249 if localVarHttpHeaderAccept != "" { 5250 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5251 } 5252 // body params 5253 localVarPostBody = setNasVolumeReturnProtectionRequest 5254 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5255 if v.IsValid() && v.CanAddr() { 5256 ptr := v.Addr().Interface().(**string) 5257 if *ptr != nil { 5258 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5259 } 5260 } 5261 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5262 if err != nil { 5263 return &successPayload, err 5264 } 5265 5266 localVarHttpResponse, err := a.client.callAPI(r) 5267 if err != nil || localVarHttpResponse == nil { 5268 return &successPayload, err 5269 } 5270 defer localVarHttpResponse.Body.Close() 5271 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5272 5273 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5274 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5275 } 5276 5277 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5278 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5279 return &successPayload, err 5280 } 5281 } 5282 5283 5284 return &successPayload, err 5285 } 5286 5287 /* V2ApiService 5288 @param setProtectServerTerminationRequest setProtectServerTerminationRequest 5289 @return *SetProtectServerTerminationResponse*/ 5290 func (a *V2ApiService) SetProtectServerTermination(setProtectServerTerminationRequest *SetProtectServerTerminationRequest) (*SetProtectServerTerminationResponse, error) { 5291 var ( 5292 localVarHttpMethod = strings.ToUpper("Post") 5293 localVarPostBody interface{} 5294 localVarFileName string 5295 localVarFileBytes []byte 5296 successPayload SetProtectServerTerminationResponse 5297 ) 5298 5299 // create path and map variables 5300 localVarPath := a.client.cfg.BasePath + "/setProtectServerTermination" 5301 5302 localVarHeaderParams := make(map[string]string) 5303 localVarQueryParams := url.Values{} 5304 localVarFormParams := url.Values{} 5305 5306 5307 // to determine the Content-Type header 5308 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5309 5310 // set Content-Type header 5311 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5312 if localVarHttpContentType != "" { 5313 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5314 } 5315 5316 // to determine the Accept header 5317 localVarHttpHeaderAccepts := []string{ 5318 } 5319 5320 // set Accept header 5321 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5322 if localVarHttpHeaderAccept != "" { 5323 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5324 } 5325 // body params 5326 localVarPostBody = setProtectServerTerminationRequest 5327 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5328 if v.IsValid() && v.CanAddr() { 5329 ptr := v.Addr().Interface().(**string) 5330 if *ptr != nil { 5331 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5332 } 5333 } 5334 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5335 if err != nil { 5336 return &successPayload, err 5337 } 5338 5339 localVarHttpResponse, err := a.client.callAPI(r) 5340 if err != nil || localVarHttpResponse == nil { 5341 return &successPayload, err 5342 } 5343 defer localVarHttpResponse.Body.Close() 5344 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5345 5346 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5347 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5348 } 5349 5350 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5351 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5352 return &successPayload, err 5353 } 5354 } 5355 5356 5357 return &successPayload, err 5358 } 5359 5360 /* V2ApiService 5361 @param startServerInstancesRequest startServerInstancesRequest 5362 @return *StartServerInstancesResponse*/ 5363 func (a *V2ApiService) StartServerInstances(startServerInstancesRequest *StartServerInstancesRequest) (*StartServerInstancesResponse, error) { 5364 var ( 5365 localVarHttpMethod = strings.ToUpper("Post") 5366 localVarPostBody interface{} 5367 localVarFileName string 5368 localVarFileBytes []byte 5369 successPayload StartServerInstancesResponse 5370 ) 5371 5372 // create path and map variables 5373 localVarPath := a.client.cfg.BasePath + "/startServerInstances" 5374 5375 localVarHeaderParams := make(map[string]string) 5376 localVarQueryParams := url.Values{} 5377 localVarFormParams := url.Values{} 5378 5379 5380 // to determine the Content-Type header 5381 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5382 5383 // set Content-Type header 5384 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5385 if localVarHttpContentType != "" { 5386 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5387 } 5388 5389 // to determine the Accept header 5390 localVarHttpHeaderAccepts := []string{ 5391 } 5392 5393 // set Accept header 5394 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5395 if localVarHttpHeaderAccept != "" { 5396 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5397 } 5398 // body params 5399 localVarPostBody = startServerInstancesRequest 5400 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5401 if v.IsValid() && v.CanAddr() { 5402 ptr := v.Addr().Interface().(**string) 5403 if *ptr != nil { 5404 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5405 } 5406 } 5407 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5408 if err != nil { 5409 return &successPayload, err 5410 } 5411 5412 localVarHttpResponse, err := a.client.callAPI(r) 5413 if err != nil || localVarHttpResponse == nil { 5414 return &successPayload, err 5415 } 5416 defer localVarHttpResponse.Body.Close() 5417 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5418 5419 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5420 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5421 } 5422 5423 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5424 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5425 return &successPayload, err 5426 } 5427 } 5428 5429 5430 return &successPayload, err 5431 } 5432 5433 /* V2ApiService 5434 @param stopServerInstancesRequest stopServerInstancesRequest 5435 @return *StopServerInstancesResponse*/ 5436 func (a *V2ApiService) StopServerInstances(stopServerInstancesRequest *StopServerInstancesRequest) (*StopServerInstancesResponse, error) { 5437 var ( 5438 localVarHttpMethod = strings.ToUpper("Post") 5439 localVarPostBody interface{} 5440 localVarFileName string 5441 localVarFileBytes []byte 5442 successPayload StopServerInstancesResponse 5443 ) 5444 5445 // create path and map variables 5446 localVarPath := a.client.cfg.BasePath + "/stopServerInstances" 5447 5448 localVarHeaderParams := make(map[string]string) 5449 localVarQueryParams := url.Values{} 5450 localVarFormParams := url.Values{} 5451 5452 5453 // to determine the Content-Type header 5454 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5455 5456 // set Content-Type header 5457 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5458 if localVarHttpContentType != "" { 5459 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5460 } 5461 5462 // to determine the Accept header 5463 localVarHttpHeaderAccepts := []string{ 5464 } 5465 5466 // set Accept header 5467 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5468 if localVarHttpHeaderAccept != "" { 5469 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5470 } 5471 // body params 5472 localVarPostBody = stopServerInstancesRequest 5473 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5474 if v.IsValid() && v.CanAddr() { 5475 ptr := v.Addr().Interface().(**string) 5476 if *ptr != nil { 5477 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5478 } 5479 } 5480 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5481 if err != nil { 5482 return &successPayload, err 5483 } 5484 5485 localVarHttpResponse, err := a.client.callAPI(r) 5486 if err != nil || localVarHttpResponse == nil { 5487 return &successPayload, err 5488 } 5489 defer localVarHttpResponse.Body.Close() 5490 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5491 5492 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5493 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5494 } 5495 5496 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5497 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5498 return &successPayload, err 5499 } 5500 } 5501 5502 5503 return &successPayload, err 5504 } 5505 5506 /* V2ApiService 5507 @param terminateServerInstancesRequest terminateServerInstancesRequest 5508 @return *TerminateServerInstancesResponse*/ 5509 func (a *V2ApiService) TerminateServerInstances(terminateServerInstancesRequest *TerminateServerInstancesRequest) (*TerminateServerInstancesResponse, error) { 5510 var ( 5511 localVarHttpMethod = strings.ToUpper("Post") 5512 localVarPostBody interface{} 5513 localVarFileName string 5514 localVarFileBytes []byte 5515 successPayload TerminateServerInstancesResponse 5516 ) 5517 5518 // create path and map variables 5519 localVarPath := a.client.cfg.BasePath + "/terminateServerInstances" 5520 5521 localVarHeaderParams := make(map[string]string) 5522 localVarQueryParams := url.Values{} 5523 localVarFormParams := url.Values{} 5524 5525 5526 // to determine the Content-Type header 5527 localVarHttpContentTypes := []string{ "application/x-www-form-urlencoded", } 5528 5529 // set Content-Type header 5530 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 5531 if localVarHttpContentType != "" { 5532 localVarHeaderParams["Content-Type"] = localVarHttpContentType 5533 } 5534 5535 // to determine the Accept header 5536 localVarHttpHeaderAccepts := []string{ 5537 } 5538 5539 // set Accept header 5540 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 5541 if localVarHttpHeaderAccept != "" { 5542 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 5543 } 5544 // body params 5545 localVarPostBody = terminateServerInstancesRequest 5546 v := reflect.ValueOf(localVarPostBody).Elem().FieldByName("UserData") 5547 if v.IsValid() && v.CanAddr() { 5548 ptr := v.Addr().Interface().(**string) 5549 if *ptr != nil { 5550 **ptr = base64.StdEncoding.EncodeToString([]byte(**ptr)) 5551 } 5552 } 5553 r, err := a.client.prepareRequest(localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 5554 if err != nil { 5555 return &successPayload, err 5556 } 5557 5558 localVarHttpResponse, err := a.client.callAPI(r) 5559 if err != nil || localVarHttpResponse == nil { 5560 return &successPayload, err 5561 } 5562 defer localVarHttpResponse.Body.Close() 5563 bodyBytes, _ := ioutil.ReadAll(localVarHttpResponse.Body) 5564 5565 if localVarHttpResponse.StatusCode >= 300 || (localVarHttpResponse.StatusCode < 300 && !strings.HasPrefix(string(bodyBytes), `{`)) { 5566 return &successPayload, reportError("Status: %v, Body: %s", localVarHttpResponse.Status, bodyBytes) 5567 } 5568 5569 if !strings.Contains(string(bodyBytes), `{"error"`) && strings.HasPrefix(string(bodyBytes), `{`) { 5570 if err = json.Unmarshal(bodyBytes[bytes.IndexAny(bytes.Trim(bodyBytes, "{"), "{"):len(bodyBytes)-1], &successPayload); err != nil { 5571 return &successPayload, err 5572 } 5573 } 5574 5575 5576 return &successPayload, err 5577 } 5578