1package deviceupdate 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 Device Update resource provider. 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// Create creates or updates Account. 35// Parameters: 36// resourceGroupName - the resource group name. 37// accountName - account name. 38// account - account details. 39func (client AccountsClient) Create(ctx context.Context, resourceGroupName string, accountName string, account Account) (result AccountsCreateFuture, err error) { 40 if tracing.IsEnabled() { 41 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Create") 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: accountName, 52 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil}, 53 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 54 {Target: "accountName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]+$`, Chain: nil}}}}); err != nil { 55 return result, validation.NewError("deviceupdate.AccountsClient", "Create", err.Error()) 56 } 57 58 req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, account) 59 if err != nil { 60 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Create", nil, "Failure preparing request") 61 return 62 } 63 64 result, err = client.CreateSender(req) 65 if err != nil { 66 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Create", nil, "Failure sending request") 67 return 68 } 69 70 return 71} 72 73// CreatePreparer prepares the Create request. 74func (client AccountsClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, account Account) (*http.Request, error) { 75 pathParameters := map[string]interface{}{ 76 "accountName": autorest.Encode("path", accountName), 77 "resourceGroupName": autorest.Encode("path", resourceGroupName), 78 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 79 } 80 81 const APIVersion = "2020-03-01-preview" 82 queryParameters := map[string]interface{}{ 83 "api-version": APIVersion, 84 } 85 86 preparer := autorest.CreatePreparer( 87 autorest.AsContentType("application/json; charset=utf-8"), 88 autorest.AsPut(), 89 autorest.WithBaseURL(client.BaseURI), 90 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DeviceUpdate/accounts/{accountName}", pathParameters), 91 autorest.WithJSON(account), 92 autorest.WithQueryParameters(queryParameters)) 93 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 94} 95 96// CreateSender sends the Create request. The method will close the 97// http.Response Body if it receives an error. 98func (client AccountsClient) CreateSender(req *http.Request) (future AccountsCreateFuture, err error) { 99 var resp *http.Response 100 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 101 if err != nil { 102 return 103 } 104 var azf azure.Future 105 azf, err = azure.NewFutureFromResponse(resp) 106 future.FutureAPI = &azf 107 future.Result = future.result 108 return 109} 110 111// CreateResponder handles the response to the Create request. The method always 112// closes the http.Response Body. 113func (client AccountsClient) CreateResponder(resp *http.Response) (result Account, err error) { 114 err = autorest.Respond( 115 resp, 116 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 117 autorest.ByUnmarshallingJSON(&result), 118 autorest.ByClosing()) 119 result.Response = autorest.Response{Response: resp} 120 return 121} 122 123// Delete deletes account. 124// Parameters: 125// resourceGroupName - the resource group name. 126// accountName - account name. 127func (client AccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result AccountsDeleteFuture, err error) { 128 if tracing.IsEnabled() { 129 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Delete") 130 defer func() { 131 sc := -1 132 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 133 sc = result.FutureAPI.Response().StatusCode 134 } 135 tracing.EndSpan(ctx, sc, err) 136 }() 137 } 138 if err := validation.Validate([]validation.Validation{ 139 {TargetValue: accountName, 140 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil}, 141 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 142 {Target: "accountName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]+$`, Chain: nil}}}}); err != nil { 143 return result, validation.NewError("deviceupdate.AccountsClient", "Delete", err.Error()) 144 } 145 146 req, err := client.DeletePreparer(ctx, resourceGroupName, accountName) 147 if err != nil { 148 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Delete", nil, "Failure preparing request") 149 return 150 } 151 152 result, err = client.DeleteSender(req) 153 if err != nil { 154 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Delete", nil, "Failure sending request") 155 return 156 } 157 158 return 159} 160 161// DeletePreparer prepares the Delete request. 162func (client AccountsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) { 163 pathParameters := map[string]interface{}{ 164 "accountName": autorest.Encode("path", accountName), 165 "resourceGroupName": autorest.Encode("path", resourceGroupName), 166 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 167 } 168 169 const APIVersion = "2020-03-01-preview" 170 queryParameters := map[string]interface{}{ 171 "api-version": APIVersion, 172 } 173 174 preparer := autorest.CreatePreparer( 175 autorest.AsDelete(), 176 autorest.WithBaseURL(client.BaseURI), 177 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DeviceUpdate/accounts/{accountName}", pathParameters), 178 autorest.WithQueryParameters(queryParameters)) 179 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 180} 181 182// DeleteSender sends the Delete request. The method will close the 183// http.Response Body if it receives an error. 184func (client AccountsClient) DeleteSender(req *http.Request) (future AccountsDeleteFuture, err error) { 185 var resp *http.Response 186 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 187 if err != nil { 188 return 189 } 190 var azf azure.Future 191 azf, err = azure.NewFutureFromResponse(resp) 192 future.FutureAPI = &azf 193 future.Result = future.result 194 return 195} 196 197// DeleteResponder handles the response to the Delete request. The method always 198// closes the http.Response Body. 199func (client AccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 200 err = autorest.Respond( 201 resp, 202 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 203 autorest.ByClosing()) 204 result.Response = resp 205 return 206} 207 208// Get returns account details for the given account name. 209// Parameters: 210// resourceGroupName - the resource group name. 211// accountName - account name. 212func (client AccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result Account, err error) { 213 if tracing.IsEnabled() { 214 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Get") 215 defer func() { 216 sc := -1 217 if result.Response.Response != nil { 218 sc = result.Response.Response.StatusCode 219 } 220 tracing.EndSpan(ctx, sc, err) 221 }() 222 } 223 if err := validation.Validate([]validation.Validation{ 224 {TargetValue: accountName, 225 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil}, 226 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 227 {Target: "accountName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]+$`, Chain: nil}}}}); err != nil { 228 return result, validation.NewError("deviceupdate.AccountsClient", "Get", err.Error()) 229 } 230 231 req, err := client.GetPreparer(ctx, resourceGroupName, accountName) 232 if err != nil { 233 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Get", nil, "Failure preparing request") 234 return 235 } 236 237 resp, err := client.GetSender(req) 238 if err != nil { 239 result.Response = autorest.Response{Response: resp} 240 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Get", resp, "Failure sending request") 241 return 242 } 243 244 result, err = client.GetResponder(resp) 245 if err != nil { 246 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Get", resp, "Failure responding to request") 247 return 248 } 249 250 return 251} 252 253// GetPreparer prepares the Get request. 254func (client AccountsClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) { 255 pathParameters := map[string]interface{}{ 256 "accountName": autorest.Encode("path", accountName), 257 "resourceGroupName": autorest.Encode("path", resourceGroupName), 258 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 259 } 260 261 const APIVersion = "2020-03-01-preview" 262 queryParameters := map[string]interface{}{ 263 "api-version": APIVersion, 264 } 265 266 preparer := autorest.CreatePreparer( 267 autorest.AsGet(), 268 autorest.WithBaseURL(client.BaseURI), 269 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DeviceUpdate/accounts/{accountName}", pathParameters), 270 autorest.WithQueryParameters(queryParameters)) 271 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 272} 273 274// GetSender sends the Get request. The method will close the 275// http.Response Body if it receives an error. 276func (client AccountsClient) GetSender(req *http.Request) (*http.Response, error) { 277 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 278} 279 280// GetResponder handles the response to the Get request. The method always 281// closes the http.Response Body. 282func (client AccountsClient) GetResponder(resp *http.Response) (result Account, err error) { 283 err = autorest.Respond( 284 resp, 285 azure.WithErrorUnlessStatusCode(http.StatusOK), 286 autorest.ByUnmarshallingJSON(&result), 287 autorest.ByClosing()) 288 result.Response = autorest.Response{Response: resp} 289 return 290} 291 292// ListByResourceGroup returns list of Accounts. 293// Parameters: 294// resourceGroupName - the resource group name. 295func (client AccountsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result AccountListPage, err error) { 296 if tracing.IsEnabled() { 297 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListByResourceGroup") 298 defer func() { 299 sc := -1 300 if result.al.Response.Response != nil { 301 sc = result.al.Response.Response.StatusCode 302 } 303 tracing.EndSpan(ctx, sc, err) 304 }() 305 } 306 result.fn = client.listByResourceGroupNextResults 307 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 308 if err != nil { 309 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "ListByResourceGroup", nil, "Failure preparing request") 310 return 311 } 312 313 resp, err := client.ListByResourceGroupSender(req) 314 if err != nil { 315 result.al.Response = autorest.Response{Response: resp} 316 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "ListByResourceGroup", resp, "Failure sending request") 317 return 318 } 319 320 result.al, err = client.ListByResourceGroupResponder(resp) 321 if err != nil { 322 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "ListByResourceGroup", resp, "Failure responding to request") 323 return 324 } 325 if result.al.hasNextLink() && result.al.IsEmpty() { 326 err = result.NextWithContext(ctx) 327 return 328 } 329 330 return 331} 332 333// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 334func (client AccountsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 335 pathParameters := map[string]interface{}{ 336 "resourceGroupName": autorest.Encode("path", resourceGroupName), 337 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 338 } 339 340 const APIVersion = "2020-03-01-preview" 341 queryParameters := map[string]interface{}{ 342 "api-version": APIVersion, 343 } 344 345 preparer := autorest.CreatePreparer( 346 autorest.AsGet(), 347 autorest.WithBaseURL(client.BaseURI), 348 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DeviceUpdate/accounts", pathParameters), 349 autorest.WithQueryParameters(queryParameters)) 350 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 351} 352 353// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 354// http.Response Body if it receives an error. 355func (client AccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 356 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 357} 358 359// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 360// closes the http.Response Body. 361func (client AccountsClient) ListByResourceGroupResponder(resp *http.Response) (result AccountList, err error) { 362 err = autorest.Respond( 363 resp, 364 azure.WithErrorUnlessStatusCode(http.StatusOK), 365 autorest.ByUnmarshallingJSON(&result), 366 autorest.ByClosing()) 367 result.Response = autorest.Response{Response: resp} 368 return 369} 370 371// listByResourceGroupNextResults retrieves the next set of results, if any. 372func (client AccountsClient) listByResourceGroupNextResults(ctx context.Context, lastResults AccountList) (result AccountList, err error) { 373 req, err := lastResults.accountListPreparer(ctx) 374 if err != nil { 375 return result, autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 376 } 377 if req == nil { 378 return 379 } 380 resp, err := client.ListByResourceGroupSender(req) 381 if err != nil { 382 result.Response = autorest.Response{Response: resp} 383 return result, autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 384 } 385 result, err = client.ListByResourceGroupResponder(resp) 386 if err != nil { 387 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 388 } 389 return 390} 391 392// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 393func (client AccountsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result AccountListIterator, err error) { 394 if tracing.IsEnabled() { 395 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListByResourceGroup") 396 defer func() { 397 sc := -1 398 if result.Response().Response.Response != nil { 399 sc = result.page.Response().Response.Response.StatusCode 400 } 401 tracing.EndSpan(ctx, sc, err) 402 }() 403 } 404 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 405 return 406} 407 408// ListBySubscription returns list of Accounts. 409func (client AccountsClient) ListBySubscription(ctx context.Context) (result AccountListPage, err error) { 410 if tracing.IsEnabled() { 411 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListBySubscription") 412 defer func() { 413 sc := -1 414 if result.al.Response.Response != nil { 415 sc = result.al.Response.Response.StatusCode 416 } 417 tracing.EndSpan(ctx, sc, err) 418 }() 419 } 420 result.fn = client.listBySubscriptionNextResults 421 req, err := client.ListBySubscriptionPreparer(ctx) 422 if err != nil { 423 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "ListBySubscription", nil, "Failure preparing request") 424 return 425 } 426 427 resp, err := client.ListBySubscriptionSender(req) 428 if err != nil { 429 result.al.Response = autorest.Response{Response: resp} 430 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "ListBySubscription", resp, "Failure sending request") 431 return 432 } 433 434 result.al, err = client.ListBySubscriptionResponder(resp) 435 if err != nil { 436 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "ListBySubscription", resp, "Failure responding to request") 437 return 438 } 439 if result.al.hasNextLink() && result.al.IsEmpty() { 440 err = result.NextWithContext(ctx) 441 return 442 } 443 444 return 445} 446 447// ListBySubscriptionPreparer prepares the ListBySubscription request. 448func (client AccountsClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) { 449 pathParameters := map[string]interface{}{ 450 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 451 } 452 453 const APIVersion = "2020-03-01-preview" 454 queryParameters := map[string]interface{}{ 455 "api-version": APIVersion, 456 } 457 458 preparer := autorest.CreatePreparer( 459 autorest.AsGet(), 460 autorest.WithBaseURL(client.BaseURI), 461 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DeviceUpdate/accounts", pathParameters), 462 autorest.WithQueryParameters(queryParameters)) 463 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 464} 465 466// ListBySubscriptionSender sends the ListBySubscription request. The method will close the 467// http.Response Body if it receives an error. 468func (client AccountsClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { 469 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 470} 471 472// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always 473// closes the http.Response Body. 474func (client AccountsClient) ListBySubscriptionResponder(resp *http.Response) (result AccountList, err error) { 475 err = autorest.Respond( 476 resp, 477 azure.WithErrorUnlessStatusCode(http.StatusOK), 478 autorest.ByUnmarshallingJSON(&result), 479 autorest.ByClosing()) 480 result.Response = autorest.Response{Response: resp} 481 return 482} 483 484// listBySubscriptionNextResults retrieves the next set of results, if any. 485func (client AccountsClient) listBySubscriptionNextResults(ctx context.Context, lastResults AccountList) (result AccountList, err error) { 486 req, err := lastResults.accountListPreparer(ctx) 487 if err != nil { 488 return result, autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request") 489 } 490 if req == nil { 491 return 492 } 493 resp, err := client.ListBySubscriptionSender(req) 494 if err != nil { 495 result.Response = autorest.Response{Response: resp} 496 return result, autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "listBySubscriptionNextResults", resp, "Failure sending next results request") 497 } 498 result, err = client.ListBySubscriptionResponder(resp) 499 if err != nil { 500 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request") 501 } 502 return 503} 504 505// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. 506func (client AccountsClient) ListBySubscriptionComplete(ctx context.Context) (result AccountListIterator, err error) { 507 if tracing.IsEnabled() { 508 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListBySubscription") 509 defer func() { 510 sc := -1 511 if result.Response().Response.Response != nil { 512 sc = result.page.Response().Response.Response.StatusCode 513 } 514 tracing.EndSpan(ctx, sc, err) 515 }() 516 } 517 result.page, err = client.ListBySubscription(ctx) 518 return 519} 520 521// Update updates account's patchable properties 522// Parameters: 523// resourceGroupName - the resource group name. 524// accountName - account name. 525// accountUpdatePayload - updated Account. 526func (client AccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, accountUpdatePayload AccountUpdate) (result AccountsUpdateFuture, err error) { 527 if tracing.IsEnabled() { 528 ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Update") 529 defer func() { 530 sc := -1 531 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 532 sc = result.FutureAPI.Response().StatusCode 533 } 534 tracing.EndSpan(ctx, sc, err) 535 }() 536 } 537 if err := validation.Validate([]validation.Validation{ 538 {TargetValue: accountName, 539 Constraints: []validation.Constraint{{Target: "accountName", Name: validation.MaxLength, Rule: 24, Chain: nil}, 540 {Target: "accountName", Name: validation.MinLength, Rule: 3, Chain: nil}, 541 {Target: "accountName", Name: validation.Pattern, Rule: `^[A-Za-z][A-Za-z0-9]+$`, Chain: nil}}}}); err != nil { 542 return result, validation.NewError("deviceupdate.AccountsClient", "Update", err.Error()) 543 } 544 545 req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, accountUpdatePayload) 546 if err != nil { 547 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Update", nil, "Failure preparing request") 548 return 549 } 550 551 result, err = client.UpdateSender(req) 552 if err != nil { 553 err = autorest.NewErrorWithError(err, "deviceupdate.AccountsClient", "Update", nil, "Failure sending request") 554 return 555 } 556 557 return 558} 559 560// UpdatePreparer prepares the Update request. 561func (client AccountsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, accountUpdatePayload AccountUpdate) (*http.Request, error) { 562 pathParameters := map[string]interface{}{ 563 "accountName": autorest.Encode("path", accountName), 564 "resourceGroupName": autorest.Encode("path", resourceGroupName), 565 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 566 } 567 568 const APIVersion = "2020-03-01-preview" 569 queryParameters := map[string]interface{}{ 570 "api-version": APIVersion, 571 } 572 573 preparer := autorest.CreatePreparer( 574 autorest.AsContentType("application/json; charset=utf-8"), 575 autorest.AsPatch(), 576 autorest.WithBaseURL(client.BaseURI), 577 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DeviceUpdate/accounts/{accountName}", pathParameters), 578 autorest.WithJSON(accountUpdatePayload), 579 autorest.WithQueryParameters(queryParameters)) 580 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 581} 582 583// UpdateSender sends the Update request. The method will close the 584// http.Response Body if it receives an error. 585func (client AccountsClient) UpdateSender(req *http.Request) (future AccountsUpdateFuture, err error) { 586 var resp *http.Response 587 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 588 if err != nil { 589 return 590 } 591 var azf azure.Future 592 azf, err = azure.NewFutureFromResponse(resp) 593 future.FutureAPI = &azf 594 future.Result = future.result 595 return 596} 597 598// UpdateResponder handles the response to the Update request. The method always 599// closes the http.Response Body. 600func (client AccountsClient) UpdateResponder(resp *http.Response) (result Account, err error) { 601 err = autorest.Respond( 602 resp, 603 azure.WithErrorUnlessStatusCode(http.StatusOK), 604 autorest.ByUnmarshallingJSON(&result), 605 autorest.ByClosing()) 606 result.Response = autorest.Response{Response: resp} 607 return 608} 609