1package netapp 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/autorest/validation" 14 "github.com/Azure/go-autorest/tracing" 15 "net/http" 16) 17 18// AccountsClient is the microsoft NetApp Files Azure Resource Provider specification 19type AccountsClient struct { 20 BaseClient 21} 22 23// NewAccountsClient creates an instance of the AccountsClient client. 24func NewAccountsClient(subscriptionID string) AccountsClient { 25 return NewAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID) 26} 27 28// NewAccountsClientWithBaseURI creates an instance of the AccountsClient client using a custom endpoint. Use this 29// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 30func NewAccountsClientWithBaseURI(baseURI string, subscriptionID string) AccountsClient { 31 return AccountsClient{NewWithBaseURI(baseURI, subscriptionID)} 32} 33 34// CreateOrUpdate create or update the specified NetApp account within the resource group 35// Parameters: 36// body - netApp Account object supplied in the body of the operation. 37// resourceGroupName - the name of the resource group. 38// accountName - the name of the NetApp account 39func (client AccountsClient) CreateOrUpdate(ctx context.Context, body Account, resourceGroupName string, accountName string) (result AccountsCreateOrUpdateFuture, err error) { 40 if tracing.IsEnabled() { 41 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.CreateOrUpdate") 42 defer func() { 43 sc := -1 44 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 45 sc = result.FutureAPI.Response().StatusCode 46 } 47 tracing.EndSpan(ctx, sc, err) 48 }() 49 } 50 if err := validation.Validate([]validation.Validation{ 51 {TargetValue: body, 52 Constraints: []validation.Constraint{{Target: "body.Location", Name: validation.Null, Rule: true, Chain: nil}}}, 53 {TargetValue: resourceGroupName, 54 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 55 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 56 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 57 return result, validation.NewError("netapp.AccountsClient", "CreateOrUpdate", err.Error()) 58 } 59 60 req, err := client.CreateOrUpdatePreparer(ctx, body, resourceGroupName, accountName) 61 if err != nil { 62 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "CreateOrUpdate", nil, "Failure preparing request") 63 return 64 } 65 66 result, err = client.CreateOrUpdateSender(req) 67 if err != nil { 68 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "CreateOrUpdate", nil, "Failure sending request") 69 return 70 } 71 72 return 73} 74 75// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 76func (client AccountsClient) CreateOrUpdatePreparer(ctx context.Context, body Account, resourceGroupName string, accountName string) (*http.Request, error) { 77 pathParameters := map[string]interface{}{ 78 "accountName": autorest.Encode("path", accountName), 79 "resourceGroupName": autorest.Encode("path", resourceGroupName), 80 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 81 } 82 83 const APIVersion = "2021-06-01" 84 queryParameters := map[string]interface{}{ 85 "api-version": APIVersion, 86 } 87 88 body.ID = nil 89 body.Name = nil 90 body.Etag = nil 91 body.Type = nil 92 body.SystemData = nil 93 preparer := autorest.CreatePreparer( 94 autorest.AsContentType("application/json; charset=utf-8"), 95 autorest.AsPut(), 96 autorest.WithBaseURL(client.BaseURI), 97 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}", pathParameters), 98 autorest.WithJSON(body), 99 autorest.WithQueryParameters(queryParameters)) 100 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 101} 102 103// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 104// http.Response Body if it receives an error. 105func (client AccountsClient) CreateOrUpdateSender(req *http.Request) (future AccountsCreateOrUpdateFuture, err error) { 106 var resp *http.Response 107 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 108 if err != nil { 109 return 110 } 111 var azf azure.Future 112 azf, err = azure.NewFutureFromResponse(resp) 113 future.FutureAPI = &azf 114 future.Result = future.result 115 return 116} 117 118// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 119// closes the http.Response Body. 120func (client AccountsClient) CreateOrUpdateResponder(resp *http.Response) (result Account, err error) { 121 err = autorest.Respond( 122 resp, 123 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 124 autorest.ByUnmarshallingJSON(&result), 125 autorest.ByClosing()) 126 result.Response = autorest.Response{Response: resp} 127 return 128} 129 130// Delete delete the specified NetApp account 131// Parameters: 132// resourceGroupName - the name of the resource group. 133// accountName - the name of the NetApp account 134func (client AccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result AccountsDeleteFuture, err error) { 135 if tracing.IsEnabled() { 136 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Delete") 137 defer func() { 138 sc := -1 139 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 140 sc = result.FutureAPI.Response().StatusCode 141 } 142 tracing.EndSpan(ctx, sc, err) 143 }() 144 } 145 if err := validation.Validate([]validation.Validation{ 146 {TargetValue: resourceGroupName, 147 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 148 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 149 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 150 return result, validation.NewError("netapp.AccountsClient", "Delete", err.Error()) 151 } 152 153 req, err := client.DeletePreparer(ctx, resourceGroupName, accountName) 154 if err != nil { 155 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "Delete", nil, "Failure preparing request") 156 return 157 } 158 159 result, err = client.DeleteSender(req) 160 if err != nil { 161 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "Delete", nil, "Failure sending request") 162 return 163 } 164 165 return 166} 167 168// DeletePreparer prepares the Delete request. 169func (client AccountsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) { 170 pathParameters := map[string]interface{}{ 171 "accountName": autorest.Encode("path", accountName), 172 "resourceGroupName": autorest.Encode("path", resourceGroupName), 173 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 174 } 175 176 const APIVersion = "2021-06-01" 177 queryParameters := map[string]interface{}{ 178 "api-version": APIVersion, 179 } 180 181 preparer := autorest.CreatePreparer( 182 autorest.AsDelete(), 183 autorest.WithBaseURL(client.BaseURI), 184 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}", pathParameters), 185 autorest.WithQueryParameters(queryParameters)) 186 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 187} 188 189// DeleteSender sends the Delete request. The method will close the 190// http.Response Body if it receives an error. 191func (client AccountsClient) DeleteSender(req *http.Request) (future AccountsDeleteFuture, err error) { 192 var resp *http.Response 193 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 194 if err != nil { 195 return 196 } 197 var azf azure.Future 198 azf, err = azure.NewFutureFromResponse(resp) 199 future.FutureAPI = &azf 200 future.Result = future.result 201 return 202} 203 204// DeleteResponder handles the response to the Delete request. The method always 205// closes the http.Response Body. 206func (client AccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 207 err = autorest.Respond( 208 resp, 209 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 210 autorest.ByClosing()) 211 result.Response = resp 212 return 213} 214 215// Get get the NetApp account 216// Parameters: 217// resourceGroupName - the name of the resource group. 218// accountName - the name of the NetApp account 219func (client AccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result Account, err error) { 220 if tracing.IsEnabled() { 221 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Get") 222 defer func() { 223 sc := -1 224 if result.Response.Response != nil { 225 sc = result.Response.Response.StatusCode 226 } 227 tracing.EndSpan(ctx, sc, err) 228 }() 229 } 230 if err := validation.Validate([]validation.Validation{ 231 {TargetValue: resourceGroupName, 232 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 233 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 234 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 235 return result, validation.NewError("netapp.AccountsClient", "Get", err.Error()) 236 } 237 238 req, err := client.GetPreparer(ctx, resourceGroupName, accountName) 239 if err != nil { 240 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "Get", nil, "Failure preparing request") 241 return 242 } 243 244 resp, err := client.GetSender(req) 245 if err != nil { 246 result.Response = autorest.Response{Response: resp} 247 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "Get", resp, "Failure sending request") 248 return 249 } 250 251 result, err = client.GetResponder(resp) 252 if err != nil { 253 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "Get", resp, "Failure responding to request") 254 return 255 } 256 257 return 258} 259 260// GetPreparer prepares the Get request. 261func (client AccountsClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) { 262 pathParameters := map[string]interface{}{ 263 "accountName": autorest.Encode("path", accountName), 264 "resourceGroupName": autorest.Encode("path", resourceGroupName), 265 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 266 } 267 268 const APIVersion = "2021-06-01" 269 queryParameters := map[string]interface{}{ 270 "api-version": APIVersion, 271 } 272 273 preparer := autorest.CreatePreparer( 274 autorest.AsGet(), 275 autorest.WithBaseURL(client.BaseURI), 276 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}", pathParameters), 277 autorest.WithQueryParameters(queryParameters)) 278 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 279} 280 281// GetSender sends the Get request. The method will close the 282// http.Response Body if it receives an error. 283func (client AccountsClient) GetSender(req *http.Request) (*http.Response, error) { 284 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 285} 286 287// GetResponder handles the response to the Get request. The method always 288// closes the http.Response Body. 289func (client AccountsClient) GetResponder(resp *http.Response) (result Account, err error) { 290 err = autorest.Respond( 291 resp, 292 azure.WithErrorUnlessStatusCode(http.StatusOK), 293 autorest.ByUnmarshallingJSON(&result), 294 autorest.ByClosing()) 295 result.Response = autorest.Response{Response: resp} 296 return 297} 298 299// List list and describe all NetApp accounts in the resource group. 300// Parameters: 301// resourceGroupName - the name of the resource group. 302func (client AccountsClient) List(ctx context.Context, resourceGroupName string) (result AccountListPage, err error) { 303 if tracing.IsEnabled() { 304 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.List") 305 defer func() { 306 sc := -1 307 if result.al.Response.Response != nil { 308 sc = result.al.Response.Response.StatusCode 309 } 310 tracing.EndSpan(ctx, sc, err) 311 }() 312 } 313 if err := validation.Validate([]validation.Validation{ 314 {TargetValue: resourceGroupName, 315 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 316 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 317 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 318 return result, validation.NewError("netapp.AccountsClient", "List", err.Error()) 319 } 320 321 result.fn = client.listNextResults 322 req, err := client.ListPreparer(ctx, resourceGroupName) 323 if err != nil { 324 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "List", nil, "Failure preparing request") 325 return 326 } 327 328 resp, err := client.ListSender(req) 329 if err != nil { 330 result.al.Response = autorest.Response{Response: resp} 331 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "List", resp, "Failure sending request") 332 return 333 } 334 335 result.al, err = client.ListResponder(resp) 336 if err != nil { 337 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "List", resp, "Failure responding to request") 338 return 339 } 340 if result.al.hasNextLink() && result.al.IsEmpty() { 341 err = result.NextWithContext(ctx) 342 return 343 } 344 345 return 346} 347 348// ListPreparer prepares the List request. 349func (client AccountsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 350 pathParameters := map[string]interface{}{ 351 "resourceGroupName": autorest.Encode("path", resourceGroupName), 352 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 353 } 354 355 const APIVersion = "2021-06-01" 356 queryParameters := map[string]interface{}{ 357 "api-version": APIVersion, 358 } 359 360 preparer := autorest.CreatePreparer( 361 autorest.AsGet(), 362 autorest.WithBaseURL(client.BaseURI), 363 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts", pathParameters), 364 autorest.WithQueryParameters(queryParameters)) 365 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 366} 367 368// ListSender sends the List request. The method will close the 369// http.Response Body if it receives an error. 370func (client AccountsClient) ListSender(req *http.Request) (*http.Response, error) { 371 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 372} 373 374// ListResponder handles the response to the List request. The method always 375// closes the http.Response Body. 376func (client AccountsClient) ListResponder(resp *http.Response) (result AccountList, err error) { 377 err = autorest.Respond( 378 resp, 379 azure.WithErrorUnlessStatusCode(http.StatusOK), 380 autorest.ByUnmarshallingJSON(&result), 381 autorest.ByClosing()) 382 result.Response = autorest.Response{Response: resp} 383 return 384} 385 386// listNextResults retrieves the next set of results, if any. 387func (client AccountsClient) listNextResults(ctx context.Context, lastResults AccountList) (result AccountList, err error) { 388 req, err := lastResults.accountListPreparer(ctx) 389 if err != nil { 390 return result, autorest.NewErrorWithError(err, "netapp.AccountsClient", "listNextResults", nil, "Failure preparing next results request") 391 } 392 if req == nil { 393 return 394 } 395 resp, err := client.ListSender(req) 396 if err != nil { 397 result.Response = autorest.Response{Response: resp} 398 return result, autorest.NewErrorWithError(err, "netapp.AccountsClient", "listNextResults", resp, "Failure sending next results request") 399 } 400 result, err = client.ListResponder(resp) 401 if err != nil { 402 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "listNextResults", resp, "Failure responding to next results request") 403 } 404 return 405} 406 407// ListComplete enumerates all values, automatically crossing page boundaries as required. 408func (client AccountsClient) ListComplete(ctx context.Context, resourceGroupName string) (result AccountListIterator, err error) { 409 if tracing.IsEnabled() { 410 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.List") 411 defer func() { 412 sc := -1 413 if result.Response().Response.Response != nil { 414 sc = result.page.Response().Response.Response.StatusCode 415 } 416 tracing.EndSpan(ctx, sc, err) 417 }() 418 } 419 result.page, err = client.List(ctx, resourceGroupName) 420 return 421} 422 423// ListBySubscription list and describe all NetApp accounts in the subscription. 424func (client AccountsClient) ListBySubscription(ctx context.Context) (result AccountListPage, err error) { 425 if tracing.IsEnabled() { 426 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListBySubscription") 427 defer func() { 428 sc := -1 429 if result.al.Response.Response != nil { 430 sc = result.al.Response.Response.StatusCode 431 } 432 tracing.EndSpan(ctx, sc, err) 433 }() 434 } 435 result.fn = client.listBySubscriptionNextResults 436 req, err := client.ListBySubscriptionPreparer(ctx) 437 if err != nil { 438 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "ListBySubscription", nil, "Failure preparing request") 439 return 440 } 441 442 resp, err := client.ListBySubscriptionSender(req) 443 if err != nil { 444 result.al.Response = autorest.Response{Response: resp} 445 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "ListBySubscription", resp, "Failure sending request") 446 return 447 } 448 449 result.al, err = client.ListBySubscriptionResponder(resp) 450 if err != nil { 451 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "ListBySubscription", resp, "Failure responding to request") 452 return 453 } 454 if result.al.hasNextLink() && result.al.IsEmpty() { 455 err = result.NextWithContext(ctx) 456 return 457 } 458 459 return 460} 461 462// ListBySubscriptionPreparer prepares the ListBySubscription request. 463func (client AccountsClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) { 464 pathParameters := map[string]interface{}{ 465 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 466 } 467 468 const APIVersion = "2021-06-01" 469 queryParameters := map[string]interface{}{ 470 "api-version": APIVersion, 471 } 472 473 preparer := autorest.CreatePreparer( 474 autorest.AsGet(), 475 autorest.WithBaseURL(client.BaseURI), 476 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.NetApp/netAppAccounts", pathParameters), 477 autorest.WithQueryParameters(queryParameters)) 478 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 479} 480 481// ListBySubscriptionSender sends the ListBySubscription request. The method will close the 482// http.Response Body if it receives an error. 483func (client AccountsClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { 484 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 485} 486 487// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always 488// closes the http.Response Body. 489func (client AccountsClient) ListBySubscriptionResponder(resp *http.Response) (result AccountList, err error) { 490 err = autorest.Respond( 491 resp, 492 azure.WithErrorUnlessStatusCode(http.StatusOK), 493 autorest.ByUnmarshallingJSON(&result), 494 autorest.ByClosing()) 495 result.Response = autorest.Response{Response: resp} 496 return 497} 498 499// listBySubscriptionNextResults retrieves the next set of results, if any. 500func (client AccountsClient) listBySubscriptionNextResults(ctx context.Context, lastResults AccountList) (result AccountList, err error) { 501 req, err := lastResults.accountListPreparer(ctx) 502 if err != nil { 503 return result, autorest.NewErrorWithError(err, "netapp.AccountsClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request") 504 } 505 if req == nil { 506 return 507 } 508 resp, err := client.ListBySubscriptionSender(req) 509 if err != nil { 510 result.Response = autorest.Response{Response: resp} 511 return result, autorest.NewErrorWithError(err, "netapp.AccountsClient", "listBySubscriptionNextResults", resp, "Failure sending next results request") 512 } 513 result, err = client.ListBySubscriptionResponder(resp) 514 if err != nil { 515 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request") 516 } 517 return 518} 519 520// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. 521func (client AccountsClient) ListBySubscriptionComplete(ctx context.Context) (result AccountListIterator, err error) { 522 if tracing.IsEnabled() { 523 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListBySubscription") 524 defer func() { 525 sc := -1 526 if result.Response().Response.Response != nil { 527 sc = result.page.Response().Response.Response.StatusCode 528 } 529 tracing.EndSpan(ctx, sc, err) 530 }() 531 } 532 result.page, err = client.ListBySubscription(ctx) 533 return 534} 535 536// Update patch the specified NetApp account 537// Parameters: 538// body - netApp Account object supplied in the body of the operation. 539// resourceGroupName - the name of the resource group. 540// accountName - the name of the NetApp account 541func (client AccountsClient) Update(ctx context.Context, body AccountPatch, resourceGroupName string, accountName string) (result AccountsUpdateFuture, err error) { 542 if tracing.IsEnabled() { 543 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Update") 544 defer func() { 545 sc := -1 546 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 547 sc = result.FutureAPI.Response().StatusCode 548 } 549 tracing.EndSpan(ctx, sc, err) 550 }() 551 } 552 if err := validation.Validate([]validation.Validation{ 553 {TargetValue: resourceGroupName, 554 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 555 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 556 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 557 return result, validation.NewError("netapp.AccountsClient", "Update", err.Error()) 558 } 559 560 req, err := client.UpdatePreparer(ctx, body, resourceGroupName, accountName) 561 if err != nil { 562 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "Update", nil, "Failure preparing request") 563 return 564 } 565 566 result, err = client.UpdateSender(req) 567 if err != nil { 568 err = autorest.NewErrorWithError(err, "netapp.AccountsClient", "Update", nil, "Failure sending request") 569 return 570 } 571 572 return 573} 574 575// UpdatePreparer prepares the Update request. 576func (client AccountsClient) UpdatePreparer(ctx context.Context, body AccountPatch, resourceGroupName string, accountName string) (*http.Request, error) { 577 pathParameters := map[string]interface{}{ 578 "accountName": autorest.Encode("path", accountName), 579 "resourceGroupName": autorest.Encode("path", resourceGroupName), 580 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 581 } 582 583 const APIVersion = "2021-06-01" 584 queryParameters := map[string]interface{}{ 585 "api-version": APIVersion, 586 } 587 588 body.ID = nil 589 body.Name = nil 590 body.Type = nil 591 preparer := autorest.CreatePreparer( 592 autorest.AsContentType("application/json; charset=utf-8"), 593 autorest.AsPatch(), 594 autorest.WithBaseURL(client.BaseURI), 595 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.NetApp/netAppAccounts/{accountName}", pathParameters), 596 autorest.WithJSON(body), 597 autorest.WithQueryParameters(queryParameters)) 598 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 599} 600 601// UpdateSender sends the Update request. The method will close the 602// http.Response Body if it receives an error. 603func (client AccountsClient) UpdateSender(req *http.Request) (future AccountsUpdateFuture, err error) { 604 var resp *http.Response 605 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 606 if err != nil { 607 return 608 } 609 var azf azure.Future 610 azf, err = azure.NewFutureFromResponse(resp) 611 future.FutureAPI = &azf 612 future.Result = future.result 613 return 614} 615 616// UpdateResponder handles the response to the Update request. The method always 617// closes the http.Response Body. 618func (client AccountsClient) UpdateResponder(resp *http.Response) (result Account, err error) { 619 err = autorest.Respond( 620 resp, 621 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 622 autorest.ByUnmarshallingJSON(&result), 623 autorest.ByClosing()) 624 result.Response = autorest.Response{Response: resp} 625 return 626} 627