1package web 2 3// Copyright (c) Microsoft and contributors. All rights reserved. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// 14// See the License for the specific language governing permissions and 15// limitations under the License. 16// 17// Code generated by Microsoft (R) AutoRest Code Generator. 18// Changes may cause incorrect behavior and will be lost if the code is regenerated. 19 20import ( 21 "context" 22 "github.com/Azure/go-autorest/autorest" 23 "github.com/Azure/go-autorest/autorest/azure" 24 "net/http" 25) 26 27// ConnectionsClient is the webSite Management Client 28type ConnectionsClient struct { 29 BaseClient 30} 31 32// NewConnectionsClient creates an instance of the ConnectionsClient client. 33func NewConnectionsClient(subscriptionID string) ConnectionsClient { 34 return NewConnectionsClientWithBaseURI(DefaultBaseURI, subscriptionID) 35} 36 37// NewConnectionsClientWithBaseURI creates an instance of the ConnectionsClient client. 38func NewConnectionsClientWithBaseURI(baseURI string, subscriptionID string) ConnectionsClient { 39 return ConnectionsClient{NewWithBaseURI(baseURI, subscriptionID)} 40} 41 42// ConfirmConsentCode confirms consent code of a connection. 43// Parameters: 44// resourceGroupName - the resource group name. 45// connectionName - the connection name. 46// content - the content. 47func (client ConnectionsClient) ConfirmConsentCode(ctx context.Context, resourceGroupName string, connectionName string, content ConfirmConsentCodeInput) (result Connection, err error) { 48 req, err := client.ConfirmConsentCodePreparer(ctx, resourceGroupName, connectionName, content) 49 if err != nil { 50 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ConfirmConsentCode", nil, "Failure preparing request") 51 return 52 } 53 54 resp, err := client.ConfirmConsentCodeSender(req) 55 if err != nil { 56 result.Response = autorest.Response{Response: resp} 57 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ConfirmConsentCode", resp, "Failure sending request") 58 return 59 } 60 61 result, err = client.ConfirmConsentCodeResponder(resp) 62 if err != nil { 63 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ConfirmConsentCode", resp, "Failure responding to request") 64 } 65 66 return 67} 68 69// ConfirmConsentCodePreparer prepares the ConfirmConsentCode request. 70func (client ConnectionsClient) ConfirmConsentCodePreparer(ctx context.Context, resourceGroupName string, connectionName string, content ConfirmConsentCodeInput) (*http.Request, error) { 71 pathParameters := map[string]interface{}{ 72 "connectionName": autorest.Encode("path", connectionName), 73 "resourceGroupName": autorest.Encode("path", resourceGroupName), 74 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 75 } 76 77 const APIVersion = "2015-08-01-preview" 78 queryParameters := map[string]interface{}{ 79 "api-version": APIVersion, 80 } 81 82 preparer := autorest.CreatePreparer( 83 autorest.AsContentType("application/json; charset=utf-8"), 84 autorest.AsPost(), 85 autorest.WithBaseURL(client.BaseURI), 86 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/connections/{connectionName}/confirmConsentCode", pathParameters), 87 autorest.WithJSON(content), 88 autorest.WithQueryParameters(queryParameters)) 89 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 90} 91 92// ConfirmConsentCodeSender sends the ConfirmConsentCode request. The method will close the 93// http.Response Body if it receives an error. 94func (client ConnectionsClient) ConfirmConsentCodeSender(req *http.Request) (*http.Response, error) { 95 return autorest.SendWithSender(client, req, 96 azure.DoRetryWithRegistration(client.Client)) 97} 98 99// ConfirmConsentCodeResponder handles the response to the ConfirmConsentCode request. The method always 100// closes the http.Response Body. 101func (client ConnectionsClient) ConfirmConsentCodeResponder(resp *http.Response) (result Connection, err error) { 102 err = autorest.Respond( 103 resp, 104 client.ByInspecting(), 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 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, connectionName, connection) 119 if err != nil { 120 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "CreateOrUpdate", nil, "Failure preparing request") 121 return 122 } 123 124 resp, err := client.CreateOrUpdateSender(req) 125 if err != nil { 126 result.Response = autorest.Response{Response: resp} 127 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "CreateOrUpdate", resp, "Failure sending request") 128 return 129 } 130 131 result, err = client.CreateOrUpdateResponder(resp) 132 if err != nil { 133 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "CreateOrUpdate", resp, "Failure responding to request") 134 } 135 136 return 137} 138 139// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 140func (client ConnectionsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, connectionName string, connection Connection) (*http.Request, error) { 141 pathParameters := map[string]interface{}{ 142 "connectionName": autorest.Encode("path", connectionName), 143 "resourceGroupName": autorest.Encode("path", resourceGroupName), 144 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 145 } 146 147 const APIVersion = "2015-08-01-preview" 148 queryParameters := map[string]interface{}{ 149 "api-version": APIVersion, 150 } 151 152 preparer := autorest.CreatePreparer( 153 autorest.AsContentType("application/json; charset=utf-8"), 154 autorest.AsPut(), 155 autorest.WithBaseURL(client.BaseURI), 156 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/connections/{connectionName}", pathParameters), 157 autorest.WithJSON(connection), 158 autorest.WithQueryParameters(queryParameters)) 159 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 160} 161 162// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 163// http.Response Body if it receives an error. 164func (client ConnectionsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { 165 return autorest.SendWithSender(client, req, 166 azure.DoRetryWithRegistration(client.Client)) 167} 168 169// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 170// closes the http.Response Body. 171func (client ConnectionsClient) CreateOrUpdateResponder(resp *http.Response) (result Connection, err error) { 172 err = autorest.Respond( 173 resp, 174 client.ByInspecting(), 175 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 176 autorest.ByUnmarshallingJSON(&result), 177 autorest.ByClosing()) 178 result.Response = autorest.Response{Response: resp} 179 return 180} 181 182// Delete deletes a connection. 183// Parameters: 184// resourceGroupName - the resource group name. 185// connectionName - the connection name. 186func (client ConnectionsClient) Delete(ctx context.Context, resourceGroupName string, connectionName string) (result autorest.Response, err error) { 187 req, err := client.DeletePreparer(ctx, resourceGroupName, connectionName) 188 if err != nil { 189 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "Delete", nil, "Failure preparing request") 190 return 191 } 192 193 resp, err := client.DeleteSender(req) 194 if err != nil { 195 result.Response = resp 196 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "Delete", resp, "Failure sending request") 197 return 198 } 199 200 result, err = client.DeleteResponder(resp) 201 if err != nil { 202 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "Delete", resp, "Failure responding to request") 203 } 204 205 return 206} 207 208// DeletePreparer prepares the Delete request. 209func (client ConnectionsClient) DeletePreparer(ctx context.Context, resourceGroupName string, connectionName string) (*http.Request, error) { 210 pathParameters := map[string]interface{}{ 211 "connectionName": autorest.Encode("path", connectionName), 212 "resourceGroupName": autorest.Encode("path", resourceGroupName), 213 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 214 } 215 216 const APIVersion = "2015-08-01-preview" 217 queryParameters := map[string]interface{}{ 218 "api-version": APIVersion, 219 } 220 221 preparer := autorest.CreatePreparer( 222 autorest.AsDelete(), 223 autorest.WithBaseURL(client.BaseURI), 224 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/connections/{connectionName}", pathParameters), 225 autorest.WithQueryParameters(queryParameters)) 226 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 227} 228 229// DeleteSender sends the Delete request. The method will close the 230// http.Response Body if it receives an error. 231func (client ConnectionsClient) DeleteSender(req *http.Request) (*http.Response, error) { 232 return autorest.SendWithSender(client, req, 233 azure.DoRetryWithRegistration(client.Client)) 234} 235 236// DeleteResponder handles the response to the Delete request. The method always 237// closes the http.Response Body. 238func (client ConnectionsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 239 err = autorest.Respond( 240 resp, 241 client.ByInspecting(), 242 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 243 autorest.ByClosing()) 244 result.Response = resp 245 return 246} 247 248// Get gets a connection. 249// Parameters: 250// resourceGroupName - the resource group name. 251// connectionName - the connection name. 252func (client ConnectionsClient) Get(ctx context.Context, resourceGroupName string, connectionName string) (result Connection, err error) { 253 req, err := client.GetPreparer(ctx, resourceGroupName, connectionName) 254 if err != nil { 255 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "Get", nil, "Failure preparing request") 256 return 257 } 258 259 resp, err := client.GetSender(req) 260 if err != nil { 261 result.Response = autorest.Response{Response: resp} 262 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "Get", resp, "Failure sending request") 263 return 264 } 265 266 result, err = client.GetResponder(resp) 267 if err != nil { 268 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "Get", resp, "Failure responding to request") 269 } 270 271 return 272} 273 274// GetPreparer prepares the Get request. 275func (client ConnectionsClient) GetPreparer(ctx context.Context, resourceGroupName string, connectionName string) (*http.Request, error) { 276 pathParameters := map[string]interface{}{ 277 "connectionName": autorest.Encode("path", connectionName), 278 "resourceGroupName": autorest.Encode("path", resourceGroupName), 279 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 280 } 281 282 const APIVersion = "2015-08-01-preview" 283 queryParameters := map[string]interface{}{ 284 "api-version": APIVersion, 285 } 286 287 preparer := autorest.CreatePreparer( 288 autorest.AsGet(), 289 autorest.WithBaseURL(client.BaseURI), 290 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/connections/{connectionName}", pathParameters), 291 autorest.WithQueryParameters(queryParameters)) 292 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 293} 294 295// GetSender sends the Get request. The method will close the 296// http.Response Body if it receives an error. 297func (client ConnectionsClient) GetSender(req *http.Request) (*http.Response, error) { 298 return autorest.SendWithSender(client, req, 299 azure.DoRetryWithRegistration(client.Client)) 300} 301 302// GetResponder handles the response to the Get request. The method always 303// closes the http.Response Body. 304func (client ConnectionsClient) GetResponder(resp *http.Response) (result Connection, err error) { 305 err = autorest.Respond( 306 resp, 307 client.ByInspecting(), 308 azure.WithErrorUnlessStatusCode(http.StatusOK), 309 autorest.ByUnmarshallingJSON(&result), 310 autorest.ByClosing()) 311 result.Response = autorest.Response{Response: resp} 312 return 313} 314 315// List gets a list of connections. 316// Parameters: 317// resourceGroupName - resource Group Name 318// top - the number of items to be included in the result. 319// filter - the filter to apply on the operation. 320func (client ConnectionsClient) List(ctx context.Context, resourceGroupName string, top *int32, filter string) (result ConnectionCollectionPage, err error) { 321 result.fn = client.listNextResults 322 req, err := client.ListPreparer(ctx, resourceGroupName, top, filter) 323 if err != nil { 324 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "List", nil, "Failure preparing request") 325 return 326 } 327 328 resp, err := client.ListSender(req) 329 if err != nil { 330 result.cc.Response = autorest.Response{Response: resp} 331 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "List", resp, "Failure sending request") 332 return 333 } 334 335 result.cc, err = client.ListResponder(resp) 336 if err != nil { 337 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "List", resp, "Failure responding to request") 338 } 339 340 return 341} 342 343// ListPreparer prepares the List request. 344func (client ConnectionsClient) ListPreparer(ctx context.Context, resourceGroupName string, top *int32, filter string) (*http.Request, error) { 345 pathParameters := map[string]interface{}{ 346 "resourceGroupName": autorest.Encode("path", resourceGroupName), 347 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 348 } 349 350 const APIVersion = "2015-08-01-preview" 351 queryParameters := map[string]interface{}{ 352 "api-version": APIVersion, 353 } 354 if top != nil { 355 queryParameters["$top"] = autorest.Encode("query", *top) 356 } 357 if len(filter) > 0 { 358 queryParameters["$filter"] = autorest.Encode("query", filter) 359 } 360 361 preparer := autorest.CreatePreparer( 362 autorest.AsGet(), 363 autorest.WithBaseURL(client.BaseURI), 364 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/connections", pathParameters), 365 autorest.WithQueryParameters(queryParameters)) 366 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 367} 368 369// ListSender sends the List request. The method will close the 370// http.Response Body if it receives an error. 371func (client ConnectionsClient) ListSender(req *http.Request) (*http.Response, error) { 372 return autorest.SendWithSender(client, req, 373 azure.DoRetryWithRegistration(client.Client)) 374} 375 376// ListResponder handles the response to the List request. The method always 377// closes the http.Response Body. 378func (client ConnectionsClient) ListResponder(resp *http.Response) (result ConnectionCollection, err error) { 379 err = autorest.Respond( 380 resp, 381 client.ByInspecting(), 382 azure.WithErrorUnlessStatusCode(http.StatusOK), 383 autorest.ByUnmarshallingJSON(&result), 384 autorest.ByClosing()) 385 result.Response = autorest.Response{Response: resp} 386 return 387} 388 389// listNextResults retrieves the next set of results, if any. 390func (client ConnectionsClient) listNextResults(lastResults ConnectionCollection) (result ConnectionCollection, err error) { 391 req, err := lastResults.connectionCollectionPreparer() 392 if err != nil { 393 return result, autorest.NewErrorWithError(err, "web.ConnectionsClient", "listNextResults", nil, "Failure preparing next results request") 394 } 395 if req == nil { 396 return 397 } 398 resp, err := client.ListSender(req) 399 if err != nil { 400 result.Response = autorest.Response{Response: resp} 401 return result, autorest.NewErrorWithError(err, "web.ConnectionsClient", "listNextResults", resp, "Failure sending next results request") 402 } 403 result, err = client.ListResponder(resp) 404 if err != nil { 405 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "listNextResults", resp, "Failure responding to next results request") 406 } 407 return 408} 409 410// ListComplete enumerates all values, automatically crossing page boundaries as required. 411func (client ConnectionsClient) ListComplete(ctx context.Context, resourceGroupName string, top *int32, filter string) (result ConnectionCollectionIterator, err error) { 412 result.page, err = client.List(ctx, resourceGroupName, top, filter) 413 return 414} 415 416// ListConnectionKeys lists connection keys. 417// Parameters: 418// resourceGroupName - the resource group name. 419// connectionName - the connection name. 420// content - the content. 421func (client ConnectionsClient) ListConnectionKeys(ctx context.Context, resourceGroupName string, connectionName string, content ListConnectionKeysInput) (result ConnectionSecrets, err error) { 422 req, err := client.ListConnectionKeysPreparer(ctx, resourceGroupName, connectionName, content) 423 if err != nil { 424 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ListConnectionKeys", nil, "Failure preparing request") 425 return 426 } 427 428 resp, err := client.ListConnectionKeysSender(req) 429 if err != nil { 430 result.Response = autorest.Response{Response: resp} 431 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ListConnectionKeys", resp, "Failure sending request") 432 return 433 } 434 435 result, err = client.ListConnectionKeysResponder(resp) 436 if err != nil { 437 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ListConnectionKeys", resp, "Failure responding to request") 438 } 439 440 return 441} 442 443// ListConnectionKeysPreparer prepares the ListConnectionKeys request. 444func (client ConnectionsClient) ListConnectionKeysPreparer(ctx context.Context, resourceGroupName string, connectionName string, content ListConnectionKeysInput) (*http.Request, error) { 445 pathParameters := map[string]interface{}{ 446 "connectionName": autorest.Encode("path", connectionName), 447 "resourceGroupName": autorest.Encode("path", resourceGroupName), 448 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 449 } 450 451 const APIVersion = "2015-08-01-preview" 452 queryParameters := map[string]interface{}{ 453 "api-version": APIVersion, 454 } 455 456 preparer := autorest.CreatePreparer( 457 autorest.AsContentType("application/json; charset=utf-8"), 458 autorest.AsPost(), 459 autorest.WithBaseURL(client.BaseURI), 460 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/connections/{connectionName}/listConnectionKeys", pathParameters), 461 autorest.WithJSON(content), 462 autorest.WithQueryParameters(queryParameters)) 463 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 464} 465 466// ListConnectionKeysSender sends the ListConnectionKeys request. The method will close the 467// http.Response Body if it receives an error. 468func (client ConnectionsClient) ListConnectionKeysSender(req *http.Request) (*http.Response, error) { 469 return autorest.SendWithSender(client, req, 470 azure.DoRetryWithRegistration(client.Client)) 471} 472 473// ListConnectionKeysResponder handles the response to the ListConnectionKeys request. The method always 474// closes the http.Response Body. 475func (client ConnectionsClient) ListConnectionKeysResponder(resp *http.Response) (result ConnectionSecrets, err error) { 476 err = autorest.Respond( 477 resp, 478 client.ByInspecting(), 479 azure.WithErrorUnlessStatusCode(http.StatusOK), 480 autorest.ByUnmarshallingJSON(&result), 481 autorest.ByClosing()) 482 result.Response = autorest.Response{Response: resp} 483 return 484} 485 486// ListConsentLinks lists consent links of a connection. 487// Parameters: 488// resourceGroupName - the resource group name. 489// connectionName - the connection name. 490// content - the content. 491func (client ConnectionsClient) ListConsentLinks(ctx context.Context, resourceGroupName string, connectionName string, content ConsentLinkInput) (result ConsentLinkPayload, err error) { 492 req, err := client.ListConsentLinksPreparer(ctx, resourceGroupName, connectionName, content) 493 if err != nil { 494 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ListConsentLinks", nil, "Failure preparing request") 495 return 496 } 497 498 resp, err := client.ListConsentLinksSender(req) 499 if err != nil { 500 result.Response = autorest.Response{Response: resp} 501 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ListConsentLinks", resp, "Failure sending request") 502 return 503 } 504 505 result, err = client.ListConsentLinksResponder(resp) 506 if err != nil { 507 err = autorest.NewErrorWithError(err, "web.ConnectionsClient", "ListConsentLinks", resp, "Failure responding to request") 508 } 509 510 return 511} 512 513// ListConsentLinksPreparer prepares the ListConsentLinks request. 514func (client ConnectionsClient) ListConsentLinksPreparer(ctx context.Context, resourceGroupName string, connectionName string, content ConsentLinkInput) (*http.Request, error) { 515 pathParameters := map[string]interface{}{ 516 "connectionName": autorest.Encode("path", connectionName), 517 "resourceGroupName": autorest.Encode("path", resourceGroupName), 518 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 519 } 520 521 const APIVersion = "2015-08-01-preview" 522 queryParameters := map[string]interface{}{ 523 "api-version": APIVersion, 524 } 525 526 preparer := autorest.CreatePreparer( 527 autorest.AsContentType("application/json; charset=utf-8"), 528 autorest.AsPost(), 529 autorest.WithBaseURL(client.BaseURI), 530 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/connections/{connectionName}/listConsentLinks", pathParameters), 531 autorest.WithJSON(content), 532 autorest.WithQueryParameters(queryParameters)) 533 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 534} 535 536// ListConsentLinksSender sends the ListConsentLinks request. The method will close the 537// http.Response Body if it receives an error. 538func (client ConnectionsClient) ListConsentLinksSender(req *http.Request) (*http.Response, error) { 539 return autorest.SendWithSender(client, req, 540 azure.DoRetryWithRegistration(client.Client)) 541} 542 543// ListConsentLinksResponder handles the response to the ListConsentLinks request. The method always 544// closes the http.Response Body. 545func (client ConnectionsClient) ListConsentLinksResponder(resp *http.Response) (result ConsentLinkPayload, err error) { 546 err = autorest.Respond( 547 resp, 548 client.ByInspecting(), 549 azure.WithErrorUnlessStatusCode(http.StatusOK), 550 autorest.ByUnmarshallingJSON(&result), 551 autorest.ByClosing()) 552 result.Response = autorest.Response{Response: resp} 553 return 554} 555