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