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/autorest/validation" 14 "github.com/Azure/go-autorest/tracing" 15 "net/http" 16) 17 18// StaticSitesClient is the webSite Management Client 19type StaticSitesClient struct { 20 BaseClient 21} 22 23// NewStaticSitesClient creates an instance of the StaticSitesClient client. 24func NewStaticSitesClient(subscriptionID string) StaticSitesClient { 25 return NewStaticSitesClientWithBaseURI(DefaultBaseURI, subscriptionID) 26} 27 28// NewStaticSitesClientWithBaseURI creates an instance of the StaticSitesClient client using a custom endpoint. Use 29// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 30func NewStaticSitesClientWithBaseURI(baseURI string, subscriptionID string) StaticSitesClient { 31 return StaticSitesClient{NewWithBaseURI(baseURI, subscriptionID)} 32} 33 34// ApproveOrRejectPrivateEndpointConnection description for Approves or rejects a private endpoint connection 35// Parameters: 36// resourceGroupName - name of the resource group to which the resource belongs. 37// name - name of the static site. 38// privateEndpointConnectionName - name of the private endpoint connection. 39// privateEndpointWrapper - request body. 40func (client StaticSitesClient) ApproveOrRejectPrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, privateEndpointWrapper PrivateLinkConnectionApprovalRequestResource) (result StaticSitesApproveOrRejectPrivateEndpointConnectionFuture, err error) { 41 if tracing.IsEnabled() { 42 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ApproveOrRejectPrivateEndpointConnection") 43 defer func() { 44 sc := -1 45 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 46 sc = result.FutureAPI.Response().StatusCode 47 } 48 tracing.EndSpan(ctx, sc, err) 49 }() 50 } 51 if err := validation.Validate([]validation.Validation{ 52 {TargetValue: resourceGroupName, 53 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 54 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 55 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 56 return result, validation.NewError("web.StaticSitesClient", "ApproveOrRejectPrivateEndpointConnection", err.Error()) 57 } 58 59 req, err := client.ApproveOrRejectPrivateEndpointConnectionPreparer(ctx, resourceGroupName, name, privateEndpointConnectionName, privateEndpointWrapper) 60 if err != nil { 61 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ApproveOrRejectPrivateEndpointConnection", nil, "Failure preparing request") 62 return 63 } 64 65 result, err = client.ApproveOrRejectPrivateEndpointConnectionSender(req) 66 if err != nil { 67 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ApproveOrRejectPrivateEndpointConnection", nil, "Failure sending request") 68 return 69 } 70 71 return 72} 73 74// ApproveOrRejectPrivateEndpointConnectionPreparer prepares the ApproveOrRejectPrivateEndpointConnection request. 75func (client StaticSitesClient) ApproveOrRejectPrivateEndpointConnectionPreparer(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string, privateEndpointWrapper PrivateLinkConnectionApprovalRequestResource) (*http.Request, error) { 76 pathParameters := map[string]interface{}{ 77 "name": autorest.Encode("path", name), 78 "privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName), 79 "resourceGroupName": autorest.Encode("path", resourceGroupName), 80 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 81 } 82 83 const APIVersion = "2020-12-01" 84 queryParameters := map[string]interface{}{ 85 "api-version": APIVersion, 86 } 87 88 preparer := autorest.CreatePreparer( 89 autorest.AsContentType("application/json; charset=utf-8"), 90 autorest.AsPut(), 91 autorest.WithBaseURL(client.BaseURI), 92 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters), 93 autorest.WithJSON(privateEndpointWrapper), 94 autorest.WithQueryParameters(queryParameters)) 95 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 96} 97 98// ApproveOrRejectPrivateEndpointConnectionSender sends the ApproveOrRejectPrivateEndpointConnection request. The method will close the 99// http.Response Body if it receives an error. 100func (client StaticSitesClient) ApproveOrRejectPrivateEndpointConnectionSender(req *http.Request) (future StaticSitesApproveOrRejectPrivateEndpointConnectionFuture, err error) { 101 var resp *http.Response 102 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 103 if err != nil { 104 return 105 } 106 var azf azure.Future 107 azf, err = azure.NewFutureFromResponse(resp) 108 future.FutureAPI = &azf 109 future.Result = future.result 110 return 111} 112 113// ApproveOrRejectPrivateEndpointConnectionResponder handles the response to the ApproveOrRejectPrivateEndpointConnection request. The method always 114// closes the http.Response Body. 115func (client StaticSitesClient) ApproveOrRejectPrivateEndpointConnectionResponder(resp *http.Response) (result RemotePrivateEndpointConnectionARMResource, err error) { 116 err = autorest.Respond( 117 resp, 118 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 119 autorest.ByUnmarshallingJSON(&result), 120 autorest.ByClosing()) 121 result.Response = autorest.Response{Response: resp} 122 return 123} 124 125// CreateOrUpdateStaticSite description for Creates a new static site in an existing resource group, or updates an 126// existing static site. 127// Parameters: 128// resourceGroupName - name of the resource group to which the resource belongs. 129// name - name of the static site to create or update. 130// staticSiteEnvelope - a JSON representation of the staticsite properties. See example. 131func (client StaticSitesClient) CreateOrUpdateStaticSite(ctx context.Context, resourceGroupName string, name string, staticSiteEnvelope StaticSiteARMResource) (result StaticSitesCreateOrUpdateStaticSiteFuture, err error) { 132 if tracing.IsEnabled() { 133 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateOrUpdateStaticSite") 134 defer func() { 135 sc := -1 136 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 137 sc = result.FutureAPI.Response().StatusCode 138 } 139 tracing.EndSpan(ctx, sc, err) 140 }() 141 } 142 if err := validation.Validate([]validation.Validation{ 143 {TargetValue: resourceGroupName, 144 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 145 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 146 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 147 return result, validation.NewError("web.StaticSitesClient", "CreateOrUpdateStaticSite", err.Error()) 148 } 149 150 req, err := client.CreateOrUpdateStaticSitePreparer(ctx, resourceGroupName, name, staticSiteEnvelope) 151 if err != nil { 152 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSite", nil, "Failure preparing request") 153 return 154 } 155 156 result, err = client.CreateOrUpdateStaticSiteSender(req) 157 if err != nil { 158 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSite", nil, "Failure sending request") 159 return 160 } 161 162 return 163} 164 165// CreateOrUpdateStaticSitePreparer prepares the CreateOrUpdateStaticSite request. 166func (client StaticSitesClient) CreateOrUpdateStaticSitePreparer(ctx context.Context, resourceGroupName string, name string, staticSiteEnvelope StaticSiteARMResource) (*http.Request, error) { 167 pathParameters := map[string]interface{}{ 168 "name": autorest.Encode("path", name), 169 "resourceGroupName": autorest.Encode("path", resourceGroupName), 170 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 171 } 172 173 const APIVersion = "2020-12-01" 174 queryParameters := map[string]interface{}{ 175 "api-version": APIVersion, 176 } 177 178 preparer := autorest.CreatePreparer( 179 autorest.AsContentType("application/json; charset=utf-8"), 180 autorest.AsPut(), 181 autorest.WithBaseURL(client.BaseURI), 182 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}", pathParameters), 183 autorest.WithJSON(staticSiteEnvelope), 184 autorest.WithQueryParameters(queryParameters)) 185 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 186} 187 188// CreateOrUpdateStaticSiteSender sends the CreateOrUpdateStaticSite request. The method will close the 189// http.Response Body if it receives an error. 190func (client StaticSitesClient) CreateOrUpdateStaticSiteSender(req *http.Request) (future StaticSitesCreateOrUpdateStaticSiteFuture, err error) { 191 var resp *http.Response 192 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 193 if err != nil { 194 return 195 } 196 var azf azure.Future 197 azf, err = azure.NewFutureFromResponse(resp) 198 future.FutureAPI = &azf 199 future.Result = future.result 200 return 201} 202 203// CreateOrUpdateStaticSiteResponder handles the response to the CreateOrUpdateStaticSite request. The method always 204// closes the http.Response Body. 205func (client StaticSitesClient) CreateOrUpdateStaticSiteResponder(resp *http.Response) (result StaticSiteARMResource, err error) { 206 err = autorest.Respond( 207 resp, 208 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 209 autorest.ByUnmarshallingJSON(&result), 210 autorest.ByClosing()) 211 result.Response = autorest.Response{Response: resp} 212 return 213} 214 215// CreateOrUpdateStaticSiteAppSettings description for Creates or updates the app settings of a static site. 216// Parameters: 217// resourceGroupName - name of the resource group to which the resource belongs. 218// name - name of the static site. 219// appSettings - the dictionary containing the static site app settings to update. 220func (client StaticSitesClient) CreateOrUpdateStaticSiteAppSettings(ctx context.Context, resourceGroupName string, name string, appSettings StringDictionary) (result StringDictionary, err error) { 221 if tracing.IsEnabled() { 222 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateOrUpdateStaticSiteAppSettings") 223 defer func() { 224 sc := -1 225 if result.Response.Response != nil { 226 sc = result.Response.Response.StatusCode 227 } 228 tracing.EndSpan(ctx, sc, err) 229 }() 230 } 231 if err := validation.Validate([]validation.Validation{ 232 {TargetValue: resourceGroupName, 233 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 234 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 235 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 236 return result, validation.NewError("web.StaticSitesClient", "CreateOrUpdateStaticSiteAppSettings", err.Error()) 237 } 238 239 req, err := client.CreateOrUpdateStaticSiteAppSettingsPreparer(ctx, resourceGroupName, name, appSettings) 240 if err != nil { 241 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteAppSettings", nil, "Failure preparing request") 242 return 243 } 244 245 resp, err := client.CreateOrUpdateStaticSiteAppSettingsSender(req) 246 if err != nil { 247 result.Response = autorest.Response{Response: resp} 248 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteAppSettings", resp, "Failure sending request") 249 return 250 } 251 252 result, err = client.CreateOrUpdateStaticSiteAppSettingsResponder(resp) 253 if err != nil { 254 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteAppSettings", resp, "Failure responding to request") 255 return 256 } 257 258 return 259} 260 261// CreateOrUpdateStaticSiteAppSettingsPreparer prepares the CreateOrUpdateStaticSiteAppSettings request. 262func (client StaticSitesClient) CreateOrUpdateStaticSiteAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string, appSettings StringDictionary) (*http.Request, error) { 263 pathParameters := map[string]interface{}{ 264 "name": autorest.Encode("path", name), 265 "resourceGroupName": autorest.Encode("path", resourceGroupName), 266 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 267 } 268 269 const APIVersion = "2020-12-01" 270 queryParameters := map[string]interface{}{ 271 "api-version": APIVersion, 272 } 273 274 preparer := autorest.CreatePreparer( 275 autorest.AsContentType("application/json; charset=utf-8"), 276 autorest.AsPut(), 277 autorest.WithBaseURL(client.BaseURI), 278 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/config/appsettings", pathParameters), 279 autorest.WithJSON(appSettings), 280 autorest.WithQueryParameters(queryParameters)) 281 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 282} 283 284// CreateOrUpdateStaticSiteAppSettingsSender sends the CreateOrUpdateStaticSiteAppSettings request. The method will close the 285// http.Response Body if it receives an error. 286func (client StaticSitesClient) CreateOrUpdateStaticSiteAppSettingsSender(req *http.Request) (*http.Response, error) { 287 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 288} 289 290// CreateOrUpdateStaticSiteAppSettingsResponder handles the response to the CreateOrUpdateStaticSiteAppSettings request. The method always 291// closes the http.Response Body. 292func (client StaticSitesClient) CreateOrUpdateStaticSiteAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 293 err = autorest.Respond( 294 resp, 295 azure.WithErrorUnlessStatusCode(http.StatusOK), 296 autorest.ByUnmarshallingJSON(&result), 297 autorest.ByClosing()) 298 result.Response = autorest.Response{Response: resp} 299 return 300} 301 302// CreateOrUpdateStaticSiteBuildAppSettings description for Creates or updates the app settings of a static site build. 303// Parameters: 304// resourceGroupName - name of the resource group to which the resource belongs. 305// name - name of the static site. 306// environmentName - the stage site identifier. 307// appSettings - the dictionary containing the static site app settings to update. 308func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildAppSettings(ctx context.Context, resourceGroupName string, name string, environmentName string, appSettings StringDictionary) (result StringDictionary, err error) { 309 if tracing.IsEnabled() { 310 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateOrUpdateStaticSiteBuildAppSettings") 311 defer func() { 312 sc := -1 313 if result.Response.Response != nil { 314 sc = result.Response.Response.StatusCode 315 } 316 tracing.EndSpan(ctx, sc, err) 317 }() 318 } 319 if err := validation.Validate([]validation.Validation{ 320 {TargetValue: resourceGroupName, 321 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 322 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 323 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 324 return result, validation.NewError("web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildAppSettings", err.Error()) 325 } 326 327 req, err := client.CreateOrUpdateStaticSiteBuildAppSettingsPreparer(ctx, resourceGroupName, name, environmentName, appSettings) 328 if err != nil { 329 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildAppSettings", nil, "Failure preparing request") 330 return 331 } 332 333 resp, err := client.CreateOrUpdateStaticSiteBuildAppSettingsSender(req) 334 if err != nil { 335 result.Response = autorest.Response{Response: resp} 336 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildAppSettings", resp, "Failure sending request") 337 return 338 } 339 340 result, err = client.CreateOrUpdateStaticSiteBuildAppSettingsResponder(resp) 341 if err != nil { 342 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildAppSettings", resp, "Failure responding to request") 343 return 344 } 345 346 return 347} 348 349// CreateOrUpdateStaticSiteBuildAppSettingsPreparer prepares the CreateOrUpdateStaticSiteBuildAppSettings request. 350func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string, appSettings StringDictionary) (*http.Request, error) { 351 pathParameters := map[string]interface{}{ 352 "environmentName": autorest.Encode("path", environmentName), 353 "name": autorest.Encode("path", name), 354 "resourceGroupName": autorest.Encode("path", resourceGroupName), 355 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 356 } 357 358 const APIVersion = "2020-12-01" 359 queryParameters := map[string]interface{}{ 360 "api-version": APIVersion, 361 } 362 363 preparer := autorest.CreatePreparer( 364 autorest.AsContentType("application/json; charset=utf-8"), 365 autorest.AsPut(), 366 autorest.WithBaseURL(client.BaseURI), 367 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/config/appsettings", pathParameters), 368 autorest.WithJSON(appSettings), 369 autorest.WithQueryParameters(queryParameters)) 370 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 371} 372 373// CreateOrUpdateStaticSiteBuildAppSettingsSender sends the CreateOrUpdateStaticSiteBuildAppSettings request. The method will close the 374// http.Response Body if it receives an error. 375func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildAppSettingsSender(req *http.Request) (*http.Response, error) { 376 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 377} 378 379// CreateOrUpdateStaticSiteBuildAppSettingsResponder handles the response to the CreateOrUpdateStaticSiteBuildAppSettings request. The method always 380// closes the http.Response Body. 381func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 382 err = autorest.Respond( 383 resp, 384 azure.WithErrorUnlessStatusCode(http.StatusOK), 385 autorest.ByUnmarshallingJSON(&result), 386 autorest.ByClosing()) 387 result.Response = autorest.Response{Response: resp} 388 return 389} 390 391// CreateOrUpdateStaticSiteBuildFunctionAppSettings description for Creates or updates the function app settings of a 392// static site build. 393// Parameters: 394// resourceGroupName - name of the resource group to which the resource belongs. 395// name - name of the static site. 396// environmentName - the stage site identifier. 397// appSettings - the dictionary containing the static site function app settings to update. 398func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildFunctionAppSettings(ctx context.Context, resourceGroupName string, name string, environmentName string, appSettings StringDictionary) (result StringDictionary, err error) { 399 if tracing.IsEnabled() { 400 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateOrUpdateStaticSiteBuildFunctionAppSettings") 401 defer func() { 402 sc := -1 403 if result.Response.Response != nil { 404 sc = result.Response.Response.StatusCode 405 } 406 tracing.EndSpan(ctx, sc, err) 407 }() 408 } 409 if err := validation.Validate([]validation.Validation{ 410 {TargetValue: resourceGroupName, 411 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 412 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 413 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 414 return result, validation.NewError("web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildFunctionAppSettings", err.Error()) 415 } 416 417 req, err := client.CreateOrUpdateStaticSiteBuildFunctionAppSettingsPreparer(ctx, resourceGroupName, name, environmentName, appSettings) 418 if err != nil { 419 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildFunctionAppSettings", nil, "Failure preparing request") 420 return 421 } 422 423 resp, err := client.CreateOrUpdateStaticSiteBuildFunctionAppSettingsSender(req) 424 if err != nil { 425 result.Response = autorest.Response{Response: resp} 426 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildFunctionAppSettings", resp, "Failure sending request") 427 return 428 } 429 430 result, err = client.CreateOrUpdateStaticSiteBuildFunctionAppSettingsResponder(resp) 431 if err != nil { 432 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteBuildFunctionAppSettings", resp, "Failure responding to request") 433 return 434 } 435 436 return 437} 438 439// CreateOrUpdateStaticSiteBuildFunctionAppSettingsPreparer prepares the CreateOrUpdateStaticSiteBuildFunctionAppSettings request. 440func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildFunctionAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string, appSettings StringDictionary) (*http.Request, error) { 441 pathParameters := map[string]interface{}{ 442 "environmentName": autorest.Encode("path", environmentName), 443 "name": autorest.Encode("path", name), 444 "resourceGroupName": autorest.Encode("path", resourceGroupName), 445 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 446 } 447 448 const APIVersion = "2020-12-01" 449 queryParameters := map[string]interface{}{ 450 "api-version": APIVersion, 451 } 452 453 preparer := autorest.CreatePreparer( 454 autorest.AsContentType("application/json; charset=utf-8"), 455 autorest.AsPut(), 456 autorest.WithBaseURL(client.BaseURI), 457 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/config/functionappsettings", pathParameters), 458 autorest.WithJSON(appSettings), 459 autorest.WithQueryParameters(queryParameters)) 460 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 461} 462 463// CreateOrUpdateStaticSiteBuildFunctionAppSettingsSender sends the CreateOrUpdateStaticSiteBuildFunctionAppSettings request. The method will close the 464// http.Response Body if it receives an error. 465func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildFunctionAppSettingsSender(req *http.Request) (*http.Response, error) { 466 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 467} 468 469// CreateOrUpdateStaticSiteBuildFunctionAppSettingsResponder handles the response to the CreateOrUpdateStaticSiteBuildFunctionAppSettings request. The method always 470// closes the http.Response Body. 471func (client StaticSitesClient) CreateOrUpdateStaticSiteBuildFunctionAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 472 err = autorest.Respond( 473 resp, 474 azure.WithErrorUnlessStatusCode(http.StatusOK), 475 autorest.ByUnmarshallingJSON(&result), 476 autorest.ByClosing()) 477 result.Response = autorest.Response{Response: resp} 478 return 479} 480 481// CreateOrUpdateStaticSiteCustomDomain description for Creates a new static site custom domain in an existing resource 482// group and static site. 483// Parameters: 484// resourceGroupName - name of the resource group to which the resource belongs. 485// name - name of the static site. 486// domainName - the custom domain to create. 487// staticSiteCustomDomainRequestPropertiesEnvelope - a JSON representation of the static site custom domain 488// request properties. See example. 489func (client StaticSitesClient) CreateOrUpdateStaticSiteCustomDomain(ctx context.Context, resourceGroupName string, name string, domainName string, staticSiteCustomDomainRequestPropertiesEnvelope StaticSiteCustomDomainRequestPropertiesARMResource) (result StaticSitesCreateOrUpdateStaticSiteCustomDomainFuture, err error) { 490 if tracing.IsEnabled() { 491 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateOrUpdateStaticSiteCustomDomain") 492 defer func() { 493 sc := -1 494 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 495 sc = result.FutureAPI.Response().StatusCode 496 } 497 tracing.EndSpan(ctx, sc, err) 498 }() 499 } 500 if err := validation.Validate([]validation.Validation{ 501 {TargetValue: resourceGroupName, 502 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 503 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 504 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 505 return result, validation.NewError("web.StaticSitesClient", "CreateOrUpdateStaticSiteCustomDomain", err.Error()) 506 } 507 508 req, err := client.CreateOrUpdateStaticSiteCustomDomainPreparer(ctx, resourceGroupName, name, domainName, staticSiteCustomDomainRequestPropertiesEnvelope) 509 if err != nil { 510 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteCustomDomain", nil, "Failure preparing request") 511 return 512 } 513 514 result, err = client.CreateOrUpdateStaticSiteCustomDomainSender(req) 515 if err != nil { 516 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteCustomDomain", nil, "Failure sending request") 517 return 518 } 519 520 return 521} 522 523// CreateOrUpdateStaticSiteCustomDomainPreparer prepares the CreateOrUpdateStaticSiteCustomDomain request. 524func (client StaticSitesClient) CreateOrUpdateStaticSiteCustomDomainPreparer(ctx context.Context, resourceGroupName string, name string, domainName string, staticSiteCustomDomainRequestPropertiesEnvelope StaticSiteCustomDomainRequestPropertiesARMResource) (*http.Request, error) { 525 pathParameters := map[string]interface{}{ 526 "domainName": autorest.Encode("path", domainName), 527 "name": autorest.Encode("path", name), 528 "resourceGroupName": autorest.Encode("path", resourceGroupName), 529 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 530 } 531 532 const APIVersion = "2020-12-01" 533 queryParameters := map[string]interface{}{ 534 "api-version": APIVersion, 535 } 536 537 preparer := autorest.CreatePreparer( 538 autorest.AsContentType("application/json; charset=utf-8"), 539 autorest.AsPut(), 540 autorest.WithBaseURL(client.BaseURI), 541 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/customDomains/{domainName}", pathParameters), 542 autorest.WithJSON(staticSiteCustomDomainRequestPropertiesEnvelope), 543 autorest.WithQueryParameters(queryParameters)) 544 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 545} 546 547// CreateOrUpdateStaticSiteCustomDomainSender sends the CreateOrUpdateStaticSiteCustomDomain request. The method will close the 548// http.Response Body if it receives an error. 549func (client StaticSitesClient) CreateOrUpdateStaticSiteCustomDomainSender(req *http.Request) (future StaticSitesCreateOrUpdateStaticSiteCustomDomainFuture, err error) { 550 var resp *http.Response 551 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 552 if err != nil { 553 return 554 } 555 var azf azure.Future 556 azf, err = azure.NewFutureFromResponse(resp) 557 future.FutureAPI = &azf 558 future.Result = future.result 559 return 560} 561 562// CreateOrUpdateStaticSiteCustomDomainResponder handles the response to the CreateOrUpdateStaticSiteCustomDomain request. The method always 563// closes the http.Response Body. 564func (client StaticSitesClient) CreateOrUpdateStaticSiteCustomDomainResponder(resp *http.Response) (result StaticSiteCustomDomainOverviewARMResource, err error) { 565 err = autorest.Respond( 566 resp, 567 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 568 autorest.ByUnmarshallingJSON(&result), 569 autorest.ByClosing()) 570 result.Response = autorest.Response{Response: resp} 571 return 572} 573 574// CreateOrUpdateStaticSiteFunctionAppSettings description for Creates or updates the function app settings of a static 575// site. 576// Parameters: 577// resourceGroupName - name of the resource group to which the resource belongs. 578// name - name of the static site. 579// appSettings - the dictionary containing the static site function app settings to update. 580func (client StaticSitesClient) CreateOrUpdateStaticSiteFunctionAppSettings(ctx context.Context, resourceGroupName string, name string, appSettings StringDictionary) (result StringDictionary, err error) { 581 if tracing.IsEnabled() { 582 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateOrUpdateStaticSiteFunctionAppSettings") 583 defer func() { 584 sc := -1 585 if result.Response.Response != nil { 586 sc = result.Response.Response.StatusCode 587 } 588 tracing.EndSpan(ctx, sc, err) 589 }() 590 } 591 if err := validation.Validate([]validation.Validation{ 592 {TargetValue: resourceGroupName, 593 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 594 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 595 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 596 return result, validation.NewError("web.StaticSitesClient", "CreateOrUpdateStaticSiteFunctionAppSettings", err.Error()) 597 } 598 599 req, err := client.CreateOrUpdateStaticSiteFunctionAppSettingsPreparer(ctx, resourceGroupName, name, appSettings) 600 if err != nil { 601 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteFunctionAppSettings", nil, "Failure preparing request") 602 return 603 } 604 605 resp, err := client.CreateOrUpdateStaticSiteFunctionAppSettingsSender(req) 606 if err != nil { 607 result.Response = autorest.Response{Response: resp} 608 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteFunctionAppSettings", resp, "Failure sending request") 609 return 610 } 611 612 result, err = client.CreateOrUpdateStaticSiteFunctionAppSettingsResponder(resp) 613 if err != nil { 614 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateOrUpdateStaticSiteFunctionAppSettings", resp, "Failure responding to request") 615 return 616 } 617 618 return 619} 620 621// CreateOrUpdateStaticSiteFunctionAppSettingsPreparer prepares the CreateOrUpdateStaticSiteFunctionAppSettings request. 622func (client StaticSitesClient) CreateOrUpdateStaticSiteFunctionAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string, appSettings StringDictionary) (*http.Request, error) { 623 pathParameters := map[string]interface{}{ 624 "name": autorest.Encode("path", name), 625 "resourceGroupName": autorest.Encode("path", resourceGroupName), 626 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 627 } 628 629 const APIVersion = "2020-12-01" 630 queryParameters := map[string]interface{}{ 631 "api-version": APIVersion, 632 } 633 634 preparer := autorest.CreatePreparer( 635 autorest.AsContentType("application/json; charset=utf-8"), 636 autorest.AsPut(), 637 autorest.WithBaseURL(client.BaseURI), 638 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/config/functionappsettings", pathParameters), 639 autorest.WithJSON(appSettings), 640 autorest.WithQueryParameters(queryParameters)) 641 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 642} 643 644// CreateOrUpdateStaticSiteFunctionAppSettingsSender sends the CreateOrUpdateStaticSiteFunctionAppSettings request. The method will close the 645// http.Response Body if it receives an error. 646func (client StaticSitesClient) CreateOrUpdateStaticSiteFunctionAppSettingsSender(req *http.Request) (*http.Response, error) { 647 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 648} 649 650// CreateOrUpdateStaticSiteFunctionAppSettingsResponder handles the response to the CreateOrUpdateStaticSiteFunctionAppSettings request. The method always 651// closes the http.Response Body. 652func (client StaticSitesClient) CreateOrUpdateStaticSiteFunctionAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 653 err = autorest.Respond( 654 resp, 655 azure.WithErrorUnlessStatusCode(http.StatusOK), 656 autorest.ByUnmarshallingJSON(&result), 657 autorest.ByClosing()) 658 result.Response = autorest.Response{Response: resp} 659 return 660} 661 662// CreateUserRolesInvitationLink description for Creates an invitation link for a user with the role 663// Parameters: 664// resourceGroupName - name of the resource group to which the resource belongs. 665// name - name of the static site. 666func (client StaticSitesClient) CreateUserRolesInvitationLink(ctx context.Context, resourceGroupName string, name string, staticSiteUserRolesInvitationEnvelope StaticSiteUserInvitationRequestResource) (result StaticSiteUserInvitationResponseResource, err error) { 667 if tracing.IsEnabled() { 668 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateUserRolesInvitationLink") 669 defer func() { 670 sc := -1 671 if result.Response.Response != nil { 672 sc = result.Response.Response.StatusCode 673 } 674 tracing.EndSpan(ctx, sc, err) 675 }() 676 } 677 if err := validation.Validate([]validation.Validation{ 678 {TargetValue: resourceGroupName, 679 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 680 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 681 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 682 return result, validation.NewError("web.StaticSitesClient", "CreateUserRolesInvitationLink", err.Error()) 683 } 684 685 req, err := client.CreateUserRolesInvitationLinkPreparer(ctx, resourceGroupName, name, staticSiteUserRolesInvitationEnvelope) 686 if err != nil { 687 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateUserRolesInvitationLink", nil, "Failure preparing request") 688 return 689 } 690 691 resp, err := client.CreateUserRolesInvitationLinkSender(req) 692 if err != nil { 693 result.Response = autorest.Response{Response: resp} 694 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateUserRolesInvitationLink", resp, "Failure sending request") 695 return 696 } 697 698 result, err = client.CreateUserRolesInvitationLinkResponder(resp) 699 if err != nil { 700 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateUserRolesInvitationLink", resp, "Failure responding to request") 701 return 702 } 703 704 return 705} 706 707// CreateUserRolesInvitationLinkPreparer prepares the CreateUserRolesInvitationLink request. 708func (client StaticSitesClient) CreateUserRolesInvitationLinkPreparer(ctx context.Context, resourceGroupName string, name string, staticSiteUserRolesInvitationEnvelope StaticSiteUserInvitationRequestResource) (*http.Request, error) { 709 pathParameters := map[string]interface{}{ 710 "name": autorest.Encode("path", name), 711 "resourceGroupName": autorest.Encode("path", resourceGroupName), 712 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 713 } 714 715 const APIVersion = "2020-12-01" 716 queryParameters := map[string]interface{}{ 717 "api-version": APIVersion, 718 } 719 720 preparer := autorest.CreatePreparer( 721 autorest.AsContentType("application/json; charset=utf-8"), 722 autorest.AsPost(), 723 autorest.WithBaseURL(client.BaseURI), 724 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/createUserInvitation", pathParameters), 725 autorest.WithJSON(staticSiteUserRolesInvitationEnvelope), 726 autorest.WithQueryParameters(queryParameters)) 727 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 728} 729 730// CreateUserRolesInvitationLinkSender sends the CreateUserRolesInvitationLink request. The method will close the 731// http.Response Body if it receives an error. 732func (client StaticSitesClient) CreateUserRolesInvitationLinkSender(req *http.Request) (*http.Response, error) { 733 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 734} 735 736// CreateUserRolesInvitationLinkResponder handles the response to the CreateUserRolesInvitationLink request. The method always 737// closes the http.Response Body. 738func (client StaticSitesClient) CreateUserRolesInvitationLinkResponder(resp *http.Response) (result StaticSiteUserInvitationResponseResource, err error) { 739 err = autorest.Respond( 740 resp, 741 azure.WithErrorUnlessStatusCode(http.StatusOK), 742 autorest.ByUnmarshallingJSON(&result), 743 autorest.ByClosing()) 744 result.Response = autorest.Response{Response: resp} 745 return 746} 747 748// CreateZipDeploymentForStaticSite description for Deploys zipped content to a static site. 749// Parameters: 750// resourceGroupName - name of the resource group to which the resource belongs. 751// name - name of the static site. 752// staticSiteZipDeploymentEnvelope - a JSON representation of the StaticSiteZipDeployment properties. See 753// example. 754func (client StaticSitesClient) CreateZipDeploymentForStaticSite(ctx context.Context, resourceGroupName string, name string, staticSiteZipDeploymentEnvelope StaticSiteZipDeploymentARMResource) (result StaticSitesCreateZipDeploymentForStaticSiteFuture, err error) { 755 if tracing.IsEnabled() { 756 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateZipDeploymentForStaticSite") 757 defer func() { 758 sc := -1 759 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 760 sc = result.FutureAPI.Response().StatusCode 761 } 762 tracing.EndSpan(ctx, sc, err) 763 }() 764 } 765 if err := validation.Validate([]validation.Validation{ 766 {TargetValue: resourceGroupName, 767 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 768 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 769 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 770 return result, validation.NewError("web.StaticSitesClient", "CreateZipDeploymentForStaticSite", err.Error()) 771 } 772 773 req, err := client.CreateZipDeploymentForStaticSitePreparer(ctx, resourceGroupName, name, staticSiteZipDeploymentEnvelope) 774 if err != nil { 775 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateZipDeploymentForStaticSite", nil, "Failure preparing request") 776 return 777 } 778 779 result, err = client.CreateZipDeploymentForStaticSiteSender(req) 780 if err != nil { 781 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateZipDeploymentForStaticSite", nil, "Failure sending request") 782 return 783 } 784 785 return 786} 787 788// CreateZipDeploymentForStaticSitePreparer prepares the CreateZipDeploymentForStaticSite request. 789func (client StaticSitesClient) CreateZipDeploymentForStaticSitePreparer(ctx context.Context, resourceGroupName string, name string, staticSiteZipDeploymentEnvelope StaticSiteZipDeploymentARMResource) (*http.Request, error) { 790 pathParameters := map[string]interface{}{ 791 "name": autorest.Encode("path", name), 792 "resourceGroupName": autorest.Encode("path", resourceGroupName), 793 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 794 } 795 796 const APIVersion = "2020-12-01" 797 queryParameters := map[string]interface{}{ 798 "api-version": APIVersion, 799 } 800 801 preparer := autorest.CreatePreparer( 802 autorest.AsContentType("application/json; charset=utf-8"), 803 autorest.AsPost(), 804 autorest.WithBaseURL(client.BaseURI), 805 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/zipdeploy", pathParameters), 806 autorest.WithJSON(staticSiteZipDeploymentEnvelope), 807 autorest.WithQueryParameters(queryParameters)) 808 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 809} 810 811// CreateZipDeploymentForStaticSiteSender sends the CreateZipDeploymentForStaticSite request. The method will close the 812// http.Response Body if it receives an error. 813func (client StaticSitesClient) CreateZipDeploymentForStaticSiteSender(req *http.Request) (future StaticSitesCreateZipDeploymentForStaticSiteFuture, err error) { 814 var resp *http.Response 815 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 816 if err != nil { 817 return 818 } 819 var azf azure.Future 820 azf, err = azure.NewFutureFromResponse(resp) 821 future.FutureAPI = &azf 822 future.Result = future.result 823 return 824} 825 826// CreateZipDeploymentForStaticSiteResponder handles the response to the CreateZipDeploymentForStaticSite request. The method always 827// closes the http.Response Body. 828func (client StaticSitesClient) CreateZipDeploymentForStaticSiteResponder(resp *http.Response) (result autorest.Response, err error) { 829 err = autorest.Respond( 830 resp, 831 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 832 autorest.ByClosing()) 833 result.Response = resp 834 return 835} 836 837// CreateZipDeploymentForStaticSiteBuild description for Deploys zipped content to a specific environment of a static 838// site. 839// Parameters: 840// resourceGroupName - name of the resource group to which the resource belongs. 841// name - name of the static site. 842// environmentName - name of the environment. 843// staticSiteZipDeploymentEnvelope - a JSON representation of the StaticSiteZipDeployment properties. See 844// example. 845func (client StaticSitesClient) CreateZipDeploymentForStaticSiteBuild(ctx context.Context, resourceGroupName string, name string, environmentName string, staticSiteZipDeploymentEnvelope StaticSiteZipDeploymentARMResource) (result StaticSitesCreateZipDeploymentForStaticSiteBuildFuture, err error) { 846 if tracing.IsEnabled() { 847 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.CreateZipDeploymentForStaticSiteBuild") 848 defer func() { 849 sc := -1 850 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 851 sc = result.FutureAPI.Response().StatusCode 852 } 853 tracing.EndSpan(ctx, sc, err) 854 }() 855 } 856 if err := validation.Validate([]validation.Validation{ 857 {TargetValue: resourceGroupName, 858 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 859 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 860 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 861 return result, validation.NewError("web.StaticSitesClient", "CreateZipDeploymentForStaticSiteBuild", err.Error()) 862 } 863 864 req, err := client.CreateZipDeploymentForStaticSiteBuildPreparer(ctx, resourceGroupName, name, environmentName, staticSiteZipDeploymentEnvelope) 865 if err != nil { 866 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateZipDeploymentForStaticSiteBuild", nil, "Failure preparing request") 867 return 868 } 869 870 result, err = client.CreateZipDeploymentForStaticSiteBuildSender(req) 871 if err != nil { 872 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "CreateZipDeploymentForStaticSiteBuild", nil, "Failure sending request") 873 return 874 } 875 876 return 877} 878 879// CreateZipDeploymentForStaticSiteBuildPreparer prepares the CreateZipDeploymentForStaticSiteBuild request. 880func (client StaticSitesClient) CreateZipDeploymentForStaticSiteBuildPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string, staticSiteZipDeploymentEnvelope StaticSiteZipDeploymentARMResource) (*http.Request, error) { 881 pathParameters := map[string]interface{}{ 882 "environmentName": autorest.Encode("path", environmentName), 883 "name": autorest.Encode("path", name), 884 "resourceGroupName": autorest.Encode("path", resourceGroupName), 885 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 886 } 887 888 const APIVersion = "2020-12-01" 889 queryParameters := map[string]interface{}{ 890 "api-version": APIVersion, 891 } 892 893 preparer := autorest.CreatePreparer( 894 autorest.AsContentType("application/json; charset=utf-8"), 895 autorest.AsPost(), 896 autorest.WithBaseURL(client.BaseURI), 897 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/zipdeploy", pathParameters), 898 autorest.WithJSON(staticSiteZipDeploymentEnvelope), 899 autorest.WithQueryParameters(queryParameters)) 900 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 901} 902 903// CreateZipDeploymentForStaticSiteBuildSender sends the CreateZipDeploymentForStaticSiteBuild request. The method will close the 904// http.Response Body if it receives an error. 905func (client StaticSitesClient) CreateZipDeploymentForStaticSiteBuildSender(req *http.Request) (future StaticSitesCreateZipDeploymentForStaticSiteBuildFuture, err error) { 906 var resp *http.Response 907 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 908 if err != nil { 909 return 910 } 911 var azf azure.Future 912 azf, err = azure.NewFutureFromResponse(resp) 913 future.FutureAPI = &azf 914 future.Result = future.result 915 return 916} 917 918// CreateZipDeploymentForStaticSiteBuildResponder handles the response to the CreateZipDeploymentForStaticSiteBuild request. The method always 919// closes the http.Response Body. 920func (client StaticSitesClient) CreateZipDeploymentForStaticSiteBuildResponder(resp *http.Response) (result autorest.Response, err error) { 921 err = autorest.Respond( 922 resp, 923 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 924 autorest.ByClosing()) 925 result.Response = resp 926 return 927} 928 929// DeletePrivateEndpointConnection description for Deletes a private endpoint connection 930// Parameters: 931// resourceGroupName - name of the resource group to which the resource belongs. 932// name - name of the static site. 933// privateEndpointConnectionName - name of the private endpoint connection. 934func (client StaticSitesClient) DeletePrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string) (result StaticSitesDeletePrivateEndpointConnectionFuture, err error) { 935 if tracing.IsEnabled() { 936 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DeletePrivateEndpointConnection") 937 defer func() { 938 sc := -1 939 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 940 sc = result.FutureAPI.Response().StatusCode 941 } 942 tracing.EndSpan(ctx, sc, err) 943 }() 944 } 945 if err := validation.Validate([]validation.Validation{ 946 {TargetValue: resourceGroupName, 947 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 948 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 949 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 950 return result, validation.NewError("web.StaticSitesClient", "DeletePrivateEndpointConnection", err.Error()) 951 } 952 953 req, err := client.DeletePrivateEndpointConnectionPreparer(ctx, resourceGroupName, name, privateEndpointConnectionName) 954 if err != nil { 955 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeletePrivateEndpointConnection", nil, "Failure preparing request") 956 return 957 } 958 959 result, err = client.DeletePrivateEndpointConnectionSender(req) 960 if err != nil { 961 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeletePrivateEndpointConnection", nil, "Failure sending request") 962 return 963 } 964 965 return 966} 967 968// DeletePrivateEndpointConnectionPreparer prepares the DeletePrivateEndpointConnection request. 969func (client StaticSitesClient) DeletePrivateEndpointConnectionPreparer(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string) (*http.Request, error) { 970 pathParameters := map[string]interface{}{ 971 "name": autorest.Encode("path", name), 972 "privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName), 973 "resourceGroupName": autorest.Encode("path", resourceGroupName), 974 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 975 } 976 977 const APIVersion = "2020-12-01" 978 queryParameters := map[string]interface{}{ 979 "api-version": APIVersion, 980 } 981 982 preparer := autorest.CreatePreparer( 983 autorest.AsDelete(), 984 autorest.WithBaseURL(client.BaseURI), 985 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters), 986 autorest.WithQueryParameters(queryParameters)) 987 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 988} 989 990// DeletePrivateEndpointConnectionSender sends the DeletePrivateEndpointConnection request. The method will close the 991// http.Response Body if it receives an error. 992func (client StaticSitesClient) DeletePrivateEndpointConnectionSender(req *http.Request) (future StaticSitesDeletePrivateEndpointConnectionFuture, err error) { 993 var resp *http.Response 994 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 995 if err != nil { 996 return 997 } 998 var azf azure.Future 999 azf, err = azure.NewFutureFromResponse(resp) 1000 future.FutureAPI = &azf 1001 future.Result = future.result 1002 return 1003} 1004 1005// DeletePrivateEndpointConnectionResponder handles the response to the DeletePrivateEndpointConnection request. The method always 1006// closes the http.Response Body. 1007func (client StaticSitesClient) DeletePrivateEndpointConnectionResponder(resp *http.Response) (result SetObject, err error) { 1008 err = autorest.Respond( 1009 resp, 1010 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 1011 autorest.ByUnmarshallingJSON(&result), 1012 autorest.ByClosing()) 1013 result.Response = autorest.Response{Response: resp} 1014 return 1015} 1016 1017// DeleteStaticSite description for Deletes a static site. 1018// Parameters: 1019// resourceGroupName - name of the resource group to which the resource belongs. 1020// name - name of the static site to delete. 1021func (client StaticSitesClient) DeleteStaticSite(ctx context.Context, resourceGroupName string, name string) (result StaticSitesDeleteStaticSiteFuture, err error) { 1022 if tracing.IsEnabled() { 1023 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DeleteStaticSite") 1024 defer func() { 1025 sc := -1 1026 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1027 sc = result.FutureAPI.Response().StatusCode 1028 } 1029 tracing.EndSpan(ctx, sc, err) 1030 }() 1031 } 1032 if err := validation.Validate([]validation.Validation{ 1033 {TargetValue: resourceGroupName, 1034 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1035 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1036 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1037 return result, validation.NewError("web.StaticSitesClient", "DeleteStaticSite", err.Error()) 1038 } 1039 1040 req, err := client.DeleteStaticSitePreparer(ctx, resourceGroupName, name) 1041 if err != nil { 1042 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSite", nil, "Failure preparing request") 1043 return 1044 } 1045 1046 result, err = client.DeleteStaticSiteSender(req) 1047 if err != nil { 1048 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSite", nil, "Failure sending request") 1049 return 1050 } 1051 1052 return 1053} 1054 1055// DeleteStaticSitePreparer prepares the DeleteStaticSite request. 1056func (client StaticSitesClient) DeleteStaticSitePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 1057 pathParameters := map[string]interface{}{ 1058 "name": autorest.Encode("path", name), 1059 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1060 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1061 } 1062 1063 const APIVersion = "2020-12-01" 1064 queryParameters := map[string]interface{}{ 1065 "api-version": APIVersion, 1066 } 1067 1068 preparer := autorest.CreatePreparer( 1069 autorest.AsDelete(), 1070 autorest.WithBaseURL(client.BaseURI), 1071 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}", pathParameters), 1072 autorest.WithQueryParameters(queryParameters)) 1073 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1074} 1075 1076// DeleteStaticSiteSender sends the DeleteStaticSite request. The method will close the 1077// http.Response Body if it receives an error. 1078func (client StaticSitesClient) DeleteStaticSiteSender(req *http.Request) (future StaticSitesDeleteStaticSiteFuture, err error) { 1079 var resp *http.Response 1080 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1081 if err != nil { 1082 return 1083 } 1084 var azf azure.Future 1085 azf, err = azure.NewFutureFromResponse(resp) 1086 future.FutureAPI = &azf 1087 future.Result = future.result 1088 return 1089} 1090 1091// DeleteStaticSiteResponder handles the response to the DeleteStaticSite request. The method always 1092// closes the http.Response Body. 1093func (client StaticSitesClient) DeleteStaticSiteResponder(resp *http.Response) (result autorest.Response, err error) { 1094 err = autorest.Respond( 1095 resp, 1096 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1097 autorest.ByClosing()) 1098 result.Response = resp 1099 return 1100} 1101 1102// DeleteStaticSiteBuild description for Deletes a static site build. 1103// Parameters: 1104// resourceGroupName - name of the resource group to which the resource belongs. 1105// name - name of the static site. 1106// environmentName - the stage site identifier. 1107func (client StaticSitesClient) DeleteStaticSiteBuild(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StaticSitesDeleteStaticSiteBuildFuture, err error) { 1108 if tracing.IsEnabled() { 1109 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DeleteStaticSiteBuild") 1110 defer func() { 1111 sc := -1 1112 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1113 sc = result.FutureAPI.Response().StatusCode 1114 } 1115 tracing.EndSpan(ctx, sc, err) 1116 }() 1117 } 1118 if err := validation.Validate([]validation.Validation{ 1119 {TargetValue: resourceGroupName, 1120 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1121 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1122 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1123 return result, validation.NewError("web.StaticSitesClient", "DeleteStaticSiteBuild", err.Error()) 1124 } 1125 1126 req, err := client.DeleteStaticSiteBuildPreparer(ctx, resourceGroupName, name, environmentName) 1127 if err != nil { 1128 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSiteBuild", nil, "Failure preparing request") 1129 return 1130 } 1131 1132 result, err = client.DeleteStaticSiteBuildSender(req) 1133 if err != nil { 1134 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSiteBuild", nil, "Failure sending request") 1135 return 1136 } 1137 1138 return 1139} 1140 1141// DeleteStaticSiteBuildPreparer prepares the DeleteStaticSiteBuild request. 1142func (client StaticSitesClient) DeleteStaticSiteBuildPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string) (*http.Request, error) { 1143 pathParameters := map[string]interface{}{ 1144 "environmentName": autorest.Encode("path", environmentName), 1145 "name": autorest.Encode("path", name), 1146 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1147 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1148 } 1149 1150 const APIVersion = "2020-12-01" 1151 queryParameters := map[string]interface{}{ 1152 "api-version": APIVersion, 1153 } 1154 1155 preparer := autorest.CreatePreparer( 1156 autorest.AsDelete(), 1157 autorest.WithBaseURL(client.BaseURI), 1158 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}", pathParameters), 1159 autorest.WithQueryParameters(queryParameters)) 1160 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1161} 1162 1163// DeleteStaticSiteBuildSender sends the DeleteStaticSiteBuild request. The method will close the 1164// http.Response Body if it receives an error. 1165func (client StaticSitesClient) DeleteStaticSiteBuildSender(req *http.Request) (future StaticSitesDeleteStaticSiteBuildFuture, err error) { 1166 var resp *http.Response 1167 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1168 if err != nil { 1169 return 1170 } 1171 var azf azure.Future 1172 azf, err = azure.NewFutureFromResponse(resp) 1173 future.FutureAPI = &azf 1174 future.Result = future.result 1175 return 1176} 1177 1178// DeleteStaticSiteBuildResponder handles the response to the DeleteStaticSiteBuild request. The method always 1179// closes the http.Response Body. 1180func (client StaticSitesClient) DeleteStaticSiteBuildResponder(resp *http.Response) (result autorest.Response, err error) { 1181 err = autorest.Respond( 1182 resp, 1183 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 1184 autorest.ByClosing()) 1185 result.Response = resp 1186 return 1187} 1188 1189// DeleteStaticSiteCustomDomain description for Deletes a custom domain. 1190// Parameters: 1191// resourceGroupName - name of the resource group to which the resource belongs. 1192// name - name of the static site. 1193// domainName - the custom domain to delete. 1194func (client StaticSitesClient) DeleteStaticSiteCustomDomain(ctx context.Context, resourceGroupName string, name string, domainName string) (result StaticSitesDeleteStaticSiteCustomDomainFuture, err error) { 1195 if tracing.IsEnabled() { 1196 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DeleteStaticSiteCustomDomain") 1197 defer func() { 1198 sc := -1 1199 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1200 sc = result.FutureAPI.Response().StatusCode 1201 } 1202 tracing.EndSpan(ctx, sc, err) 1203 }() 1204 } 1205 if err := validation.Validate([]validation.Validation{ 1206 {TargetValue: resourceGroupName, 1207 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1208 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1209 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1210 return result, validation.NewError("web.StaticSitesClient", "DeleteStaticSiteCustomDomain", err.Error()) 1211 } 1212 1213 req, err := client.DeleteStaticSiteCustomDomainPreparer(ctx, resourceGroupName, name, domainName) 1214 if err != nil { 1215 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSiteCustomDomain", nil, "Failure preparing request") 1216 return 1217 } 1218 1219 result, err = client.DeleteStaticSiteCustomDomainSender(req) 1220 if err != nil { 1221 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSiteCustomDomain", nil, "Failure sending request") 1222 return 1223 } 1224 1225 return 1226} 1227 1228// DeleteStaticSiteCustomDomainPreparer prepares the DeleteStaticSiteCustomDomain request. 1229func (client StaticSitesClient) DeleteStaticSiteCustomDomainPreparer(ctx context.Context, resourceGroupName string, name string, domainName string) (*http.Request, error) { 1230 pathParameters := map[string]interface{}{ 1231 "domainName": autorest.Encode("path", domainName), 1232 "name": autorest.Encode("path", name), 1233 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1234 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1235 } 1236 1237 const APIVersion = "2020-12-01" 1238 queryParameters := map[string]interface{}{ 1239 "api-version": APIVersion, 1240 } 1241 1242 preparer := autorest.CreatePreparer( 1243 autorest.AsDelete(), 1244 autorest.WithBaseURL(client.BaseURI), 1245 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/customDomains/{domainName}", pathParameters), 1246 autorest.WithQueryParameters(queryParameters)) 1247 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1248} 1249 1250// DeleteStaticSiteCustomDomainSender sends the DeleteStaticSiteCustomDomain request. The method will close the 1251// http.Response Body if it receives an error. 1252func (client StaticSitesClient) DeleteStaticSiteCustomDomainSender(req *http.Request) (future StaticSitesDeleteStaticSiteCustomDomainFuture, err error) { 1253 var resp *http.Response 1254 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1255 if err != nil { 1256 return 1257 } 1258 var azf azure.Future 1259 azf, err = azure.NewFutureFromResponse(resp) 1260 future.FutureAPI = &azf 1261 future.Result = future.result 1262 return 1263} 1264 1265// DeleteStaticSiteCustomDomainResponder handles the response to the DeleteStaticSiteCustomDomain request. The method always 1266// closes the http.Response Body. 1267func (client StaticSitesClient) DeleteStaticSiteCustomDomainResponder(resp *http.Response) (result autorest.Response, err error) { 1268 err = autorest.Respond( 1269 resp, 1270 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1271 autorest.ByClosing()) 1272 result.Response = resp 1273 return 1274} 1275 1276// DeleteStaticSiteUser description for Deletes the user entry from the static site. 1277// Parameters: 1278// resourceGroupName - name of the resource group to which the resource belongs. 1279// name - name of the staticsite. 1280// authprovider - the auth provider for this user. 1281// userid - the user id of the user. 1282func (client StaticSitesClient) DeleteStaticSiteUser(ctx context.Context, resourceGroupName string, name string, authprovider string, userid string) (result autorest.Response, err error) { 1283 if tracing.IsEnabled() { 1284 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DeleteStaticSiteUser") 1285 defer func() { 1286 sc := -1 1287 if result.Response != nil { 1288 sc = result.Response.StatusCode 1289 } 1290 tracing.EndSpan(ctx, sc, err) 1291 }() 1292 } 1293 if err := validation.Validate([]validation.Validation{ 1294 {TargetValue: resourceGroupName, 1295 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1296 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1297 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1298 return result, validation.NewError("web.StaticSitesClient", "DeleteStaticSiteUser", err.Error()) 1299 } 1300 1301 req, err := client.DeleteStaticSiteUserPreparer(ctx, resourceGroupName, name, authprovider, userid) 1302 if err != nil { 1303 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSiteUser", nil, "Failure preparing request") 1304 return 1305 } 1306 1307 resp, err := client.DeleteStaticSiteUserSender(req) 1308 if err != nil { 1309 result.Response = resp 1310 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSiteUser", resp, "Failure sending request") 1311 return 1312 } 1313 1314 result, err = client.DeleteStaticSiteUserResponder(resp) 1315 if err != nil { 1316 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DeleteStaticSiteUser", resp, "Failure responding to request") 1317 return 1318 } 1319 1320 return 1321} 1322 1323// DeleteStaticSiteUserPreparer prepares the DeleteStaticSiteUser request. 1324func (client StaticSitesClient) DeleteStaticSiteUserPreparer(ctx context.Context, resourceGroupName string, name string, authprovider string, userid string) (*http.Request, error) { 1325 pathParameters := map[string]interface{}{ 1326 "authprovider": autorest.Encode("path", authprovider), 1327 "name": autorest.Encode("path", name), 1328 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1329 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1330 "userid": autorest.Encode("path", userid), 1331 } 1332 1333 const APIVersion = "2020-12-01" 1334 queryParameters := map[string]interface{}{ 1335 "api-version": APIVersion, 1336 } 1337 1338 preparer := autorest.CreatePreparer( 1339 autorest.AsDelete(), 1340 autorest.WithBaseURL(client.BaseURI), 1341 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/authproviders/{authprovider}/users/{userid}", pathParameters), 1342 autorest.WithQueryParameters(queryParameters)) 1343 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1344} 1345 1346// DeleteStaticSiteUserSender sends the DeleteStaticSiteUser request. The method will close the 1347// http.Response Body if it receives an error. 1348func (client StaticSitesClient) DeleteStaticSiteUserSender(req *http.Request) (*http.Response, error) { 1349 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1350} 1351 1352// DeleteStaticSiteUserResponder handles the response to the DeleteStaticSiteUser request. The method always 1353// closes the http.Response Body. 1354func (client StaticSitesClient) DeleteStaticSiteUserResponder(resp *http.Response) (result autorest.Response, err error) { 1355 err = autorest.Respond( 1356 resp, 1357 azure.WithErrorUnlessStatusCode(http.StatusOK), 1358 autorest.ByClosing()) 1359 result.Response = resp 1360 return 1361} 1362 1363// DetachStaticSite description for Detaches a static site. 1364// Parameters: 1365// resourceGroupName - name of the resource group to which the resource belongs. 1366// name - name of the static site to detach. 1367func (client StaticSitesClient) DetachStaticSite(ctx context.Context, resourceGroupName string, name string) (result StaticSitesDetachStaticSiteFuture, err error) { 1368 if tracing.IsEnabled() { 1369 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DetachStaticSite") 1370 defer func() { 1371 sc := -1 1372 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1373 sc = result.FutureAPI.Response().StatusCode 1374 } 1375 tracing.EndSpan(ctx, sc, err) 1376 }() 1377 } 1378 if err := validation.Validate([]validation.Validation{ 1379 {TargetValue: resourceGroupName, 1380 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1381 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1382 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1383 return result, validation.NewError("web.StaticSitesClient", "DetachStaticSite", err.Error()) 1384 } 1385 1386 req, err := client.DetachStaticSitePreparer(ctx, resourceGroupName, name) 1387 if err != nil { 1388 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachStaticSite", nil, "Failure preparing request") 1389 return 1390 } 1391 1392 result, err = client.DetachStaticSiteSender(req) 1393 if err != nil { 1394 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachStaticSite", nil, "Failure sending request") 1395 return 1396 } 1397 1398 return 1399} 1400 1401// DetachStaticSitePreparer prepares the DetachStaticSite request. 1402func (client StaticSitesClient) DetachStaticSitePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 1403 pathParameters := map[string]interface{}{ 1404 "name": autorest.Encode("path", name), 1405 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1406 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1407 } 1408 1409 const APIVersion = "2020-12-01" 1410 queryParameters := map[string]interface{}{ 1411 "api-version": APIVersion, 1412 } 1413 1414 preparer := autorest.CreatePreparer( 1415 autorest.AsPost(), 1416 autorest.WithBaseURL(client.BaseURI), 1417 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/detach", pathParameters), 1418 autorest.WithQueryParameters(queryParameters)) 1419 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1420} 1421 1422// DetachStaticSiteSender sends the DetachStaticSite request. The method will close the 1423// http.Response Body if it receives an error. 1424func (client StaticSitesClient) DetachStaticSiteSender(req *http.Request) (future StaticSitesDetachStaticSiteFuture, err error) { 1425 var resp *http.Response 1426 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1427 if err != nil { 1428 return 1429 } 1430 var azf azure.Future 1431 azf, err = azure.NewFutureFromResponse(resp) 1432 future.FutureAPI = &azf 1433 future.Result = future.result 1434 return 1435} 1436 1437// DetachStaticSiteResponder handles the response to the DetachStaticSite request. The method always 1438// closes the http.Response Body. 1439func (client StaticSitesClient) DetachStaticSiteResponder(resp *http.Response) (result autorest.Response, err error) { 1440 err = autorest.Respond( 1441 resp, 1442 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1443 autorest.ByClosing()) 1444 result.Response = resp 1445 return 1446} 1447 1448// DetachUserProvidedFunctionAppFromStaticSite description for Detach the user provided function app from the static 1449// site 1450// Parameters: 1451// resourceGroupName - name of the resource group to which the resource belongs. 1452// name - name of the static site. 1453// functionAppName - name of the function app registered with the static site. 1454func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSite(ctx context.Context, resourceGroupName string, name string, functionAppName string) (result autorest.Response, err error) { 1455 if tracing.IsEnabled() { 1456 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DetachUserProvidedFunctionAppFromStaticSite") 1457 defer func() { 1458 sc := -1 1459 if result.Response != nil { 1460 sc = result.Response.StatusCode 1461 } 1462 tracing.EndSpan(ctx, sc, err) 1463 }() 1464 } 1465 if err := validation.Validate([]validation.Validation{ 1466 {TargetValue: resourceGroupName, 1467 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1468 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1469 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1470 return result, validation.NewError("web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSite", err.Error()) 1471 } 1472 1473 req, err := client.DetachUserProvidedFunctionAppFromStaticSitePreparer(ctx, resourceGroupName, name, functionAppName) 1474 if err != nil { 1475 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSite", nil, "Failure preparing request") 1476 return 1477 } 1478 1479 resp, err := client.DetachUserProvidedFunctionAppFromStaticSiteSender(req) 1480 if err != nil { 1481 result.Response = resp 1482 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSite", resp, "Failure sending request") 1483 return 1484 } 1485 1486 result, err = client.DetachUserProvidedFunctionAppFromStaticSiteResponder(resp) 1487 if err != nil { 1488 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSite", resp, "Failure responding to request") 1489 return 1490 } 1491 1492 return 1493} 1494 1495// DetachUserProvidedFunctionAppFromStaticSitePreparer prepares the DetachUserProvidedFunctionAppFromStaticSite request. 1496func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSitePreparer(ctx context.Context, resourceGroupName string, name string, functionAppName string) (*http.Request, error) { 1497 pathParameters := map[string]interface{}{ 1498 "functionAppName": autorest.Encode("path", functionAppName), 1499 "name": autorest.Encode("path", name), 1500 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1501 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1502 } 1503 1504 const APIVersion = "2020-12-01" 1505 queryParameters := map[string]interface{}{ 1506 "api-version": APIVersion, 1507 } 1508 1509 preparer := autorest.CreatePreparer( 1510 autorest.AsDelete(), 1511 autorest.WithBaseURL(client.BaseURI), 1512 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/userProvidedFunctionApps/{functionAppName}", pathParameters), 1513 autorest.WithQueryParameters(queryParameters)) 1514 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1515} 1516 1517// DetachUserProvidedFunctionAppFromStaticSiteSender sends the DetachUserProvidedFunctionAppFromStaticSite request. The method will close the 1518// http.Response Body if it receives an error. 1519func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSiteSender(req *http.Request) (*http.Response, error) { 1520 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1521} 1522 1523// DetachUserProvidedFunctionAppFromStaticSiteResponder handles the response to the DetachUserProvidedFunctionAppFromStaticSite request. The method always 1524// closes the http.Response Body. 1525func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSiteResponder(resp *http.Response) (result autorest.Response, err error) { 1526 err = autorest.Respond( 1527 resp, 1528 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 1529 autorest.ByClosing()) 1530 result.Response = resp 1531 return 1532} 1533 1534// DetachUserProvidedFunctionAppFromStaticSiteBuild description for Detach the user provided function app from the 1535// static site build 1536// Parameters: 1537// resourceGroupName - name of the resource group to which the resource belongs. 1538// name - name of the static site. 1539// environmentName - the stage site identifier. 1540// functionAppName - name of the function app registered with the static site build. 1541func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSiteBuild(ctx context.Context, resourceGroupName string, name string, environmentName string, functionAppName string) (result autorest.Response, err error) { 1542 if tracing.IsEnabled() { 1543 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.DetachUserProvidedFunctionAppFromStaticSiteBuild") 1544 defer func() { 1545 sc := -1 1546 if result.Response != nil { 1547 sc = result.Response.StatusCode 1548 } 1549 tracing.EndSpan(ctx, sc, err) 1550 }() 1551 } 1552 if err := validation.Validate([]validation.Validation{ 1553 {TargetValue: resourceGroupName, 1554 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1555 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1556 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1557 return result, validation.NewError("web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSiteBuild", err.Error()) 1558 } 1559 1560 req, err := client.DetachUserProvidedFunctionAppFromStaticSiteBuildPreparer(ctx, resourceGroupName, name, environmentName, functionAppName) 1561 if err != nil { 1562 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSiteBuild", nil, "Failure preparing request") 1563 return 1564 } 1565 1566 resp, err := client.DetachUserProvidedFunctionAppFromStaticSiteBuildSender(req) 1567 if err != nil { 1568 result.Response = resp 1569 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSiteBuild", resp, "Failure sending request") 1570 return 1571 } 1572 1573 result, err = client.DetachUserProvidedFunctionAppFromStaticSiteBuildResponder(resp) 1574 if err != nil { 1575 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "DetachUserProvidedFunctionAppFromStaticSiteBuild", resp, "Failure responding to request") 1576 return 1577 } 1578 1579 return 1580} 1581 1582// DetachUserProvidedFunctionAppFromStaticSiteBuildPreparer prepares the DetachUserProvidedFunctionAppFromStaticSiteBuild request. 1583func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSiteBuildPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string, functionAppName string) (*http.Request, error) { 1584 pathParameters := map[string]interface{}{ 1585 "environmentName": autorest.Encode("path", environmentName), 1586 "functionAppName": autorest.Encode("path", functionAppName), 1587 "name": autorest.Encode("path", name), 1588 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1589 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1590 } 1591 1592 const APIVersion = "2020-12-01" 1593 queryParameters := map[string]interface{}{ 1594 "api-version": APIVersion, 1595 } 1596 1597 preparer := autorest.CreatePreparer( 1598 autorest.AsDelete(), 1599 autorest.WithBaseURL(client.BaseURI), 1600 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/userProvidedFunctionApps/{functionAppName}", pathParameters), 1601 autorest.WithQueryParameters(queryParameters)) 1602 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1603} 1604 1605// DetachUserProvidedFunctionAppFromStaticSiteBuildSender sends the DetachUserProvidedFunctionAppFromStaticSiteBuild request. The method will close the 1606// http.Response Body if it receives an error. 1607func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSiteBuildSender(req *http.Request) (*http.Response, error) { 1608 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1609} 1610 1611// DetachUserProvidedFunctionAppFromStaticSiteBuildResponder handles the response to the DetachUserProvidedFunctionAppFromStaticSiteBuild request. The method always 1612// closes the http.Response Body. 1613func (client StaticSitesClient) DetachUserProvidedFunctionAppFromStaticSiteBuildResponder(resp *http.Response) (result autorest.Response, err error) { 1614 err = autorest.Respond( 1615 resp, 1616 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 1617 autorest.ByClosing()) 1618 result.Response = resp 1619 return 1620} 1621 1622// GetPrivateEndpointConnection description for Gets a private endpoint connection 1623// Parameters: 1624// resourceGroupName - name of the resource group to which the resource belongs. 1625// name - name of the static site. 1626// privateEndpointConnectionName - name of the private endpoint connection. 1627func (client StaticSitesClient) GetPrivateEndpointConnection(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string) (result RemotePrivateEndpointConnectionARMResource, err error) { 1628 if tracing.IsEnabled() { 1629 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetPrivateEndpointConnection") 1630 defer func() { 1631 sc := -1 1632 if result.Response.Response != nil { 1633 sc = result.Response.Response.StatusCode 1634 } 1635 tracing.EndSpan(ctx, sc, err) 1636 }() 1637 } 1638 if err := validation.Validate([]validation.Validation{ 1639 {TargetValue: resourceGroupName, 1640 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1641 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1642 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1643 return result, validation.NewError("web.StaticSitesClient", "GetPrivateEndpointConnection", err.Error()) 1644 } 1645 1646 req, err := client.GetPrivateEndpointConnectionPreparer(ctx, resourceGroupName, name, privateEndpointConnectionName) 1647 if err != nil { 1648 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateEndpointConnection", nil, "Failure preparing request") 1649 return 1650 } 1651 1652 resp, err := client.GetPrivateEndpointConnectionSender(req) 1653 if err != nil { 1654 result.Response = autorest.Response{Response: resp} 1655 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateEndpointConnection", resp, "Failure sending request") 1656 return 1657 } 1658 1659 result, err = client.GetPrivateEndpointConnectionResponder(resp) 1660 if err != nil { 1661 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateEndpointConnection", resp, "Failure responding to request") 1662 return 1663 } 1664 1665 return 1666} 1667 1668// GetPrivateEndpointConnectionPreparer prepares the GetPrivateEndpointConnection request. 1669func (client StaticSitesClient) GetPrivateEndpointConnectionPreparer(ctx context.Context, resourceGroupName string, name string, privateEndpointConnectionName string) (*http.Request, error) { 1670 pathParameters := map[string]interface{}{ 1671 "name": autorest.Encode("path", name), 1672 "privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName), 1673 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1674 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1675 } 1676 1677 const APIVersion = "2020-12-01" 1678 queryParameters := map[string]interface{}{ 1679 "api-version": APIVersion, 1680 } 1681 1682 preparer := autorest.CreatePreparer( 1683 autorest.AsGet(), 1684 autorest.WithBaseURL(client.BaseURI), 1685 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters), 1686 autorest.WithQueryParameters(queryParameters)) 1687 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1688} 1689 1690// GetPrivateEndpointConnectionSender sends the GetPrivateEndpointConnection request. The method will close the 1691// http.Response Body if it receives an error. 1692func (client StaticSitesClient) GetPrivateEndpointConnectionSender(req *http.Request) (*http.Response, error) { 1693 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1694} 1695 1696// GetPrivateEndpointConnectionResponder handles the response to the GetPrivateEndpointConnection request. The method always 1697// closes the http.Response Body. 1698func (client StaticSitesClient) GetPrivateEndpointConnectionResponder(resp *http.Response) (result RemotePrivateEndpointConnectionARMResource, err error) { 1699 err = autorest.Respond( 1700 resp, 1701 azure.WithErrorUnlessStatusCode(http.StatusOK), 1702 autorest.ByUnmarshallingJSON(&result), 1703 autorest.ByClosing()) 1704 result.Response = autorest.Response{Response: resp} 1705 return 1706} 1707 1708// GetPrivateEndpointConnectionList description for Gets the list of private endpoint connections associated with a 1709// static site 1710// Parameters: 1711// resourceGroupName - name of the resource group to which the resource belongs. 1712// name - name of the static site. 1713func (client StaticSitesClient) GetPrivateEndpointConnectionList(ctx context.Context, resourceGroupName string, name string) (result PrivateEndpointConnectionCollectionPage, err error) { 1714 if tracing.IsEnabled() { 1715 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetPrivateEndpointConnectionList") 1716 defer func() { 1717 sc := -1 1718 if result.pecc.Response.Response != nil { 1719 sc = result.pecc.Response.Response.StatusCode 1720 } 1721 tracing.EndSpan(ctx, sc, err) 1722 }() 1723 } 1724 if err := validation.Validate([]validation.Validation{ 1725 {TargetValue: resourceGroupName, 1726 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1727 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1728 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1729 return result, validation.NewError("web.StaticSitesClient", "GetPrivateEndpointConnectionList", err.Error()) 1730 } 1731 1732 result.fn = client.getPrivateEndpointConnectionListNextResults 1733 req, err := client.GetPrivateEndpointConnectionListPreparer(ctx, resourceGroupName, name) 1734 if err != nil { 1735 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateEndpointConnectionList", nil, "Failure preparing request") 1736 return 1737 } 1738 1739 resp, err := client.GetPrivateEndpointConnectionListSender(req) 1740 if err != nil { 1741 result.pecc.Response = autorest.Response{Response: resp} 1742 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateEndpointConnectionList", resp, "Failure sending request") 1743 return 1744 } 1745 1746 result.pecc, err = client.GetPrivateEndpointConnectionListResponder(resp) 1747 if err != nil { 1748 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateEndpointConnectionList", resp, "Failure responding to request") 1749 return 1750 } 1751 if result.pecc.hasNextLink() && result.pecc.IsEmpty() { 1752 err = result.NextWithContext(ctx) 1753 return 1754 } 1755 1756 return 1757} 1758 1759// GetPrivateEndpointConnectionListPreparer prepares the GetPrivateEndpointConnectionList request. 1760func (client StaticSitesClient) GetPrivateEndpointConnectionListPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 1761 pathParameters := map[string]interface{}{ 1762 "name": autorest.Encode("path", name), 1763 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1764 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1765 } 1766 1767 const APIVersion = "2020-12-01" 1768 queryParameters := map[string]interface{}{ 1769 "api-version": APIVersion, 1770 } 1771 1772 preparer := autorest.CreatePreparer( 1773 autorest.AsGet(), 1774 autorest.WithBaseURL(client.BaseURI), 1775 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/privateEndpointConnections", pathParameters), 1776 autorest.WithQueryParameters(queryParameters)) 1777 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1778} 1779 1780// GetPrivateEndpointConnectionListSender sends the GetPrivateEndpointConnectionList request. The method will close the 1781// http.Response Body if it receives an error. 1782func (client StaticSitesClient) GetPrivateEndpointConnectionListSender(req *http.Request) (*http.Response, error) { 1783 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1784} 1785 1786// GetPrivateEndpointConnectionListResponder handles the response to the GetPrivateEndpointConnectionList request. The method always 1787// closes the http.Response Body. 1788func (client StaticSitesClient) GetPrivateEndpointConnectionListResponder(resp *http.Response) (result PrivateEndpointConnectionCollection, err error) { 1789 err = autorest.Respond( 1790 resp, 1791 azure.WithErrorUnlessStatusCode(http.StatusOK), 1792 autorest.ByUnmarshallingJSON(&result), 1793 autorest.ByClosing()) 1794 result.Response = autorest.Response{Response: resp} 1795 return 1796} 1797 1798// getPrivateEndpointConnectionListNextResults retrieves the next set of results, if any. 1799func (client StaticSitesClient) getPrivateEndpointConnectionListNextResults(ctx context.Context, lastResults PrivateEndpointConnectionCollection) (result PrivateEndpointConnectionCollection, err error) { 1800 req, err := lastResults.privateEndpointConnectionCollectionPreparer(ctx) 1801 if err != nil { 1802 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getPrivateEndpointConnectionListNextResults", nil, "Failure preparing next results request") 1803 } 1804 if req == nil { 1805 return 1806 } 1807 resp, err := client.GetPrivateEndpointConnectionListSender(req) 1808 if err != nil { 1809 result.Response = autorest.Response{Response: resp} 1810 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getPrivateEndpointConnectionListNextResults", resp, "Failure sending next results request") 1811 } 1812 result, err = client.GetPrivateEndpointConnectionListResponder(resp) 1813 if err != nil { 1814 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "getPrivateEndpointConnectionListNextResults", resp, "Failure responding to next results request") 1815 } 1816 return 1817} 1818 1819// GetPrivateEndpointConnectionListComplete enumerates all values, automatically crossing page boundaries as required. 1820func (client StaticSitesClient) GetPrivateEndpointConnectionListComplete(ctx context.Context, resourceGroupName string, name string) (result PrivateEndpointConnectionCollectionIterator, err error) { 1821 if tracing.IsEnabled() { 1822 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetPrivateEndpointConnectionList") 1823 defer func() { 1824 sc := -1 1825 if result.Response().Response.Response != nil { 1826 sc = result.page.Response().Response.Response.StatusCode 1827 } 1828 tracing.EndSpan(ctx, sc, err) 1829 }() 1830 } 1831 result.page, err = client.GetPrivateEndpointConnectionList(ctx, resourceGroupName, name) 1832 return 1833} 1834 1835// GetPrivateLinkResources description for Gets the private link resources 1836// Parameters: 1837// resourceGroupName - name of the resource group to which the resource belongs. 1838// name - name of the site. 1839func (client StaticSitesClient) GetPrivateLinkResources(ctx context.Context, resourceGroupName string, name string) (result PrivateLinkResourcesWrapper, err error) { 1840 if tracing.IsEnabled() { 1841 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetPrivateLinkResources") 1842 defer func() { 1843 sc := -1 1844 if result.Response.Response != nil { 1845 sc = result.Response.Response.StatusCode 1846 } 1847 tracing.EndSpan(ctx, sc, err) 1848 }() 1849 } 1850 if err := validation.Validate([]validation.Validation{ 1851 {TargetValue: resourceGroupName, 1852 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1853 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1854 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1855 return result, validation.NewError("web.StaticSitesClient", "GetPrivateLinkResources", err.Error()) 1856 } 1857 1858 req, err := client.GetPrivateLinkResourcesPreparer(ctx, resourceGroupName, name) 1859 if err != nil { 1860 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateLinkResources", nil, "Failure preparing request") 1861 return 1862 } 1863 1864 resp, err := client.GetPrivateLinkResourcesSender(req) 1865 if err != nil { 1866 result.Response = autorest.Response{Response: resp} 1867 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateLinkResources", resp, "Failure sending request") 1868 return 1869 } 1870 1871 result, err = client.GetPrivateLinkResourcesResponder(resp) 1872 if err != nil { 1873 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetPrivateLinkResources", resp, "Failure responding to request") 1874 return 1875 } 1876 1877 return 1878} 1879 1880// GetPrivateLinkResourcesPreparer prepares the GetPrivateLinkResources request. 1881func (client StaticSitesClient) GetPrivateLinkResourcesPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 1882 pathParameters := map[string]interface{}{ 1883 "name": autorest.Encode("path", name), 1884 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1885 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1886 } 1887 1888 const APIVersion = "2020-12-01" 1889 queryParameters := map[string]interface{}{ 1890 "api-version": APIVersion, 1891 } 1892 1893 preparer := autorest.CreatePreparer( 1894 autorest.AsGet(), 1895 autorest.WithBaseURL(client.BaseURI), 1896 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/privateLinkResources", pathParameters), 1897 autorest.WithQueryParameters(queryParameters)) 1898 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1899} 1900 1901// GetPrivateLinkResourcesSender sends the GetPrivateLinkResources request. The method will close the 1902// http.Response Body if it receives an error. 1903func (client StaticSitesClient) GetPrivateLinkResourcesSender(req *http.Request) (*http.Response, error) { 1904 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1905} 1906 1907// GetPrivateLinkResourcesResponder handles the response to the GetPrivateLinkResources request. The method always 1908// closes the http.Response Body. 1909func (client StaticSitesClient) GetPrivateLinkResourcesResponder(resp *http.Response) (result PrivateLinkResourcesWrapper, err error) { 1910 err = autorest.Respond( 1911 resp, 1912 azure.WithErrorUnlessStatusCode(http.StatusOK), 1913 autorest.ByUnmarshallingJSON(&result), 1914 autorest.ByClosing()) 1915 result.Response = autorest.Response{Response: resp} 1916 return 1917} 1918 1919// GetStaticSite description for Gets the details of a static site. 1920// Parameters: 1921// resourceGroupName - name of the resource group to which the resource belongs. 1922// name - name of the static site. 1923func (client StaticSitesClient) GetStaticSite(ctx context.Context, resourceGroupName string, name string) (result StaticSiteARMResource, err error) { 1924 if tracing.IsEnabled() { 1925 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetStaticSite") 1926 defer func() { 1927 sc := -1 1928 if result.Response.Response != nil { 1929 sc = result.Response.Response.StatusCode 1930 } 1931 tracing.EndSpan(ctx, sc, err) 1932 }() 1933 } 1934 if err := validation.Validate([]validation.Validation{ 1935 {TargetValue: resourceGroupName, 1936 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 1937 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 1938 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 1939 return result, validation.NewError("web.StaticSitesClient", "GetStaticSite", err.Error()) 1940 } 1941 1942 req, err := client.GetStaticSitePreparer(ctx, resourceGroupName, name) 1943 if err != nil { 1944 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSite", nil, "Failure preparing request") 1945 return 1946 } 1947 1948 resp, err := client.GetStaticSiteSender(req) 1949 if err != nil { 1950 result.Response = autorest.Response{Response: resp} 1951 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSite", resp, "Failure sending request") 1952 return 1953 } 1954 1955 result, err = client.GetStaticSiteResponder(resp) 1956 if err != nil { 1957 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSite", resp, "Failure responding to request") 1958 return 1959 } 1960 1961 return 1962} 1963 1964// GetStaticSitePreparer prepares the GetStaticSite request. 1965func (client StaticSitesClient) GetStaticSitePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 1966 pathParameters := map[string]interface{}{ 1967 "name": autorest.Encode("path", name), 1968 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1969 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1970 } 1971 1972 const APIVersion = "2020-12-01" 1973 queryParameters := map[string]interface{}{ 1974 "api-version": APIVersion, 1975 } 1976 1977 preparer := autorest.CreatePreparer( 1978 autorest.AsGet(), 1979 autorest.WithBaseURL(client.BaseURI), 1980 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}", pathParameters), 1981 autorest.WithQueryParameters(queryParameters)) 1982 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1983} 1984 1985// GetStaticSiteSender sends the GetStaticSite request. The method will close the 1986// http.Response Body if it receives an error. 1987func (client StaticSitesClient) GetStaticSiteSender(req *http.Request) (*http.Response, error) { 1988 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1989} 1990 1991// GetStaticSiteResponder handles the response to the GetStaticSite request. The method always 1992// closes the http.Response Body. 1993func (client StaticSitesClient) GetStaticSiteResponder(resp *http.Response) (result StaticSiteARMResource, err error) { 1994 err = autorest.Respond( 1995 resp, 1996 azure.WithErrorUnlessStatusCode(http.StatusOK), 1997 autorest.ByUnmarshallingJSON(&result), 1998 autorest.ByClosing()) 1999 result.Response = autorest.Response{Response: resp} 2000 return 2001} 2002 2003// GetStaticSiteBuild description for Gets the details of a static site build. 2004// Parameters: 2005// resourceGroupName - name of the resource group to which the resource belongs. 2006// name - name of the static site. 2007// environmentName - the stage site identifier. 2008func (client StaticSitesClient) GetStaticSiteBuild(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StaticSiteBuildARMResource, err error) { 2009 if tracing.IsEnabled() { 2010 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetStaticSiteBuild") 2011 defer func() { 2012 sc := -1 2013 if result.Response.Response != nil { 2014 sc = result.Response.Response.StatusCode 2015 } 2016 tracing.EndSpan(ctx, sc, err) 2017 }() 2018 } 2019 if err := validation.Validate([]validation.Validation{ 2020 {TargetValue: resourceGroupName, 2021 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2022 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2023 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2024 return result, validation.NewError("web.StaticSitesClient", "GetStaticSiteBuild", err.Error()) 2025 } 2026 2027 req, err := client.GetStaticSiteBuildPreparer(ctx, resourceGroupName, name, environmentName) 2028 if err != nil { 2029 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteBuild", nil, "Failure preparing request") 2030 return 2031 } 2032 2033 resp, err := client.GetStaticSiteBuildSender(req) 2034 if err != nil { 2035 result.Response = autorest.Response{Response: resp} 2036 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteBuild", resp, "Failure sending request") 2037 return 2038 } 2039 2040 result, err = client.GetStaticSiteBuildResponder(resp) 2041 if err != nil { 2042 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteBuild", resp, "Failure responding to request") 2043 return 2044 } 2045 2046 return 2047} 2048 2049// GetStaticSiteBuildPreparer prepares the GetStaticSiteBuild request. 2050func (client StaticSitesClient) GetStaticSiteBuildPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string) (*http.Request, error) { 2051 pathParameters := map[string]interface{}{ 2052 "environmentName": autorest.Encode("path", environmentName), 2053 "name": autorest.Encode("path", name), 2054 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2055 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2056 } 2057 2058 const APIVersion = "2020-12-01" 2059 queryParameters := map[string]interface{}{ 2060 "api-version": APIVersion, 2061 } 2062 2063 preparer := autorest.CreatePreparer( 2064 autorest.AsGet(), 2065 autorest.WithBaseURL(client.BaseURI), 2066 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}", pathParameters), 2067 autorest.WithQueryParameters(queryParameters)) 2068 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2069} 2070 2071// GetStaticSiteBuildSender sends the GetStaticSiteBuild request. The method will close the 2072// http.Response Body if it receives an error. 2073func (client StaticSitesClient) GetStaticSiteBuildSender(req *http.Request) (*http.Response, error) { 2074 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2075} 2076 2077// GetStaticSiteBuildResponder handles the response to the GetStaticSiteBuild request. The method always 2078// closes the http.Response Body. 2079func (client StaticSitesClient) GetStaticSiteBuildResponder(resp *http.Response) (result StaticSiteBuildARMResource, err error) { 2080 err = autorest.Respond( 2081 resp, 2082 azure.WithErrorUnlessStatusCode(http.StatusOK), 2083 autorest.ByUnmarshallingJSON(&result), 2084 autorest.ByClosing()) 2085 result.Response = autorest.Response{Response: resp} 2086 return 2087} 2088 2089// GetStaticSiteBuilds description for Gets all static site builds for a particular static site. 2090// Parameters: 2091// resourceGroupName - name of the resource group to which the resource belongs. 2092// name - name of the static site. 2093func (client StaticSitesClient) GetStaticSiteBuilds(ctx context.Context, resourceGroupName string, name string) (result StaticSiteBuildCollectionPage, err error) { 2094 if tracing.IsEnabled() { 2095 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetStaticSiteBuilds") 2096 defer func() { 2097 sc := -1 2098 if result.ssbc.Response.Response != nil { 2099 sc = result.ssbc.Response.Response.StatusCode 2100 } 2101 tracing.EndSpan(ctx, sc, err) 2102 }() 2103 } 2104 if err := validation.Validate([]validation.Validation{ 2105 {TargetValue: resourceGroupName, 2106 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2107 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2108 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2109 return result, validation.NewError("web.StaticSitesClient", "GetStaticSiteBuilds", err.Error()) 2110 } 2111 2112 result.fn = client.getStaticSiteBuildsNextResults 2113 req, err := client.GetStaticSiteBuildsPreparer(ctx, resourceGroupName, name) 2114 if err != nil { 2115 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteBuilds", nil, "Failure preparing request") 2116 return 2117 } 2118 2119 resp, err := client.GetStaticSiteBuildsSender(req) 2120 if err != nil { 2121 result.ssbc.Response = autorest.Response{Response: resp} 2122 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteBuilds", resp, "Failure sending request") 2123 return 2124 } 2125 2126 result.ssbc, err = client.GetStaticSiteBuildsResponder(resp) 2127 if err != nil { 2128 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteBuilds", resp, "Failure responding to request") 2129 return 2130 } 2131 if result.ssbc.hasNextLink() && result.ssbc.IsEmpty() { 2132 err = result.NextWithContext(ctx) 2133 return 2134 } 2135 2136 return 2137} 2138 2139// GetStaticSiteBuildsPreparer prepares the GetStaticSiteBuilds request. 2140func (client StaticSitesClient) GetStaticSiteBuildsPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 2141 pathParameters := map[string]interface{}{ 2142 "name": autorest.Encode("path", name), 2143 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2144 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2145 } 2146 2147 const APIVersion = "2020-12-01" 2148 queryParameters := map[string]interface{}{ 2149 "api-version": APIVersion, 2150 } 2151 2152 preparer := autorest.CreatePreparer( 2153 autorest.AsGet(), 2154 autorest.WithBaseURL(client.BaseURI), 2155 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds", pathParameters), 2156 autorest.WithQueryParameters(queryParameters)) 2157 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2158} 2159 2160// GetStaticSiteBuildsSender sends the GetStaticSiteBuilds request. The method will close the 2161// http.Response Body if it receives an error. 2162func (client StaticSitesClient) GetStaticSiteBuildsSender(req *http.Request) (*http.Response, error) { 2163 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2164} 2165 2166// GetStaticSiteBuildsResponder handles the response to the GetStaticSiteBuilds request. The method always 2167// closes the http.Response Body. 2168func (client StaticSitesClient) GetStaticSiteBuildsResponder(resp *http.Response) (result StaticSiteBuildCollection, err error) { 2169 err = autorest.Respond( 2170 resp, 2171 azure.WithErrorUnlessStatusCode(http.StatusOK), 2172 autorest.ByUnmarshallingJSON(&result), 2173 autorest.ByClosing()) 2174 result.Response = autorest.Response{Response: resp} 2175 return 2176} 2177 2178// getStaticSiteBuildsNextResults retrieves the next set of results, if any. 2179func (client StaticSitesClient) getStaticSiteBuildsNextResults(ctx context.Context, lastResults StaticSiteBuildCollection) (result StaticSiteBuildCollection, err error) { 2180 req, err := lastResults.staticSiteBuildCollectionPreparer(ctx) 2181 if err != nil { 2182 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getStaticSiteBuildsNextResults", nil, "Failure preparing next results request") 2183 } 2184 if req == nil { 2185 return 2186 } 2187 resp, err := client.GetStaticSiteBuildsSender(req) 2188 if err != nil { 2189 result.Response = autorest.Response{Response: resp} 2190 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getStaticSiteBuildsNextResults", resp, "Failure sending next results request") 2191 } 2192 result, err = client.GetStaticSiteBuildsResponder(resp) 2193 if err != nil { 2194 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "getStaticSiteBuildsNextResults", resp, "Failure responding to next results request") 2195 } 2196 return 2197} 2198 2199// GetStaticSiteBuildsComplete enumerates all values, automatically crossing page boundaries as required. 2200func (client StaticSitesClient) GetStaticSiteBuildsComplete(ctx context.Context, resourceGroupName string, name string) (result StaticSiteBuildCollectionIterator, err error) { 2201 if tracing.IsEnabled() { 2202 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetStaticSiteBuilds") 2203 defer func() { 2204 sc := -1 2205 if result.Response().Response.Response != nil { 2206 sc = result.page.Response().Response.Response.StatusCode 2207 } 2208 tracing.EndSpan(ctx, sc, err) 2209 }() 2210 } 2211 result.page, err = client.GetStaticSiteBuilds(ctx, resourceGroupName, name) 2212 return 2213} 2214 2215// GetStaticSiteCustomDomain description for Gets an existing custom domain for a particular static site. 2216// Parameters: 2217// resourceGroupName - name of the resource group to which the resource belongs. 2218// name - name of the static site resource to search in. 2219// domainName - the custom domain name. 2220func (client StaticSitesClient) GetStaticSiteCustomDomain(ctx context.Context, resourceGroupName string, name string, domainName string) (result StaticSiteCustomDomainOverviewARMResource, err error) { 2221 if tracing.IsEnabled() { 2222 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetStaticSiteCustomDomain") 2223 defer func() { 2224 sc := -1 2225 if result.Response.Response != nil { 2226 sc = result.Response.Response.StatusCode 2227 } 2228 tracing.EndSpan(ctx, sc, err) 2229 }() 2230 } 2231 if err := validation.Validate([]validation.Validation{ 2232 {TargetValue: resourceGroupName, 2233 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2234 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2235 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2236 return result, validation.NewError("web.StaticSitesClient", "GetStaticSiteCustomDomain", err.Error()) 2237 } 2238 2239 req, err := client.GetStaticSiteCustomDomainPreparer(ctx, resourceGroupName, name, domainName) 2240 if err != nil { 2241 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteCustomDomain", nil, "Failure preparing request") 2242 return 2243 } 2244 2245 resp, err := client.GetStaticSiteCustomDomainSender(req) 2246 if err != nil { 2247 result.Response = autorest.Response{Response: resp} 2248 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteCustomDomain", resp, "Failure sending request") 2249 return 2250 } 2251 2252 result, err = client.GetStaticSiteCustomDomainResponder(resp) 2253 if err != nil { 2254 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSiteCustomDomain", resp, "Failure responding to request") 2255 return 2256 } 2257 2258 return 2259} 2260 2261// GetStaticSiteCustomDomainPreparer prepares the GetStaticSiteCustomDomain request. 2262func (client StaticSitesClient) GetStaticSiteCustomDomainPreparer(ctx context.Context, resourceGroupName string, name string, domainName string) (*http.Request, error) { 2263 pathParameters := map[string]interface{}{ 2264 "domainName": autorest.Encode("path", domainName), 2265 "name": autorest.Encode("path", name), 2266 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2267 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2268 } 2269 2270 const APIVersion = "2020-12-01" 2271 queryParameters := map[string]interface{}{ 2272 "api-version": APIVersion, 2273 } 2274 2275 preparer := autorest.CreatePreparer( 2276 autorest.AsGet(), 2277 autorest.WithBaseURL(client.BaseURI), 2278 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/customDomains/{domainName}", pathParameters), 2279 autorest.WithQueryParameters(queryParameters)) 2280 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2281} 2282 2283// GetStaticSiteCustomDomainSender sends the GetStaticSiteCustomDomain request. The method will close the 2284// http.Response Body if it receives an error. 2285func (client StaticSitesClient) GetStaticSiteCustomDomainSender(req *http.Request) (*http.Response, error) { 2286 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2287} 2288 2289// GetStaticSiteCustomDomainResponder handles the response to the GetStaticSiteCustomDomain request. The method always 2290// closes the http.Response Body. 2291func (client StaticSitesClient) GetStaticSiteCustomDomainResponder(resp *http.Response) (result StaticSiteCustomDomainOverviewARMResource, err error) { 2292 err = autorest.Respond( 2293 resp, 2294 azure.WithErrorUnlessStatusCode(http.StatusOK), 2295 autorest.ByUnmarshallingJSON(&result), 2296 autorest.ByClosing()) 2297 result.Response = autorest.Response{Response: resp} 2298 return 2299} 2300 2301// GetStaticSitesByResourceGroup description for Gets all static sites in the specified resource group. 2302// Parameters: 2303// resourceGroupName - name of the resource group to which the resource belongs. 2304func (client StaticSitesClient) GetStaticSitesByResourceGroup(ctx context.Context, resourceGroupName string) (result StaticSiteCollectionPage, err error) { 2305 if tracing.IsEnabled() { 2306 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetStaticSitesByResourceGroup") 2307 defer func() { 2308 sc := -1 2309 if result.ssc.Response.Response != nil { 2310 sc = result.ssc.Response.Response.StatusCode 2311 } 2312 tracing.EndSpan(ctx, sc, err) 2313 }() 2314 } 2315 if err := validation.Validate([]validation.Validation{ 2316 {TargetValue: resourceGroupName, 2317 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2318 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2319 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2320 return result, validation.NewError("web.StaticSitesClient", "GetStaticSitesByResourceGroup", err.Error()) 2321 } 2322 2323 result.fn = client.getStaticSitesByResourceGroupNextResults 2324 req, err := client.GetStaticSitesByResourceGroupPreparer(ctx, resourceGroupName) 2325 if err != nil { 2326 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSitesByResourceGroup", nil, "Failure preparing request") 2327 return 2328 } 2329 2330 resp, err := client.GetStaticSitesByResourceGroupSender(req) 2331 if err != nil { 2332 result.ssc.Response = autorest.Response{Response: resp} 2333 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSitesByResourceGroup", resp, "Failure sending request") 2334 return 2335 } 2336 2337 result.ssc, err = client.GetStaticSitesByResourceGroupResponder(resp) 2338 if err != nil { 2339 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetStaticSitesByResourceGroup", resp, "Failure responding to request") 2340 return 2341 } 2342 if result.ssc.hasNextLink() && result.ssc.IsEmpty() { 2343 err = result.NextWithContext(ctx) 2344 return 2345 } 2346 2347 return 2348} 2349 2350// GetStaticSitesByResourceGroupPreparer prepares the GetStaticSitesByResourceGroup request. 2351func (client StaticSitesClient) GetStaticSitesByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 2352 pathParameters := map[string]interface{}{ 2353 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2354 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2355 } 2356 2357 const APIVersion = "2020-12-01" 2358 queryParameters := map[string]interface{}{ 2359 "api-version": APIVersion, 2360 } 2361 2362 preparer := autorest.CreatePreparer( 2363 autorest.AsGet(), 2364 autorest.WithBaseURL(client.BaseURI), 2365 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites", pathParameters), 2366 autorest.WithQueryParameters(queryParameters)) 2367 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2368} 2369 2370// GetStaticSitesByResourceGroupSender sends the GetStaticSitesByResourceGroup request. The method will close the 2371// http.Response Body if it receives an error. 2372func (client StaticSitesClient) GetStaticSitesByResourceGroupSender(req *http.Request) (*http.Response, error) { 2373 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2374} 2375 2376// GetStaticSitesByResourceGroupResponder handles the response to the GetStaticSitesByResourceGroup request. The method always 2377// closes the http.Response Body. 2378func (client StaticSitesClient) GetStaticSitesByResourceGroupResponder(resp *http.Response) (result StaticSiteCollection, err error) { 2379 err = autorest.Respond( 2380 resp, 2381 azure.WithErrorUnlessStatusCode(http.StatusOK), 2382 autorest.ByUnmarshallingJSON(&result), 2383 autorest.ByClosing()) 2384 result.Response = autorest.Response{Response: resp} 2385 return 2386} 2387 2388// getStaticSitesByResourceGroupNextResults retrieves the next set of results, if any. 2389func (client StaticSitesClient) getStaticSitesByResourceGroupNextResults(ctx context.Context, lastResults StaticSiteCollection) (result StaticSiteCollection, err error) { 2390 req, err := lastResults.staticSiteCollectionPreparer(ctx) 2391 if err != nil { 2392 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getStaticSitesByResourceGroupNextResults", nil, "Failure preparing next results request") 2393 } 2394 if req == nil { 2395 return 2396 } 2397 resp, err := client.GetStaticSitesByResourceGroupSender(req) 2398 if err != nil { 2399 result.Response = autorest.Response{Response: resp} 2400 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getStaticSitesByResourceGroupNextResults", resp, "Failure sending next results request") 2401 } 2402 result, err = client.GetStaticSitesByResourceGroupResponder(resp) 2403 if err != nil { 2404 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "getStaticSitesByResourceGroupNextResults", resp, "Failure responding to next results request") 2405 } 2406 return 2407} 2408 2409// GetStaticSitesByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 2410func (client StaticSitesClient) GetStaticSitesByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result StaticSiteCollectionIterator, err error) { 2411 if tracing.IsEnabled() { 2412 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetStaticSitesByResourceGroup") 2413 defer func() { 2414 sc := -1 2415 if result.Response().Response.Response != nil { 2416 sc = result.page.Response().Response.Response.StatusCode 2417 } 2418 tracing.EndSpan(ctx, sc, err) 2419 }() 2420 } 2421 result.page, err = client.GetStaticSitesByResourceGroup(ctx, resourceGroupName) 2422 return 2423} 2424 2425// GetUserProvidedFunctionAppForStaticSite description for Gets the details of the user provided function app 2426// registered with a static site 2427// Parameters: 2428// resourceGroupName - name of the resource group to which the resource belongs. 2429// name - name of the static site. 2430// functionAppName - name of the function app registered with the static site. 2431func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSite(ctx context.Context, resourceGroupName string, name string, functionAppName string) (result StaticSiteUserProvidedFunctionAppARMResource, err error) { 2432 if tracing.IsEnabled() { 2433 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetUserProvidedFunctionAppForStaticSite") 2434 defer func() { 2435 sc := -1 2436 if result.Response.Response != nil { 2437 sc = result.Response.Response.StatusCode 2438 } 2439 tracing.EndSpan(ctx, sc, err) 2440 }() 2441 } 2442 if err := validation.Validate([]validation.Validation{ 2443 {TargetValue: resourceGroupName, 2444 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2445 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2446 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2447 return result, validation.NewError("web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSite", err.Error()) 2448 } 2449 2450 req, err := client.GetUserProvidedFunctionAppForStaticSitePreparer(ctx, resourceGroupName, name, functionAppName) 2451 if err != nil { 2452 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSite", nil, "Failure preparing request") 2453 return 2454 } 2455 2456 resp, err := client.GetUserProvidedFunctionAppForStaticSiteSender(req) 2457 if err != nil { 2458 result.Response = autorest.Response{Response: resp} 2459 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSite", resp, "Failure sending request") 2460 return 2461 } 2462 2463 result, err = client.GetUserProvidedFunctionAppForStaticSiteResponder(resp) 2464 if err != nil { 2465 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSite", resp, "Failure responding to request") 2466 return 2467 } 2468 2469 return 2470} 2471 2472// GetUserProvidedFunctionAppForStaticSitePreparer prepares the GetUserProvidedFunctionAppForStaticSite request. 2473func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSitePreparer(ctx context.Context, resourceGroupName string, name string, functionAppName string) (*http.Request, error) { 2474 pathParameters := map[string]interface{}{ 2475 "functionAppName": autorest.Encode("path", functionAppName), 2476 "name": autorest.Encode("path", name), 2477 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2478 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2479 } 2480 2481 const APIVersion = "2020-12-01" 2482 queryParameters := map[string]interface{}{ 2483 "api-version": APIVersion, 2484 } 2485 2486 preparer := autorest.CreatePreparer( 2487 autorest.AsGet(), 2488 autorest.WithBaseURL(client.BaseURI), 2489 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/userProvidedFunctionApps/{functionAppName}", pathParameters), 2490 autorest.WithQueryParameters(queryParameters)) 2491 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2492} 2493 2494// GetUserProvidedFunctionAppForStaticSiteSender sends the GetUserProvidedFunctionAppForStaticSite request. The method will close the 2495// http.Response Body if it receives an error. 2496func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSiteSender(req *http.Request) (*http.Response, error) { 2497 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2498} 2499 2500// GetUserProvidedFunctionAppForStaticSiteResponder handles the response to the GetUserProvidedFunctionAppForStaticSite request. The method always 2501// closes the http.Response Body. 2502func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSiteResponder(resp *http.Response) (result StaticSiteUserProvidedFunctionAppARMResource, err error) { 2503 err = autorest.Respond( 2504 resp, 2505 azure.WithErrorUnlessStatusCode(http.StatusOK), 2506 autorest.ByUnmarshallingJSON(&result), 2507 autorest.ByClosing()) 2508 result.Response = autorest.Response{Response: resp} 2509 return 2510} 2511 2512// GetUserProvidedFunctionAppForStaticSiteBuild description for Gets the details of the user provided function app 2513// registered with a static site build 2514// Parameters: 2515// resourceGroupName - name of the resource group to which the resource belongs. 2516// name - name of the static site. 2517// environmentName - the stage site identifier. 2518// functionAppName - name of the function app registered with the static site build. 2519func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSiteBuild(ctx context.Context, resourceGroupName string, name string, environmentName string, functionAppName string) (result StaticSiteUserProvidedFunctionAppARMResource, err error) { 2520 if tracing.IsEnabled() { 2521 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetUserProvidedFunctionAppForStaticSiteBuild") 2522 defer func() { 2523 sc := -1 2524 if result.Response.Response != nil { 2525 sc = result.Response.Response.StatusCode 2526 } 2527 tracing.EndSpan(ctx, sc, err) 2528 }() 2529 } 2530 if err := validation.Validate([]validation.Validation{ 2531 {TargetValue: resourceGroupName, 2532 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2533 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2534 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2535 return result, validation.NewError("web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSiteBuild", err.Error()) 2536 } 2537 2538 req, err := client.GetUserProvidedFunctionAppForStaticSiteBuildPreparer(ctx, resourceGroupName, name, environmentName, functionAppName) 2539 if err != nil { 2540 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSiteBuild", nil, "Failure preparing request") 2541 return 2542 } 2543 2544 resp, err := client.GetUserProvidedFunctionAppForStaticSiteBuildSender(req) 2545 if err != nil { 2546 result.Response = autorest.Response{Response: resp} 2547 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSiteBuild", resp, "Failure sending request") 2548 return 2549 } 2550 2551 result, err = client.GetUserProvidedFunctionAppForStaticSiteBuildResponder(resp) 2552 if err != nil { 2553 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppForStaticSiteBuild", resp, "Failure responding to request") 2554 return 2555 } 2556 2557 return 2558} 2559 2560// GetUserProvidedFunctionAppForStaticSiteBuildPreparer prepares the GetUserProvidedFunctionAppForStaticSiteBuild request. 2561func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSiteBuildPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string, functionAppName string) (*http.Request, error) { 2562 pathParameters := map[string]interface{}{ 2563 "environmentName": autorest.Encode("path", environmentName), 2564 "functionAppName": autorest.Encode("path", functionAppName), 2565 "name": autorest.Encode("path", name), 2566 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2567 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2568 } 2569 2570 const APIVersion = "2020-12-01" 2571 queryParameters := map[string]interface{}{ 2572 "api-version": APIVersion, 2573 } 2574 2575 preparer := autorest.CreatePreparer( 2576 autorest.AsGet(), 2577 autorest.WithBaseURL(client.BaseURI), 2578 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/userProvidedFunctionApps/{functionAppName}", pathParameters), 2579 autorest.WithQueryParameters(queryParameters)) 2580 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2581} 2582 2583// GetUserProvidedFunctionAppForStaticSiteBuildSender sends the GetUserProvidedFunctionAppForStaticSiteBuild request. The method will close the 2584// http.Response Body if it receives an error. 2585func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSiteBuildSender(req *http.Request) (*http.Response, error) { 2586 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2587} 2588 2589// GetUserProvidedFunctionAppForStaticSiteBuildResponder handles the response to the GetUserProvidedFunctionAppForStaticSiteBuild request. The method always 2590// closes the http.Response Body. 2591func (client StaticSitesClient) GetUserProvidedFunctionAppForStaticSiteBuildResponder(resp *http.Response) (result StaticSiteUserProvidedFunctionAppARMResource, err error) { 2592 err = autorest.Respond( 2593 resp, 2594 azure.WithErrorUnlessStatusCode(http.StatusOK), 2595 autorest.ByUnmarshallingJSON(&result), 2596 autorest.ByClosing()) 2597 result.Response = autorest.Response{Response: resp} 2598 return 2599} 2600 2601// GetUserProvidedFunctionAppsForStaticSite description for Gets the details of the user provided function apps 2602// registered with a static site 2603// Parameters: 2604// resourceGroupName - name of the resource group to which the resource belongs. 2605// name - name of the static site. 2606func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSite(ctx context.Context, resourceGroupName string, name string) (result StaticSiteUserProvidedFunctionAppsCollectionPage, err error) { 2607 if tracing.IsEnabled() { 2608 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetUserProvidedFunctionAppsForStaticSite") 2609 defer func() { 2610 sc := -1 2611 if result.ssupfac.Response.Response != nil { 2612 sc = result.ssupfac.Response.Response.StatusCode 2613 } 2614 tracing.EndSpan(ctx, sc, err) 2615 }() 2616 } 2617 if err := validation.Validate([]validation.Validation{ 2618 {TargetValue: resourceGroupName, 2619 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2620 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2621 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2622 return result, validation.NewError("web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSite", err.Error()) 2623 } 2624 2625 result.fn = client.getUserProvidedFunctionAppsForStaticSiteNextResults 2626 req, err := client.GetUserProvidedFunctionAppsForStaticSitePreparer(ctx, resourceGroupName, name) 2627 if err != nil { 2628 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSite", nil, "Failure preparing request") 2629 return 2630 } 2631 2632 resp, err := client.GetUserProvidedFunctionAppsForStaticSiteSender(req) 2633 if err != nil { 2634 result.ssupfac.Response = autorest.Response{Response: resp} 2635 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSite", resp, "Failure sending request") 2636 return 2637 } 2638 2639 result.ssupfac, err = client.GetUserProvidedFunctionAppsForStaticSiteResponder(resp) 2640 if err != nil { 2641 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSite", resp, "Failure responding to request") 2642 return 2643 } 2644 if result.ssupfac.hasNextLink() && result.ssupfac.IsEmpty() { 2645 err = result.NextWithContext(ctx) 2646 return 2647 } 2648 2649 return 2650} 2651 2652// GetUserProvidedFunctionAppsForStaticSitePreparer prepares the GetUserProvidedFunctionAppsForStaticSite request. 2653func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSitePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 2654 pathParameters := map[string]interface{}{ 2655 "name": autorest.Encode("path", name), 2656 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2657 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2658 } 2659 2660 const APIVersion = "2020-12-01" 2661 queryParameters := map[string]interface{}{ 2662 "api-version": APIVersion, 2663 } 2664 2665 preparer := autorest.CreatePreparer( 2666 autorest.AsGet(), 2667 autorest.WithBaseURL(client.BaseURI), 2668 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/userProvidedFunctionApps", pathParameters), 2669 autorest.WithQueryParameters(queryParameters)) 2670 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2671} 2672 2673// GetUserProvidedFunctionAppsForStaticSiteSender sends the GetUserProvidedFunctionAppsForStaticSite request. The method will close the 2674// http.Response Body if it receives an error. 2675func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteSender(req *http.Request) (*http.Response, error) { 2676 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2677} 2678 2679// GetUserProvidedFunctionAppsForStaticSiteResponder handles the response to the GetUserProvidedFunctionAppsForStaticSite request. The method always 2680// closes the http.Response Body. 2681func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteResponder(resp *http.Response) (result StaticSiteUserProvidedFunctionAppsCollection, err error) { 2682 err = autorest.Respond( 2683 resp, 2684 azure.WithErrorUnlessStatusCode(http.StatusOK), 2685 autorest.ByUnmarshallingJSON(&result), 2686 autorest.ByClosing()) 2687 result.Response = autorest.Response{Response: resp} 2688 return 2689} 2690 2691// getUserProvidedFunctionAppsForStaticSiteNextResults retrieves the next set of results, if any. 2692func (client StaticSitesClient) getUserProvidedFunctionAppsForStaticSiteNextResults(ctx context.Context, lastResults StaticSiteUserProvidedFunctionAppsCollection) (result StaticSiteUserProvidedFunctionAppsCollection, err error) { 2693 req, err := lastResults.staticSiteUserProvidedFunctionAppsCollectionPreparer(ctx) 2694 if err != nil { 2695 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getUserProvidedFunctionAppsForStaticSiteNextResults", nil, "Failure preparing next results request") 2696 } 2697 if req == nil { 2698 return 2699 } 2700 resp, err := client.GetUserProvidedFunctionAppsForStaticSiteSender(req) 2701 if err != nil { 2702 result.Response = autorest.Response{Response: resp} 2703 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getUserProvidedFunctionAppsForStaticSiteNextResults", resp, "Failure sending next results request") 2704 } 2705 result, err = client.GetUserProvidedFunctionAppsForStaticSiteResponder(resp) 2706 if err != nil { 2707 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "getUserProvidedFunctionAppsForStaticSiteNextResults", resp, "Failure responding to next results request") 2708 } 2709 return 2710} 2711 2712// GetUserProvidedFunctionAppsForStaticSiteComplete enumerates all values, automatically crossing page boundaries as required. 2713func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteComplete(ctx context.Context, resourceGroupName string, name string) (result StaticSiteUserProvidedFunctionAppsCollectionIterator, err error) { 2714 if tracing.IsEnabled() { 2715 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetUserProvidedFunctionAppsForStaticSite") 2716 defer func() { 2717 sc := -1 2718 if result.Response().Response.Response != nil { 2719 sc = result.page.Response().Response.Response.StatusCode 2720 } 2721 tracing.EndSpan(ctx, sc, err) 2722 }() 2723 } 2724 result.page, err = client.GetUserProvidedFunctionAppsForStaticSite(ctx, resourceGroupName, name) 2725 return 2726} 2727 2728// GetUserProvidedFunctionAppsForStaticSiteBuild description for Gets the details of the user provided function apps 2729// registered with a static site build 2730// Parameters: 2731// resourceGroupName - name of the resource group to which the resource belongs. 2732// name - name of the static site. 2733// environmentName - the stage site identifier. 2734func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteBuild(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StaticSiteUserProvidedFunctionAppsCollectionPage, err error) { 2735 if tracing.IsEnabled() { 2736 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetUserProvidedFunctionAppsForStaticSiteBuild") 2737 defer func() { 2738 sc := -1 2739 if result.ssupfac.Response.Response != nil { 2740 sc = result.ssupfac.Response.Response.StatusCode 2741 } 2742 tracing.EndSpan(ctx, sc, err) 2743 }() 2744 } 2745 if err := validation.Validate([]validation.Validation{ 2746 {TargetValue: resourceGroupName, 2747 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2748 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2749 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2750 return result, validation.NewError("web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSiteBuild", err.Error()) 2751 } 2752 2753 result.fn = client.getUserProvidedFunctionAppsForStaticSiteBuildNextResults 2754 req, err := client.GetUserProvidedFunctionAppsForStaticSiteBuildPreparer(ctx, resourceGroupName, name, environmentName) 2755 if err != nil { 2756 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSiteBuild", nil, "Failure preparing request") 2757 return 2758 } 2759 2760 resp, err := client.GetUserProvidedFunctionAppsForStaticSiteBuildSender(req) 2761 if err != nil { 2762 result.ssupfac.Response = autorest.Response{Response: resp} 2763 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSiteBuild", resp, "Failure sending request") 2764 return 2765 } 2766 2767 result.ssupfac, err = client.GetUserProvidedFunctionAppsForStaticSiteBuildResponder(resp) 2768 if err != nil { 2769 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "GetUserProvidedFunctionAppsForStaticSiteBuild", resp, "Failure responding to request") 2770 return 2771 } 2772 if result.ssupfac.hasNextLink() && result.ssupfac.IsEmpty() { 2773 err = result.NextWithContext(ctx) 2774 return 2775 } 2776 2777 return 2778} 2779 2780// GetUserProvidedFunctionAppsForStaticSiteBuildPreparer prepares the GetUserProvidedFunctionAppsForStaticSiteBuild request. 2781func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteBuildPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string) (*http.Request, error) { 2782 pathParameters := map[string]interface{}{ 2783 "environmentName": autorest.Encode("path", environmentName), 2784 "name": autorest.Encode("path", name), 2785 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2786 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2787 } 2788 2789 const APIVersion = "2020-12-01" 2790 queryParameters := map[string]interface{}{ 2791 "api-version": APIVersion, 2792 } 2793 2794 preparer := autorest.CreatePreparer( 2795 autorest.AsGet(), 2796 autorest.WithBaseURL(client.BaseURI), 2797 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/userProvidedFunctionApps", pathParameters), 2798 autorest.WithQueryParameters(queryParameters)) 2799 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2800} 2801 2802// GetUserProvidedFunctionAppsForStaticSiteBuildSender sends the GetUserProvidedFunctionAppsForStaticSiteBuild request. The method will close the 2803// http.Response Body if it receives an error. 2804func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteBuildSender(req *http.Request) (*http.Response, error) { 2805 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2806} 2807 2808// GetUserProvidedFunctionAppsForStaticSiteBuildResponder handles the response to the GetUserProvidedFunctionAppsForStaticSiteBuild request. The method always 2809// closes the http.Response Body. 2810func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteBuildResponder(resp *http.Response) (result StaticSiteUserProvidedFunctionAppsCollection, err error) { 2811 err = autorest.Respond( 2812 resp, 2813 azure.WithErrorUnlessStatusCode(http.StatusOK), 2814 autorest.ByUnmarshallingJSON(&result), 2815 autorest.ByClosing()) 2816 result.Response = autorest.Response{Response: resp} 2817 return 2818} 2819 2820// getUserProvidedFunctionAppsForStaticSiteBuildNextResults retrieves the next set of results, if any. 2821func (client StaticSitesClient) getUserProvidedFunctionAppsForStaticSiteBuildNextResults(ctx context.Context, lastResults StaticSiteUserProvidedFunctionAppsCollection) (result StaticSiteUserProvidedFunctionAppsCollection, err error) { 2822 req, err := lastResults.staticSiteUserProvidedFunctionAppsCollectionPreparer(ctx) 2823 if err != nil { 2824 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getUserProvidedFunctionAppsForStaticSiteBuildNextResults", nil, "Failure preparing next results request") 2825 } 2826 if req == nil { 2827 return 2828 } 2829 resp, err := client.GetUserProvidedFunctionAppsForStaticSiteBuildSender(req) 2830 if err != nil { 2831 result.Response = autorest.Response{Response: resp} 2832 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "getUserProvidedFunctionAppsForStaticSiteBuildNextResults", resp, "Failure sending next results request") 2833 } 2834 result, err = client.GetUserProvidedFunctionAppsForStaticSiteBuildResponder(resp) 2835 if err != nil { 2836 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "getUserProvidedFunctionAppsForStaticSiteBuildNextResults", resp, "Failure responding to next results request") 2837 } 2838 return 2839} 2840 2841// GetUserProvidedFunctionAppsForStaticSiteBuildComplete enumerates all values, automatically crossing page boundaries as required. 2842func (client StaticSitesClient) GetUserProvidedFunctionAppsForStaticSiteBuildComplete(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StaticSiteUserProvidedFunctionAppsCollectionIterator, err error) { 2843 if tracing.IsEnabled() { 2844 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.GetUserProvidedFunctionAppsForStaticSiteBuild") 2845 defer func() { 2846 sc := -1 2847 if result.Response().Response.Response != nil { 2848 sc = result.page.Response().Response.Response.StatusCode 2849 } 2850 tracing.EndSpan(ctx, sc, err) 2851 }() 2852 } 2853 result.page, err = client.GetUserProvidedFunctionAppsForStaticSiteBuild(ctx, resourceGroupName, name, environmentName) 2854 return 2855} 2856 2857// List description for Get all Static Sites for a subscription. 2858func (client StaticSitesClient) List(ctx context.Context) (result StaticSiteCollectionPage, err error) { 2859 if tracing.IsEnabled() { 2860 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.List") 2861 defer func() { 2862 sc := -1 2863 if result.ssc.Response.Response != nil { 2864 sc = result.ssc.Response.Response.StatusCode 2865 } 2866 tracing.EndSpan(ctx, sc, err) 2867 }() 2868 } 2869 result.fn = client.listNextResults 2870 req, err := client.ListPreparer(ctx) 2871 if err != nil { 2872 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "List", nil, "Failure preparing request") 2873 return 2874 } 2875 2876 resp, err := client.ListSender(req) 2877 if err != nil { 2878 result.ssc.Response = autorest.Response{Response: resp} 2879 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "List", resp, "Failure sending request") 2880 return 2881 } 2882 2883 result.ssc, err = client.ListResponder(resp) 2884 if err != nil { 2885 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "List", resp, "Failure responding to request") 2886 return 2887 } 2888 if result.ssc.hasNextLink() && result.ssc.IsEmpty() { 2889 err = result.NextWithContext(ctx) 2890 return 2891 } 2892 2893 return 2894} 2895 2896// ListPreparer prepares the List request. 2897func (client StaticSitesClient) ListPreparer(ctx context.Context) (*http.Request, error) { 2898 pathParameters := map[string]interface{}{ 2899 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2900 } 2901 2902 const APIVersion = "2020-12-01" 2903 queryParameters := map[string]interface{}{ 2904 "api-version": APIVersion, 2905 } 2906 2907 preparer := autorest.CreatePreparer( 2908 autorest.AsGet(), 2909 autorest.WithBaseURL(client.BaseURI), 2910 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/staticSites", pathParameters), 2911 autorest.WithQueryParameters(queryParameters)) 2912 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2913} 2914 2915// ListSender sends the List request. The method will close the 2916// http.Response Body if it receives an error. 2917func (client StaticSitesClient) ListSender(req *http.Request) (*http.Response, error) { 2918 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2919} 2920 2921// ListResponder handles the response to the List request. The method always 2922// closes the http.Response Body. 2923func (client StaticSitesClient) ListResponder(resp *http.Response) (result StaticSiteCollection, err error) { 2924 err = autorest.Respond( 2925 resp, 2926 azure.WithErrorUnlessStatusCode(http.StatusOK), 2927 autorest.ByUnmarshallingJSON(&result), 2928 autorest.ByClosing()) 2929 result.Response = autorest.Response{Response: resp} 2930 return 2931} 2932 2933// listNextResults retrieves the next set of results, if any. 2934func (client StaticSitesClient) listNextResults(ctx context.Context, lastResults StaticSiteCollection) (result StaticSiteCollection, err error) { 2935 req, err := lastResults.staticSiteCollectionPreparer(ctx) 2936 if err != nil { 2937 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listNextResults", nil, "Failure preparing next results request") 2938 } 2939 if req == nil { 2940 return 2941 } 2942 resp, err := client.ListSender(req) 2943 if err != nil { 2944 result.Response = autorest.Response{Response: resp} 2945 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listNextResults", resp, "Failure sending next results request") 2946 } 2947 result, err = client.ListResponder(resp) 2948 if err != nil { 2949 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "listNextResults", resp, "Failure responding to next results request") 2950 } 2951 return 2952} 2953 2954// ListComplete enumerates all values, automatically crossing page boundaries as required. 2955func (client StaticSitesClient) ListComplete(ctx context.Context) (result StaticSiteCollectionIterator, err error) { 2956 if tracing.IsEnabled() { 2957 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.List") 2958 defer func() { 2959 sc := -1 2960 if result.Response().Response.Response != nil { 2961 sc = result.page.Response().Response.Response.StatusCode 2962 } 2963 tracing.EndSpan(ctx, sc, err) 2964 }() 2965 } 2966 result.page, err = client.List(ctx) 2967 return 2968} 2969 2970// ListStaticSiteAppSettings description for Gets the application settings of a static site. 2971// Parameters: 2972// resourceGroupName - name of the resource group to which the resource belongs. 2973// name - name of the static site. 2974func (client StaticSitesClient) ListStaticSiteAppSettings(ctx context.Context, resourceGroupName string, name string) (result StringDictionary, err error) { 2975 if tracing.IsEnabled() { 2976 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteAppSettings") 2977 defer func() { 2978 sc := -1 2979 if result.Response.Response != nil { 2980 sc = result.Response.Response.StatusCode 2981 } 2982 tracing.EndSpan(ctx, sc, err) 2983 }() 2984 } 2985 if err := validation.Validate([]validation.Validation{ 2986 {TargetValue: resourceGroupName, 2987 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 2988 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 2989 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 2990 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteAppSettings", err.Error()) 2991 } 2992 2993 req, err := client.ListStaticSiteAppSettingsPreparer(ctx, resourceGroupName, name) 2994 if err != nil { 2995 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteAppSettings", nil, "Failure preparing request") 2996 return 2997 } 2998 2999 resp, err := client.ListStaticSiteAppSettingsSender(req) 3000 if err != nil { 3001 result.Response = autorest.Response{Response: resp} 3002 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteAppSettings", resp, "Failure sending request") 3003 return 3004 } 3005 3006 result, err = client.ListStaticSiteAppSettingsResponder(resp) 3007 if err != nil { 3008 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteAppSettings", resp, "Failure responding to request") 3009 return 3010 } 3011 3012 return 3013} 3014 3015// ListStaticSiteAppSettingsPreparer prepares the ListStaticSiteAppSettings request. 3016func (client StaticSitesClient) ListStaticSiteAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 3017 pathParameters := map[string]interface{}{ 3018 "name": autorest.Encode("path", name), 3019 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3020 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3021 } 3022 3023 const APIVersion = "2020-12-01" 3024 queryParameters := map[string]interface{}{ 3025 "api-version": APIVersion, 3026 } 3027 3028 preparer := autorest.CreatePreparer( 3029 autorest.AsPost(), 3030 autorest.WithBaseURL(client.BaseURI), 3031 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/listAppSettings", pathParameters), 3032 autorest.WithQueryParameters(queryParameters)) 3033 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3034} 3035 3036// ListStaticSiteAppSettingsSender sends the ListStaticSiteAppSettings request. The method will close the 3037// http.Response Body if it receives an error. 3038func (client StaticSitesClient) ListStaticSiteAppSettingsSender(req *http.Request) (*http.Response, error) { 3039 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3040} 3041 3042// ListStaticSiteAppSettingsResponder handles the response to the ListStaticSiteAppSettings request. The method always 3043// closes the http.Response Body. 3044func (client StaticSitesClient) ListStaticSiteAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 3045 err = autorest.Respond( 3046 resp, 3047 azure.WithErrorUnlessStatusCode(http.StatusOK), 3048 autorest.ByUnmarshallingJSON(&result), 3049 autorest.ByClosing()) 3050 result.Response = autorest.Response{Response: resp} 3051 return 3052} 3053 3054// ListStaticSiteBuildAppSettings description for Gets the application settings of a static site build. 3055// Parameters: 3056// resourceGroupName - name of the resource group to which the resource belongs. 3057// name - name of the static site. 3058// environmentName - the stage site identifier. 3059func (client StaticSitesClient) ListStaticSiteBuildAppSettings(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StringDictionary, err error) { 3060 if tracing.IsEnabled() { 3061 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteBuildAppSettings") 3062 defer func() { 3063 sc := -1 3064 if result.Response.Response != nil { 3065 sc = result.Response.Response.StatusCode 3066 } 3067 tracing.EndSpan(ctx, sc, err) 3068 }() 3069 } 3070 if err := validation.Validate([]validation.Validation{ 3071 {TargetValue: resourceGroupName, 3072 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3073 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3074 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3075 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteBuildAppSettings", err.Error()) 3076 } 3077 3078 req, err := client.ListStaticSiteBuildAppSettingsPreparer(ctx, resourceGroupName, name, environmentName) 3079 if err != nil { 3080 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildAppSettings", nil, "Failure preparing request") 3081 return 3082 } 3083 3084 resp, err := client.ListStaticSiteBuildAppSettingsSender(req) 3085 if err != nil { 3086 result.Response = autorest.Response{Response: resp} 3087 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildAppSettings", resp, "Failure sending request") 3088 return 3089 } 3090 3091 result, err = client.ListStaticSiteBuildAppSettingsResponder(resp) 3092 if err != nil { 3093 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildAppSettings", resp, "Failure responding to request") 3094 return 3095 } 3096 3097 return 3098} 3099 3100// ListStaticSiteBuildAppSettingsPreparer prepares the ListStaticSiteBuildAppSettings request. 3101func (client StaticSitesClient) ListStaticSiteBuildAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string) (*http.Request, error) { 3102 pathParameters := map[string]interface{}{ 3103 "environmentName": autorest.Encode("path", environmentName), 3104 "name": autorest.Encode("path", name), 3105 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3106 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3107 } 3108 3109 const APIVersion = "2020-12-01" 3110 queryParameters := map[string]interface{}{ 3111 "api-version": APIVersion, 3112 } 3113 3114 preparer := autorest.CreatePreparer( 3115 autorest.AsPost(), 3116 autorest.WithBaseURL(client.BaseURI), 3117 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/listAppSettings", pathParameters), 3118 autorest.WithQueryParameters(queryParameters)) 3119 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3120} 3121 3122// ListStaticSiteBuildAppSettingsSender sends the ListStaticSiteBuildAppSettings request. The method will close the 3123// http.Response Body if it receives an error. 3124func (client StaticSitesClient) ListStaticSiteBuildAppSettingsSender(req *http.Request) (*http.Response, error) { 3125 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3126} 3127 3128// ListStaticSiteBuildAppSettingsResponder handles the response to the ListStaticSiteBuildAppSettings request. The method always 3129// closes the http.Response Body. 3130func (client StaticSitesClient) ListStaticSiteBuildAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 3131 err = autorest.Respond( 3132 resp, 3133 azure.WithErrorUnlessStatusCode(http.StatusOK), 3134 autorest.ByUnmarshallingJSON(&result), 3135 autorest.ByClosing()) 3136 result.Response = autorest.Response{Response: resp} 3137 return 3138} 3139 3140// ListStaticSiteBuildFunctionAppSettings description for Gets the application settings of a static site build. 3141// Parameters: 3142// resourceGroupName - name of the resource group to which the resource belongs. 3143// name - name of the static site. 3144// environmentName - the stage site identifier. 3145func (client StaticSitesClient) ListStaticSiteBuildFunctionAppSettings(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StringDictionary, err error) { 3146 if tracing.IsEnabled() { 3147 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteBuildFunctionAppSettings") 3148 defer func() { 3149 sc := -1 3150 if result.Response.Response != nil { 3151 sc = result.Response.Response.StatusCode 3152 } 3153 tracing.EndSpan(ctx, sc, err) 3154 }() 3155 } 3156 if err := validation.Validate([]validation.Validation{ 3157 {TargetValue: resourceGroupName, 3158 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3159 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3160 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3161 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteBuildFunctionAppSettings", err.Error()) 3162 } 3163 3164 req, err := client.ListStaticSiteBuildFunctionAppSettingsPreparer(ctx, resourceGroupName, name, environmentName) 3165 if err != nil { 3166 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildFunctionAppSettings", nil, "Failure preparing request") 3167 return 3168 } 3169 3170 resp, err := client.ListStaticSiteBuildFunctionAppSettingsSender(req) 3171 if err != nil { 3172 result.Response = autorest.Response{Response: resp} 3173 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildFunctionAppSettings", resp, "Failure sending request") 3174 return 3175 } 3176 3177 result, err = client.ListStaticSiteBuildFunctionAppSettingsResponder(resp) 3178 if err != nil { 3179 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildFunctionAppSettings", resp, "Failure responding to request") 3180 return 3181 } 3182 3183 return 3184} 3185 3186// ListStaticSiteBuildFunctionAppSettingsPreparer prepares the ListStaticSiteBuildFunctionAppSettings request. 3187func (client StaticSitesClient) ListStaticSiteBuildFunctionAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string) (*http.Request, error) { 3188 pathParameters := map[string]interface{}{ 3189 "environmentName": autorest.Encode("path", environmentName), 3190 "name": autorest.Encode("path", name), 3191 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3192 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3193 } 3194 3195 const APIVersion = "2020-12-01" 3196 queryParameters := map[string]interface{}{ 3197 "api-version": APIVersion, 3198 } 3199 3200 preparer := autorest.CreatePreparer( 3201 autorest.AsPost(), 3202 autorest.WithBaseURL(client.BaseURI), 3203 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/listFunctionAppSettings", pathParameters), 3204 autorest.WithQueryParameters(queryParameters)) 3205 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3206} 3207 3208// ListStaticSiteBuildFunctionAppSettingsSender sends the ListStaticSiteBuildFunctionAppSettings request. The method will close the 3209// http.Response Body if it receives an error. 3210func (client StaticSitesClient) ListStaticSiteBuildFunctionAppSettingsSender(req *http.Request) (*http.Response, error) { 3211 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3212} 3213 3214// ListStaticSiteBuildFunctionAppSettingsResponder handles the response to the ListStaticSiteBuildFunctionAppSettings request. The method always 3215// closes the http.Response Body. 3216func (client StaticSitesClient) ListStaticSiteBuildFunctionAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 3217 err = autorest.Respond( 3218 resp, 3219 azure.WithErrorUnlessStatusCode(http.StatusOK), 3220 autorest.ByUnmarshallingJSON(&result), 3221 autorest.ByClosing()) 3222 result.Response = autorest.Response{Response: resp} 3223 return 3224} 3225 3226// ListStaticSiteBuildFunctions description for Gets the functions of a particular static site build. 3227// Parameters: 3228// resourceGroupName - name of the resource group to which the resource belongs. 3229// name - name of the static site. 3230// environmentName - the stage site identifier. 3231func (client StaticSitesClient) ListStaticSiteBuildFunctions(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StaticSiteFunctionOverviewCollectionPage, err error) { 3232 if tracing.IsEnabled() { 3233 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteBuildFunctions") 3234 defer func() { 3235 sc := -1 3236 if result.ssfoc.Response.Response != nil { 3237 sc = result.ssfoc.Response.Response.StatusCode 3238 } 3239 tracing.EndSpan(ctx, sc, err) 3240 }() 3241 } 3242 if err := validation.Validate([]validation.Validation{ 3243 {TargetValue: resourceGroupName, 3244 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3245 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3246 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3247 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteBuildFunctions", err.Error()) 3248 } 3249 3250 result.fn = client.listStaticSiteBuildFunctionsNextResults 3251 req, err := client.ListStaticSiteBuildFunctionsPreparer(ctx, resourceGroupName, name, environmentName) 3252 if err != nil { 3253 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildFunctions", nil, "Failure preparing request") 3254 return 3255 } 3256 3257 resp, err := client.ListStaticSiteBuildFunctionsSender(req) 3258 if err != nil { 3259 result.ssfoc.Response = autorest.Response{Response: resp} 3260 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildFunctions", resp, "Failure sending request") 3261 return 3262 } 3263 3264 result.ssfoc, err = client.ListStaticSiteBuildFunctionsResponder(resp) 3265 if err != nil { 3266 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteBuildFunctions", resp, "Failure responding to request") 3267 return 3268 } 3269 if result.ssfoc.hasNextLink() && result.ssfoc.IsEmpty() { 3270 err = result.NextWithContext(ctx) 3271 return 3272 } 3273 3274 return 3275} 3276 3277// ListStaticSiteBuildFunctionsPreparer prepares the ListStaticSiteBuildFunctions request. 3278func (client StaticSitesClient) ListStaticSiteBuildFunctionsPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string) (*http.Request, error) { 3279 pathParameters := map[string]interface{}{ 3280 "environmentName": autorest.Encode("path", environmentName), 3281 "name": autorest.Encode("path", name), 3282 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3283 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3284 } 3285 3286 const APIVersion = "2020-12-01" 3287 queryParameters := map[string]interface{}{ 3288 "api-version": APIVersion, 3289 } 3290 3291 preparer := autorest.CreatePreparer( 3292 autorest.AsGet(), 3293 autorest.WithBaseURL(client.BaseURI), 3294 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/functions", pathParameters), 3295 autorest.WithQueryParameters(queryParameters)) 3296 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3297} 3298 3299// ListStaticSiteBuildFunctionsSender sends the ListStaticSiteBuildFunctions request. The method will close the 3300// http.Response Body if it receives an error. 3301func (client StaticSitesClient) ListStaticSiteBuildFunctionsSender(req *http.Request) (*http.Response, error) { 3302 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3303} 3304 3305// ListStaticSiteBuildFunctionsResponder handles the response to the ListStaticSiteBuildFunctions request. The method always 3306// closes the http.Response Body. 3307func (client StaticSitesClient) ListStaticSiteBuildFunctionsResponder(resp *http.Response) (result StaticSiteFunctionOverviewCollection, err error) { 3308 err = autorest.Respond( 3309 resp, 3310 azure.WithErrorUnlessStatusCode(http.StatusOK), 3311 autorest.ByUnmarshallingJSON(&result), 3312 autorest.ByClosing()) 3313 result.Response = autorest.Response{Response: resp} 3314 return 3315} 3316 3317// listStaticSiteBuildFunctionsNextResults retrieves the next set of results, if any. 3318func (client StaticSitesClient) listStaticSiteBuildFunctionsNextResults(ctx context.Context, lastResults StaticSiteFunctionOverviewCollection) (result StaticSiteFunctionOverviewCollection, err error) { 3319 req, err := lastResults.staticSiteFunctionOverviewCollectionPreparer(ctx) 3320 if err != nil { 3321 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteBuildFunctionsNextResults", nil, "Failure preparing next results request") 3322 } 3323 if req == nil { 3324 return 3325 } 3326 resp, err := client.ListStaticSiteBuildFunctionsSender(req) 3327 if err != nil { 3328 result.Response = autorest.Response{Response: resp} 3329 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteBuildFunctionsNextResults", resp, "Failure sending next results request") 3330 } 3331 result, err = client.ListStaticSiteBuildFunctionsResponder(resp) 3332 if err != nil { 3333 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteBuildFunctionsNextResults", resp, "Failure responding to next results request") 3334 } 3335 return 3336} 3337 3338// ListStaticSiteBuildFunctionsComplete enumerates all values, automatically crossing page boundaries as required. 3339func (client StaticSitesClient) ListStaticSiteBuildFunctionsComplete(ctx context.Context, resourceGroupName string, name string, environmentName string) (result StaticSiteFunctionOverviewCollectionIterator, err error) { 3340 if tracing.IsEnabled() { 3341 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteBuildFunctions") 3342 defer func() { 3343 sc := -1 3344 if result.Response().Response.Response != nil { 3345 sc = result.page.Response().Response.Response.StatusCode 3346 } 3347 tracing.EndSpan(ctx, sc, err) 3348 }() 3349 } 3350 result.page, err = client.ListStaticSiteBuildFunctions(ctx, resourceGroupName, name, environmentName) 3351 return 3352} 3353 3354// ListStaticSiteConfiguredRoles description for Lists the roles configured for the static site. 3355// Parameters: 3356// resourceGroupName - name of the resource group to which the resource belongs. 3357// name - name of the static site. 3358func (client StaticSitesClient) ListStaticSiteConfiguredRoles(ctx context.Context, resourceGroupName string, name string) (result StringList, err error) { 3359 if tracing.IsEnabled() { 3360 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteConfiguredRoles") 3361 defer func() { 3362 sc := -1 3363 if result.Response.Response != nil { 3364 sc = result.Response.Response.StatusCode 3365 } 3366 tracing.EndSpan(ctx, sc, err) 3367 }() 3368 } 3369 if err := validation.Validate([]validation.Validation{ 3370 {TargetValue: resourceGroupName, 3371 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3372 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3373 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3374 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteConfiguredRoles", err.Error()) 3375 } 3376 3377 req, err := client.ListStaticSiteConfiguredRolesPreparer(ctx, resourceGroupName, name) 3378 if err != nil { 3379 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteConfiguredRoles", nil, "Failure preparing request") 3380 return 3381 } 3382 3383 resp, err := client.ListStaticSiteConfiguredRolesSender(req) 3384 if err != nil { 3385 result.Response = autorest.Response{Response: resp} 3386 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteConfiguredRoles", resp, "Failure sending request") 3387 return 3388 } 3389 3390 result, err = client.ListStaticSiteConfiguredRolesResponder(resp) 3391 if err != nil { 3392 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteConfiguredRoles", resp, "Failure responding to request") 3393 return 3394 } 3395 3396 return 3397} 3398 3399// ListStaticSiteConfiguredRolesPreparer prepares the ListStaticSiteConfiguredRoles request. 3400func (client StaticSitesClient) ListStaticSiteConfiguredRolesPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 3401 pathParameters := map[string]interface{}{ 3402 "name": autorest.Encode("path", name), 3403 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3404 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3405 } 3406 3407 const APIVersion = "2020-12-01" 3408 queryParameters := map[string]interface{}{ 3409 "api-version": APIVersion, 3410 } 3411 3412 preparer := autorest.CreatePreparer( 3413 autorest.AsPost(), 3414 autorest.WithBaseURL(client.BaseURI), 3415 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/listConfiguredRoles", pathParameters), 3416 autorest.WithQueryParameters(queryParameters)) 3417 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3418} 3419 3420// ListStaticSiteConfiguredRolesSender sends the ListStaticSiteConfiguredRoles request. The method will close the 3421// http.Response Body if it receives an error. 3422func (client StaticSitesClient) ListStaticSiteConfiguredRolesSender(req *http.Request) (*http.Response, error) { 3423 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3424} 3425 3426// ListStaticSiteConfiguredRolesResponder handles the response to the ListStaticSiteConfiguredRoles request. The method always 3427// closes the http.Response Body. 3428func (client StaticSitesClient) ListStaticSiteConfiguredRolesResponder(resp *http.Response) (result StringList, err error) { 3429 err = autorest.Respond( 3430 resp, 3431 azure.WithErrorUnlessStatusCode(http.StatusOK), 3432 autorest.ByUnmarshallingJSON(&result), 3433 autorest.ByClosing()) 3434 result.Response = autorest.Response{Response: resp} 3435 return 3436} 3437 3438// ListStaticSiteCustomDomains description for Gets all static site custom domains for a particular static site. 3439// Parameters: 3440// resourceGroupName - name of the resource group to which the resource belongs. 3441// name - name of the static site resource to search in. 3442func (client StaticSitesClient) ListStaticSiteCustomDomains(ctx context.Context, resourceGroupName string, name string) (result StaticSiteCustomDomainOverviewCollectionPage, err error) { 3443 if tracing.IsEnabled() { 3444 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteCustomDomains") 3445 defer func() { 3446 sc := -1 3447 if result.sscdoc.Response.Response != nil { 3448 sc = result.sscdoc.Response.Response.StatusCode 3449 } 3450 tracing.EndSpan(ctx, sc, err) 3451 }() 3452 } 3453 if err := validation.Validate([]validation.Validation{ 3454 {TargetValue: resourceGroupName, 3455 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3456 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3457 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3458 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteCustomDomains", err.Error()) 3459 } 3460 3461 result.fn = client.listStaticSiteCustomDomainsNextResults 3462 req, err := client.ListStaticSiteCustomDomainsPreparer(ctx, resourceGroupName, name) 3463 if err != nil { 3464 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteCustomDomains", nil, "Failure preparing request") 3465 return 3466 } 3467 3468 resp, err := client.ListStaticSiteCustomDomainsSender(req) 3469 if err != nil { 3470 result.sscdoc.Response = autorest.Response{Response: resp} 3471 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteCustomDomains", resp, "Failure sending request") 3472 return 3473 } 3474 3475 result.sscdoc, err = client.ListStaticSiteCustomDomainsResponder(resp) 3476 if err != nil { 3477 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteCustomDomains", resp, "Failure responding to request") 3478 return 3479 } 3480 if result.sscdoc.hasNextLink() && result.sscdoc.IsEmpty() { 3481 err = result.NextWithContext(ctx) 3482 return 3483 } 3484 3485 return 3486} 3487 3488// ListStaticSiteCustomDomainsPreparer prepares the ListStaticSiteCustomDomains request. 3489func (client StaticSitesClient) ListStaticSiteCustomDomainsPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 3490 pathParameters := map[string]interface{}{ 3491 "name": autorest.Encode("path", name), 3492 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3493 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3494 } 3495 3496 const APIVersion = "2020-12-01" 3497 queryParameters := map[string]interface{}{ 3498 "api-version": APIVersion, 3499 } 3500 3501 preparer := autorest.CreatePreparer( 3502 autorest.AsGet(), 3503 autorest.WithBaseURL(client.BaseURI), 3504 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/customDomains", pathParameters), 3505 autorest.WithQueryParameters(queryParameters)) 3506 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3507} 3508 3509// ListStaticSiteCustomDomainsSender sends the ListStaticSiteCustomDomains request. The method will close the 3510// http.Response Body if it receives an error. 3511func (client StaticSitesClient) ListStaticSiteCustomDomainsSender(req *http.Request) (*http.Response, error) { 3512 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3513} 3514 3515// ListStaticSiteCustomDomainsResponder handles the response to the ListStaticSiteCustomDomains request. The method always 3516// closes the http.Response Body. 3517func (client StaticSitesClient) ListStaticSiteCustomDomainsResponder(resp *http.Response) (result StaticSiteCustomDomainOverviewCollection, err error) { 3518 err = autorest.Respond( 3519 resp, 3520 azure.WithErrorUnlessStatusCode(http.StatusOK), 3521 autorest.ByUnmarshallingJSON(&result), 3522 autorest.ByClosing()) 3523 result.Response = autorest.Response{Response: resp} 3524 return 3525} 3526 3527// listStaticSiteCustomDomainsNextResults retrieves the next set of results, if any. 3528func (client StaticSitesClient) listStaticSiteCustomDomainsNextResults(ctx context.Context, lastResults StaticSiteCustomDomainOverviewCollection) (result StaticSiteCustomDomainOverviewCollection, err error) { 3529 req, err := lastResults.staticSiteCustomDomainOverviewCollectionPreparer(ctx) 3530 if err != nil { 3531 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteCustomDomainsNextResults", nil, "Failure preparing next results request") 3532 } 3533 if req == nil { 3534 return 3535 } 3536 resp, err := client.ListStaticSiteCustomDomainsSender(req) 3537 if err != nil { 3538 result.Response = autorest.Response{Response: resp} 3539 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteCustomDomainsNextResults", resp, "Failure sending next results request") 3540 } 3541 result, err = client.ListStaticSiteCustomDomainsResponder(resp) 3542 if err != nil { 3543 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteCustomDomainsNextResults", resp, "Failure responding to next results request") 3544 } 3545 return 3546} 3547 3548// ListStaticSiteCustomDomainsComplete enumerates all values, automatically crossing page boundaries as required. 3549func (client StaticSitesClient) ListStaticSiteCustomDomainsComplete(ctx context.Context, resourceGroupName string, name string) (result StaticSiteCustomDomainOverviewCollectionIterator, err error) { 3550 if tracing.IsEnabled() { 3551 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteCustomDomains") 3552 defer func() { 3553 sc := -1 3554 if result.Response().Response.Response != nil { 3555 sc = result.page.Response().Response.Response.StatusCode 3556 } 3557 tracing.EndSpan(ctx, sc, err) 3558 }() 3559 } 3560 result.page, err = client.ListStaticSiteCustomDomains(ctx, resourceGroupName, name) 3561 return 3562} 3563 3564// ListStaticSiteFunctionAppSettings description for Gets the application settings of a static site. 3565// Parameters: 3566// resourceGroupName - name of the resource group to which the resource belongs. 3567// name - name of the static site. 3568func (client StaticSitesClient) ListStaticSiteFunctionAppSettings(ctx context.Context, resourceGroupName string, name string) (result StringDictionary, err error) { 3569 if tracing.IsEnabled() { 3570 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteFunctionAppSettings") 3571 defer func() { 3572 sc := -1 3573 if result.Response.Response != nil { 3574 sc = result.Response.Response.StatusCode 3575 } 3576 tracing.EndSpan(ctx, sc, err) 3577 }() 3578 } 3579 if err := validation.Validate([]validation.Validation{ 3580 {TargetValue: resourceGroupName, 3581 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3582 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3583 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3584 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteFunctionAppSettings", err.Error()) 3585 } 3586 3587 req, err := client.ListStaticSiteFunctionAppSettingsPreparer(ctx, resourceGroupName, name) 3588 if err != nil { 3589 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteFunctionAppSettings", nil, "Failure preparing request") 3590 return 3591 } 3592 3593 resp, err := client.ListStaticSiteFunctionAppSettingsSender(req) 3594 if err != nil { 3595 result.Response = autorest.Response{Response: resp} 3596 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteFunctionAppSettings", resp, "Failure sending request") 3597 return 3598 } 3599 3600 result, err = client.ListStaticSiteFunctionAppSettingsResponder(resp) 3601 if err != nil { 3602 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteFunctionAppSettings", resp, "Failure responding to request") 3603 return 3604 } 3605 3606 return 3607} 3608 3609// ListStaticSiteFunctionAppSettingsPreparer prepares the ListStaticSiteFunctionAppSettings request. 3610func (client StaticSitesClient) ListStaticSiteFunctionAppSettingsPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 3611 pathParameters := map[string]interface{}{ 3612 "name": autorest.Encode("path", name), 3613 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3614 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3615 } 3616 3617 const APIVersion = "2020-12-01" 3618 queryParameters := map[string]interface{}{ 3619 "api-version": APIVersion, 3620 } 3621 3622 preparer := autorest.CreatePreparer( 3623 autorest.AsPost(), 3624 autorest.WithBaseURL(client.BaseURI), 3625 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/listFunctionAppSettings", pathParameters), 3626 autorest.WithQueryParameters(queryParameters)) 3627 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3628} 3629 3630// ListStaticSiteFunctionAppSettingsSender sends the ListStaticSiteFunctionAppSettings request. The method will close the 3631// http.Response Body if it receives an error. 3632func (client StaticSitesClient) ListStaticSiteFunctionAppSettingsSender(req *http.Request) (*http.Response, error) { 3633 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3634} 3635 3636// ListStaticSiteFunctionAppSettingsResponder handles the response to the ListStaticSiteFunctionAppSettings request. The method always 3637// closes the http.Response Body. 3638func (client StaticSitesClient) ListStaticSiteFunctionAppSettingsResponder(resp *http.Response) (result StringDictionary, err error) { 3639 err = autorest.Respond( 3640 resp, 3641 azure.WithErrorUnlessStatusCode(http.StatusOK), 3642 autorest.ByUnmarshallingJSON(&result), 3643 autorest.ByClosing()) 3644 result.Response = autorest.Response{Response: resp} 3645 return 3646} 3647 3648// ListStaticSiteFunctions description for Gets the functions of a static site. 3649// Parameters: 3650// resourceGroupName - name of the resource group to which the resource belongs. 3651// name - name of the static site. 3652func (client StaticSitesClient) ListStaticSiteFunctions(ctx context.Context, resourceGroupName string, name string) (result StaticSiteFunctionOverviewCollectionPage, err error) { 3653 if tracing.IsEnabled() { 3654 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteFunctions") 3655 defer func() { 3656 sc := -1 3657 if result.ssfoc.Response.Response != nil { 3658 sc = result.ssfoc.Response.Response.StatusCode 3659 } 3660 tracing.EndSpan(ctx, sc, err) 3661 }() 3662 } 3663 if err := validation.Validate([]validation.Validation{ 3664 {TargetValue: resourceGroupName, 3665 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3666 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3667 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3668 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteFunctions", err.Error()) 3669 } 3670 3671 result.fn = client.listStaticSiteFunctionsNextResults 3672 req, err := client.ListStaticSiteFunctionsPreparer(ctx, resourceGroupName, name) 3673 if err != nil { 3674 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteFunctions", nil, "Failure preparing request") 3675 return 3676 } 3677 3678 resp, err := client.ListStaticSiteFunctionsSender(req) 3679 if err != nil { 3680 result.ssfoc.Response = autorest.Response{Response: resp} 3681 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteFunctions", resp, "Failure sending request") 3682 return 3683 } 3684 3685 result.ssfoc, err = client.ListStaticSiteFunctionsResponder(resp) 3686 if err != nil { 3687 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteFunctions", resp, "Failure responding to request") 3688 return 3689 } 3690 if result.ssfoc.hasNextLink() && result.ssfoc.IsEmpty() { 3691 err = result.NextWithContext(ctx) 3692 return 3693 } 3694 3695 return 3696} 3697 3698// ListStaticSiteFunctionsPreparer prepares the ListStaticSiteFunctions request. 3699func (client StaticSitesClient) ListStaticSiteFunctionsPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 3700 pathParameters := map[string]interface{}{ 3701 "name": autorest.Encode("path", name), 3702 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3703 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3704 } 3705 3706 const APIVersion = "2020-12-01" 3707 queryParameters := map[string]interface{}{ 3708 "api-version": APIVersion, 3709 } 3710 3711 preparer := autorest.CreatePreparer( 3712 autorest.AsGet(), 3713 autorest.WithBaseURL(client.BaseURI), 3714 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/functions", pathParameters), 3715 autorest.WithQueryParameters(queryParameters)) 3716 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3717} 3718 3719// ListStaticSiteFunctionsSender sends the ListStaticSiteFunctions request. The method will close the 3720// http.Response Body if it receives an error. 3721func (client StaticSitesClient) ListStaticSiteFunctionsSender(req *http.Request) (*http.Response, error) { 3722 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3723} 3724 3725// ListStaticSiteFunctionsResponder handles the response to the ListStaticSiteFunctions request. The method always 3726// closes the http.Response Body. 3727func (client StaticSitesClient) ListStaticSiteFunctionsResponder(resp *http.Response) (result StaticSiteFunctionOverviewCollection, err error) { 3728 err = autorest.Respond( 3729 resp, 3730 azure.WithErrorUnlessStatusCode(http.StatusOK), 3731 autorest.ByUnmarshallingJSON(&result), 3732 autorest.ByClosing()) 3733 result.Response = autorest.Response{Response: resp} 3734 return 3735} 3736 3737// listStaticSiteFunctionsNextResults retrieves the next set of results, if any. 3738func (client StaticSitesClient) listStaticSiteFunctionsNextResults(ctx context.Context, lastResults StaticSiteFunctionOverviewCollection) (result StaticSiteFunctionOverviewCollection, err error) { 3739 req, err := lastResults.staticSiteFunctionOverviewCollectionPreparer(ctx) 3740 if err != nil { 3741 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteFunctionsNextResults", nil, "Failure preparing next results request") 3742 } 3743 if req == nil { 3744 return 3745 } 3746 resp, err := client.ListStaticSiteFunctionsSender(req) 3747 if err != nil { 3748 result.Response = autorest.Response{Response: resp} 3749 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteFunctionsNextResults", resp, "Failure sending next results request") 3750 } 3751 result, err = client.ListStaticSiteFunctionsResponder(resp) 3752 if err != nil { 3753 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteFunctionsNextResults", resp, "Failure responding to next results request") 3754 } 3755 return 3756} 3757 3758// ListStaticSiteFunctionsComplete enumerates all values, automatically crossing page boundaries as required. 3759func (client StaticSitesClient) ListStaticSiteFunctionsComplete(ctx context.Context, resourceGroupName string, name string) (result StaticSiteFunctionOverviewCollectionIterator, err error) { 3760 if tracing.IsEnabled() { 3761 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteFunctions") 3762 defer func() { 3763 sc := -1 3764 if result.Response().Response.Response != nil { 3765 sc = result.page.Response().Response.Response.StatusCode 3766 } 3767 tracing.EndSpan(ctx, sc, err) 3768 }() 3769 } 3770 result.page, err = client.ListStaticSiteFunctions(ctx, resourceGroupName, name) 3771 return 3772} 3773 3774// ListStaticSiteSecrets description for Lists the secrets for an existing static site. 3775// Parameters: 3776// resourceGroupName - name of the resource group to which the resource belongs. 3777// name - name of the static site. 3778func (client StaticSitesClient) ListStaticSiteSecrets(ctx context.Context, resourceGroupName string, name string) (result StringDictionary, err error) { 3779 if tracing.IsEnabled() { 3780 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteSecrets") 3781 defer func() { 3782 sc := -1 3783 if result.Response.Response != nil { 3784 sc = result.Response.Response.StatusCode 3785 } 3786 tracing.EndSpan(ctx, sc, err) 3787 }() 3788 } 3789 if err := validation.Validate([]validation.Validation{ 3790 {TargetValue: resourceGroupName, 3791 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3792 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3793 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3794 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteSecrets", err.Error()) 3795 } 3796 3797 req, err := client.ListStaticSiteSecretsPreparer(ctx, resourceGroupName, name) 3798 if err != nil { 3799 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteSecrets", nil, "Failure preparing request") 3800 return 3801 } 3802 3803 resp, err := client.ListStaticSiteSecretsSender(req) 3804 if err != nil { 3805 result.Response = autorest.Response{Response: resp} 3806 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteSecrets", resp, "Failure sending request") 3807 return 3808 } 3809 3810 result, err = client.ListStaticSiteSecretsResponder(resp) 3811 if err != nil { 3812 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteSecrets", resp, "Failure responding to request") 3813 return 3814 } 3815 3816 return 3817} 3818 3819// ListStaticSiteSecretsPreparer prepares the ListStaticSiteSecrets request. 3820func (client StaticSitesClient) ListStaticSiteSecretsPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) { 3821 pathParameters := map[string]interface{}{ 3822 "name": autorest.Encode("path", name), 3823 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3824 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3825 } 3826 3827 const APIVersion = "2020-12-01" 3828 queryParameters := map[string]interface{}{ 3829 "api-version": APIVersion, 3830 } 3831 3832 preparer := autorest.CreatePreparer( 3833 autorest.AsPost(), 3834 autorest.WithBaseURL(client.BaseURI), 3835 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/listSecrets", pathParameters), 3836 autorest.WithQueryParameters(queryParameters)) 3837 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3838} 3839 3840// ListStaticSiteSecretsSender sends the ListStaticSiteSecrets request. The method will close the 3841// http.Response Body if it receives an error. 3842func (client StaticSitesClient) ListStaticSiteSecretsSender(req *http.Request) (*http.Response, error) { 3843 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3844} 3845 3846// ListStaticSiteSecretsResponder handles the response to the ListStaticSiteSecrets request. The method always 3847// closes the http.Response Body. 3848func (client StaticSitesClient) ListStaticSiteSecretsResponder(resp *http.Response) (result StringDictionary, err error) { 3849 err = autorest.Respond( 3850 resp, 3851 azure.WithErrorUnlessStatusCode(http.StatusOK), 3852 autorest.ByUnmarshallingJSON(&result), 3853 autorest.ByClosing()) 3854 result.Response = autorest.Response{Response: resp} 3855 return 3856} 3857 3858// ListStaticSiteUsers description for Gets the list of users of a static site. 3859// Parameters: 3860// resourceGroupName - name of the resource group to which the resource belongs. 3861// name - name of the static site. 3862// authprovider - the auth provider for the users. 3863func (client StaticSitesClient) ListStaticSiteUsers(ctx context.Context, resourceGroupName string, name string, authprovider string) (result StaticSiteUserCollectionPage, err error) { 3864 if tracing.IsEnabled() { 3865 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteUsers") 3866 defer func() { 3867 sc := -1 3868 if result.ssuc.Response.Response != nil { 3869 sc = result.ssuc.Response.Response.StatusCode 3870 } 3871 tracing.EndSpan(ctx, sc, err) 3872 }() 3873 } 3874 if err := validation.Validate([]validation.Validation{ 3875 {TargetValue: resourceGroupName, 3876 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 3877 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 3878 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 3879 return result, validation.NewError("web.StaticSitesClient", "ListStaticSiteUsers", err.Error()) 3880 } 3881 3882 result.fn = client.listStaticSiteUsersNextResults 3883 req, err := client.ListStaticSiteUsersPreparer(ctx, resourceGroupName, name, authprovider) 3884 if err != nil { 3885 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteUsers", nil, "Failure preparing request") 3886 return 3887 } 3888 3889 resp, err := client.ListStaticSiteUsersSender(req) 3890 if err != nil { 3891 result.ssuc.Response = autorest.Response{Response: resp} 3892 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteUsers", resp, "Failure sending request") 3893 return 3894 } 3895 3896 result.ssuc, err = client.ListStaticSiteUsersResponder(resp) 3897 if err != nil { 3898 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ListStaticSiteUsers", resp, "Failure responding to request") 3899 return 3900 } 3901 if result.ssuc.hasNextLink() && result.ssuc.IsEmpty() { 3902 err = result.NextWithContext(ctx) 3903 return 3904 } 3905 3906 return 3907} 3908 3909// ListStaticSiteUsersPreparer prepares the ListStaticSiteUsers request. 3910func (client StaticSitesClient) ListStaticSiteUsersPreparer(ctx context.Context, resourceGroupName string, name string, authprovider string) (*http.Request, error) { 3911 pathParameters := map[string]interface{}{ 3912 "authprovider": autorest.Encode("path", authprovider), 3913 "name": autorest.Encode("path", name), 3914 "resourceGroupName": autorest.Encode("path", resourceGroupName), 3915 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 3916 } 3917 3918 const APIVersion = "2020-12-01" 3919 queryParameters := map[string]interface{}{ 3920 "api-version": APIVersion, 3921 } 3922 3923 preparer := autorest.CreatePreparer( 3924 autorest.AsPost(), 3925 autorest.WithBaseURL(client.BaseURI), 3926 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/authproviders/{authprovider}/listUsers", pathParameters), 3927 autorest.WithQueryParameters(queryParameters)) 3928 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 3929} 3930 3931// ListStaticSiteUsersSender sends the ListStaticSiteUsers request. The method will close the 3932// http.Response Body if it receives an error. 3933func (client StaticSitesClient) ListStaticSiteUsersSender(req *http.Request) (*http.Response, error) { 3934 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 3935} 3936 3937// ListStaticSiteUsersResponder handles the response to the ListStaticSiteUsers request. The method always 3938// closes the http.Response Body. 3939func (client StaticSitesClient) ListStaticSiteUsersResponder(resp *http.Response) (result StaticSiteUserCollection, err error) { 3940 err = autorest.Respond( 3941 resp, 3942 azure.WithErrorUnlessStatusCode(http.StatusOK), 3943 autorest.ByUnmarshallingJSON(&result), 3944 autorest.ByClosing()) 3945 result.Response = autorest.Response{Response: resp} 3946 return 3947} 3948 3949// listStaticSiteUsersNextResults retrieves the next set of results, if any. 3950func (client StaticSitesClient) listStaticSiteUsersNextResults(ctx context.Context, lastResults StaticSiteUserCollection) (result StaticSiteUserCollection, err error) { 3951 req, err := lastResults.staticSiteUserCollectionPreparer(ctx) 3952 if err != nil { 3953 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteUsersNextResults", nil, "Failure preparing next results request") 3954 } 3955 if req == nil { 3956 return 3957 } 3958 resp, err := client.ListStaticSiteUsersSender(req) 3959 if err != nil { 3960 result.Response = autorest.Response{Response: resp} 3961 return result, autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteUsersNextResults", resp, "Failure sending next results request") 3962 } 3963 result, err = client.ListStaticSiteUsersResponder(resp) 3964 if err != nil { 3965 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "listStaticSiteUsersNextResults", resp, "Failure responding to next results request") 3966 } 3967 return 3968} 3969 3970// ListStaticSiteUsersComplete enumerates all values, automatically crossing page boundaries as required. 3971func (client StaticSitesClient) ListStaticSiteUsersComplete(ctx context.Context, resourceGroupName string, name string, authprovider string) (result StaticSiteUserCollectionIterator, err error) { 3972 if tracing.IsEnabled() { 3973 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ListStaticSiteUsers") 3974 defer func() { 3975 sc := -1 3976 if result.Response().Response.Response != nil { 3977 sc = result.page.Response().Response.Response.StatusCode 3978 } 3979 tracing.EndSpan(ctx, sc, err) 3980 }() 3981 } 3982 result.page, err = client.ListStaticSiteUsers(ctx, resourceGroupName, name, authprovider) 3983 return 3984} 3985 3986// PreviewWorkflow description for Generates a preview workflow file for the static site 3987// Parameters: 3988// location - location where you plan to create the static site. 3989// staticSitesWorkflowPreviewRequest - a JSON representation of the StaticSitesWorkflowPreviewRequest 3990// properties. See example. 3991func (client StaticSitesClient) PreviewWorkflow(ctx context.Context, location string, staticSitesWorkflowPreviewRequest StaticSitesWorkflowPreviewRequest) (result StaticSitesWorkflowPreview, err error) { 3992 if tracing.IsEnabled() { 3993 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.PreviewWorkflow") 3994 defer func() { 3995 sc := -1 3996 if result.Response.Response != nil { 3997 sc = result.Response.Response.StatusCode 3998 } 3999 tracing.EndSpan(ctx, sc, err) 4000 }() 4001 } 4002 req, err := client.PreviewWorkflowPreparer(ctx, location, staticSitesWorkflowPreviewRequest) 4003 if err != nil { 4004 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "PreviewWorkflow", nil, "Failure preparing request") 4005 return 4006 } 4007 4008 resp, err := client.PreviewWorkflowSender(req) 4009 if err != nil { 4010 result.Response = autorest.Response{Response: resp} 4011 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "PreviewWorkflow", resp, "Failure sending request") 4012 return 4013 } 4014 4015 result, err = client.PreviewWorkflowResponder(resp) 4016 if err != nil { 4017 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "PreviewWorkflow", resp, "Failure responding to request") 4018 return 4019 } 4020 4021 return 4022} 4023 4024// PreviewWorkflowPreparer prepares the PreviewWorkflow request. 4025func (client StaticSitesClient) PreviewWorkflowPreparer(ctx context.Context, location string, staticSitesWorkflowPreviewRequest StaticSitesWorkflowPreviewRequest) (*http.Request, error) { 4026 pathParameters := map[string]interface{}{ 4027 "location": autorest.Encode("path", location), 4028 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 4029 } 4030 4031 const APIVersion = "2020-12-01" 4032 queryParameters := map[string]interface{}{ 4033 "api-version": APIVersion, 4034 } 4035 4036 preparer := autorest.CreatePreparer( 4037 autorest.AsContentType("application/json; charset=utf-8"), 4038 autorest.AsPost(), 4039 autorest.WithBaseURL(client.BaseURI), 4040 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/locations/{location}/previewStaticSiteWorkflowFile", pathParameters), 4041 autorest.WithJSON(staticSitesWorkflowPreviewRequest), 4042 autorest.WithQueryParameters(queryParameters)) 4043 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 4044} 4045 4046// PreviewWorkflowSender sends the PreviewWorkflow request. The method will close the 4047// http.Response Body if it receives an error. 4048func (client StaticSitesClient) PreviewWorkflowSender(req *http.Request) (*http.Response, error) { 4049 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 4050} 4051 4052// PreviewWorkflowResponder handles the response to the PreviewWorkflow request. The method always 4053// closes the http.Response Body. 4054func (client StaticSitesClient) PreviewWorkflowResponder(resp *http.Response) (result StaticSitesWorkflowPreview, err error) { 4055 err = autorest.Respond( 4056 resp, 4057 azure.WithErrorUnlessStatusCode(http.StatusOK), 4058 autorest.ByUnmarshallingJSON(&result), 4059 autorest.ByClosing()) 4060 result.Response = autorest.Response{Response: resp} 4061 return 4062} 4063 4064// RegisterUserProvidedFunctionAppWithStaticSite description for Register a user provided function app with a static 4065// site 4066// Parameters: 4067// resourceGroupName - name of the resource group to which the resource belongs. 4068// name - name of the static site. 4069// functionAppName - name of the function app to register with the static site. 4070// staticSiteUserProvidedFunctionEnvelope - a JSON representation of the user provided function app properties. 4071// See example. 4072// isForced - specify <code>true</code> to force the update of the auth configuration on the function app even 4073// if an AzureStaticWebApps provider is already configured on the function app. The default is 4074// <code>false</code>. 4075func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSite(ctx context.Context, resourceGroupName string, name string, functionAppName string, staticSiteUserProvidedFunctionEnvelope StaticSiteUserProvidedFunctionAppARMResource, isForced *bool) (result StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteFuture, err error) { 4076 if tracing.IsEnabled() { 4077 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.RegisterUserProvidedFunctionAppWithStaticSite") 4078 defer func() { 4079 sc := -1 4080 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 4081 sc = result.FutureAPI.Response().StatusCode 4082 } 4083 tracing.EndSpan(ctx, sc, err) 4084 }() 4085 } 4086 if err := validation.Validate([]validation.Validation{ 4087 {TargetValue: resourceGroupName, 4088 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 4089 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 4090 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 4091 return result, validation.NewError("web.StaticSitesClient", "RegisterUserProvidedFunctionAppWithStaticSite", err.Error()) 4092 } 4093 4094 req, err := client.RegisterUserProvidedFunctionAppWithStaticSitePreparer(ctx, resourceGroupName, name, functionAppName, staticSiteUserProvidedFunctionEnvelope, isForced) 4095 if err != nil { 4096 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "RegisterUserProvidedFunctionAppWithStaticSite", nil, "Failure preparing request") 4097 return 4098 } 4099 4100 result, err = client.RegisterUserProvidedFunctionAppWithStaticSiteSender(req) 4101 if err != nil { 4102 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "RegisterUserProvidedFunctionAppWithStaticSite", nil, "Failure sending request") 4103 return 4104 } 4105 4106 return 4107} 4108 4109// RegisterUserProvidedFunctionAppWithStaticSitePreparer prepares the RegisterUserProvidedFunctionAppWithStaticSite request. 4110func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSitePreparer(ctx context.Context, resourceGroupName string, name string, functionAppName string, staticSiteUserProvidedFunctionEnvelope StaticSiteUserProvidedFunctionAppARMResource, isForced *bool) (*http.Request, error) { 4111 pathParameters := map[string]interface{}{ 4112 "functionAppName": autorest.Encode("path", functionAppName), 4113 "name": autorest.Encode("path", name), 4114 "resourceGroupName": autorest.Encode("path", resourceGroupName), 4115 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 4116 } 4117 4118 const APIVersion = "2020-12-01" 4119 queryParameters := map[string]interface{}{ 4120 "api-version": APIVersion, 4121 } 4122 if isForced != nil { 4123 queryParameters["isForced"] = autorest.Encode("query", *isForced) 4124 } 4125 4126 preparer := autorest.CreatePreparer( 4127 autorest.AsContentType("application/json; charset=utf-8"), 4128 autorest.AsPut(), 4129 autorest.WithBaseURL(client.BaseURI), 4130 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/userProvidedFunctionApps/{functionAppName}", pathParameters), 4131 autorest.WithJSON(staticSiteUserProvidedFunctionEnvelope), 4132 autorest.WithQueryParameters(queryParameters)) 4133 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 4134} 4135 4136// RegisterUserProvidedFunctionAppWithStaticSiteSender sends the RegisterUserProvidedFunctionAppWithStaticSite request. The method will close the 4137// http.Response Body if it receives an error. 4138func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSiteSender(req *http.Request) (future StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteFuture, err error) { 4139 var resp *http.Response 4140 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 4141 if err != nil { 4142 return 4143 } 4144 var azf azure.Future 4145 azf, err = azure.NewFutureFromResponse(resp) 4146 future.FutureAPI = &azf 4147 future.Result = future.result 4148 return 4149} 4150 4151// RegisterUserProvidedFunctionAppWithStaticSiteResponder handles the response to the RegisterUserProvidedFunctionAppWithStaticSite request. The method always 4152// closes the http.Response Body. 4153func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSiteResponder(resp *http.Response) (result StaticSiteUserProvidedFunctionAppARMResource, err error) { 4154 err = autorest.Respond( 4155 resp, 4156 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 4157 autorest.ByUnmarshallingJSON(&result), 4158 autorest.ByClosing()) 4159 result.Response = autorest.Response{Response: resp} 4160 return 4161} 4162 4163// RegisterUserProvidedFunctionAppWithStaticSiteBuild description for Register a user provided function app with a 4164// static site build 4165// Parameters: 4166// resourceGroupName - name of the resource group to which the resource belongs. 4167// name - name of the static site. 4168// environmentName - the stage site identifier. 4169// functionAppName - name of the function app to register with the static site build. 4170// staticSiteUserProvidedFunctionEnvelope - a JSON representation of the user provided function app properties. 4171// See example. 4172// isForced - specify <code>true</code> to force the update of the auth configuration on the function app even 4173// if an AzureStaticWebApps provider is already configured on the function app. The default is 4174// <code>false</code>. 4175func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSiteBuild(ctx context.Context, resourceGroupName string, name string, environmentName string, functionAppName string, staticSiteUserProvidedFunctionEnvelope StaticSiteUserProvidedFunctionAppARMResource, isForced *bool) (result StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildFuture, err error) { 4176 if tracing.IsEnabled() { 4177 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.RegisterUserProvidedFunctionAppWithStaticSiteBuild") 4178 defer func() { 4179 sc := -1 4180 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 4181 sc = result.FutureAPI.Response().StatusCode 4182 } 4183 tracing.EndSpan(ctx, sc, err) 4184 }() 4185 } 4186 if err := validation.Validate([]validation.Validation{ 4187 {TargetValue: resourceGroupName, 4188 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 4189 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 4190 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 4191 return result, validation.NewError("web.StaticSitesClient", "RegisterUserProvidedFunctionAppWithStaticSiteBuild", err.Error()) 4192 } 4193 4194 req, err := client.RegisterUserProvidedFunctionAppWithStaticSiteBuildPreparer(ctx, resourceGroupName, name, environmentName, functionAppName, staticSiteUserProvidedFunctionEnvelope, isForced) 4195 if err != nil { 4196 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "RegisterUserProvidedFunctionAppWithStaticSiteBuild", nil, "Failure preparing request") 4197 return 4198 } 4199 4200 result, err = client.RegisterUserProvidedFunctionAppWithStaticSiteBuildSender(req) 4201 if err != nil { 4202 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "RegisterUserProvidedFunctionAppWithStaticSiteBuild", nil, "Failure sending request") 4203 return 4204 } 4205 4206 return 4207} 4208 4209// RegisterUserProvidedFunctionAppWithStaticSiteBuildPreparer prepares the RegisterUserProvidedFunctionAppWithStaticSiteBuild request. 4210func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSiteBuildPreparer(ctx context.Context, resourceGroupName string, name string, environmentName string, functionAppName string, staticSiteUserProvidedFunctionEnvelope StaticSiteUserProvidedFunctionAppARMResource, isForced *bool) (*http.Request, error) { 4211 pathParameters := map[string]interface{}{ 4212 "environmentName": autorest.Encode("path", environmentName), 4213 "functionAppName": autorest.Encode("path", functionAppName), 4214 "name": autorest.Encode("path", name), 4215 "resourceGroupName": autorest.Encode("path", resourceGroupName), 4216 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 4217 } 4218 4219 const APIVersion = "2020-12-01" 4220 queryParameters := map[string]interface{}{ 4221 "api-version": APIVersion, 4222 } 4223 if isForced != nil { 4224 queryParameters["isForced"] = autorest.Encode("query", *isForced) 4225 } 4226 4227 preparer := autorest.CreatePreparer( 4228 autorest.AsContentType("application/json; charset=utf-8"), 4229 autorest.AsPut(), 4230 autorest.WithBaseURL(client.BaseURI), 4231 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/builds/{environmentName}/userProvidedFunctionApps/{functionAppName}", pathParameters), 4232 autorest.WithJSON(staticSiteUserProvidedFunctionEnvelope), 4233 autorest.WithQueryParameters(queryParameters)) 4234 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 4235} 4236 4237// RegisterUserProvidedFunctionAppWithStaticSiteBuildSender sends the RegisterUserProvidedFunctionAppWithStaticSiteBuild request. The method will close the 4238// http.Response Body if it receives an error. 4239func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSiteBuildSender(req *http.Request) (future StaticSitesRegisterUserProvidedFunctionAppWithStaticSiteBuildFuture, err error) { 4240 var resp *http.Response 4241 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 4242 if err != nil { 4243 return 4244 } 4245 var azf azure.Future 4246 azf, err = azure.NewFutureFromResponse(resp) 4247 future.FutureAPI = &azf 4248 future.Result = future.result 4249 return 4250} 4251 4252// RegisterUserProvidedFunctionAppWithStaticSiteBuildResponder handles the response to the RegisterUserProvidedFunctionAppWithStaticSiteBuild request. The method always 4253// closes the http.Response Body. 4254func (client StaticSitesClient) RegisterUserProvidedFunctionAppWithStaticSiteBuildResponder(resp *http.Response) (result StaticSiteUserProvidedFunctionAppARMResource, err error) { 4255 err = autorest.Respond( 4256 resp, 4257 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 4258 autorest.ByUnmarshallingJSON(&result), 4259 autorest.ByClosing()) 4260 result.Response = autorest.Response{Response: resp} 4261 return 4262} 4263 4264// ResetStaticSiteAPIKey description for Resets the api key for an existing static site. 4265// Parameters: 4266// resourceGroupName - name of the resource group to which the resource belongs. 4267// name - name of the static site. 4268func (client StaticSitesClient) ResetStaticSiteAPIKey(ctx context.Context, resourceGroupName string, name string, resetPropertiesEnvelope StaticSiteResetPropertiesARMResource) (result autorest.Response, err error) { 4269 if tracing.IsEnabled() { 4270 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ResetStaticSiteAPIKey") 4271 defer func() { 4272 sc := -1 4273 if result.Response != nil { 4274 sc = result.Response.StatusCode 4275 } 4276 tracing.EndSpan(ctx, sc, err) 4277 }() 4278 } 4279 if err := validation.Validate([]validation.Validation{ 4280 {TargetValue: resourceGroupName, 4281 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 4282 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 4283 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 4284 return result, validation.NewError("web.StaticSitesClient", "ResetStaticSiteAPIKey", err.Error()) 4285 } 4286 4287 req, err := client.ResetStaticSiteAPIKeyPreparer(ctx, resourceGroupName, name, resetPropertiesEnvelope) 4288 if err != nil { 4289 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ResetStaticSiteAPIKey", nil, "Failure preparing request") 4290 return 4291 } 4292 4293 resp, err := client.ResetStaticSiteAPIKeySender(req) 4294 if err != nil { 4295 result.Response = resp 4296 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ResetStaticSiteAPIKey", resp, "Failure sending request") 4297 return 4298 } 4299 4300 result, err = client.ResetStaticSiteAPIKeyResponder(resp) 4301 if err != nil { 4302 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ResetStaticSiteAPIKey", resp, "Failure responding to request") 4303 return 4304 } 4305 4306 return 4307} 4308 4309// ResetStaticSiteAPIKeyPreparer prepares the ResetStaticSiteAPIKey request. 4310func (client StaticSitesClient) ResetStaticSiteAPIKeyPreparer(ctx context.Context, resourceGroupName string, name string, resetPropertiesEnvelope StaticSiteResetPropertiesARMResource) (*http.Request, error) { 4311 pathParameters := map[string]interface{}{ 4312 "name": autorest.Encode("path", name), 4313 "resourceGroupName": autorest.Encode("path", resourceGroupName), 4314 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 4315 } 4316 4317 const APIVersion = "2020-12-01" 4318 queryParameters := map[string]interface{}{ 4319 "api-version": APIVersion, 4320 } 4321 4322 preparer := autorest.CreatePreparer( 4323 autorest.AsContentType("application/json; charset=utf-8"), 4324 autorest.AsPost(), 4325 autorest.WithBaseURL(client.BaseURI), 4326 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/resetapikey", pathParameters), 4327 autorest.WithJSON(resetPropertiesEnvelope), 4328 autorest.WithQueryParameters(queryParameters)) 4329 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 4330} 4331 4332// ResetStaticSiteAPIKeySender sends the ResetStaticSiteAPIKey request. The method will close the 4333// http.Response Body if it receives an error. 4334func (client StaticSitesClient) ResetStaticSiteAPIKeySender(req *http.Request) (*http.Response, error) { 4335 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 4336} 4337 4338// ResetStaticSiteAPIKeyResponder handles the response to the ResetStaticSiteAPIKey request. The method always 4339// closes the http.Response Body. 4340func (client StaticSitesClient) ResetStaticSiteAPIKeyResponder(resp *http.Response) (result autorest.Response, err error) { 4341 err = autorest.Respond( 4342 resp, 4343 azure.WithErrorUnlessStatusCode(http.StatusOK), 4344 autorest.ByClosing()) 4345 result.Response = resp 4346 return 4347} 4348 4349// UpdateStaticSite description for Creates a new static site in an existing resource group, or updates an existing 4350// static site. 4351// Parameters: 4352// resourceGroupName - name of the resource group to which the resource belongs. 4353// name - name of the static site to create or update. 4354// staticSiteEnvelope - a JSON representation of the staticsite properties. See example. 4355func (client StaticSitesClient) UpdateStaticSite(ctx context.Context, resourceGroupName string, name string, staticSiteEnvelope StaticSitePatchResource) (result StaticSiteARMResource, err error) { 4356 if tracing.IsEnabled() { 4357 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.UpdateStaticSite") 4358 defer func() { 4359 sc := -1 4360 if result.Response.Response != nil { 4361 sc = result.Response.Response.StatusCode 4362 } 4363 tracing.EndSpan(ctx, sc, err) 4364 }() 4365 } 4366 if err := validation.Validate([]validation.Validation{ 4367 {TargetValue: resourceGroupName, 4368 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 4369 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 4370 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 4371 return result, validation.NewError("web.StaticSitesClient", "UpdateStaticSite", err.Error()) 4372 } 4373 4374 req, err := client.UpdateStaticSitePreparer(ctx, resourceGroupName, name, staticSiteEnvelope) 4375 if err != nil { 4376 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "UpdateStaticSite", nil, "Failure preparing request") 4377 return 4378 } 4379 4380 resp, err := client.UpdateStaticSiteSender(req) 4381 if err != nil { 4382 result.Response = autorest.Response{Response: resp} 4383 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "UpdateStaticSite", resp, "Failure sending request") 4384 return 4385 } 4386 4387 result, err = client.UpdateStaticSiteResponder(resp) 4388 if err != nil { 4389 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "UpdateStaticSite", resp, "Failure responding to request") 4390 return 4391 } 4392 4393 return 4394} 4395 4396// UpdateStaticSitePreparer prepares the UpdateStaticSite request. 4397func (client StaticSitesClient) UpdateStaticSitePreparer(ctx context.Context, resourceGroupName string, name string, staticSiteEnvelope StaticSitePatchResource) (*http.Request, error) { 4398 pathParameters := map[string]interface{}{ 4399 "name": autorest.Encode("path", name), 4400 "resourceGroupName": autorest.Encode("path", resourceGroupName), 4401 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 4402 } 4403 4404 const APIVersion = "2020-12-01" 4405 queryParameters := map[string]interface{}{ 4406 "api-version": APIVersion, 4407 } 4408 4409 preparer := autorest.CreatePreparer( 4410 autorest.AsContentType("application/json; charset=utf-8"), 4411 autorest.AsPatch(), 4412 autorest.WithBaseURL(client.BaseURI), 4413 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}", pathParameters), 4414 autorest.WithJSON(staticSiteEnvelope), 4415 autorest.WithQueryParameters(queryParameters)) 4416 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 4417} 4418 4419// UpdateStaticSiteSender sends the UpdateStaticSite request. The method will close the 4420// http.Response Body if it receives an error. 4421func (client StaticSitesClient) UpdateStaticSiteSender(req *http.Request) (*http.Response, error) { 4422 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 4423} 4424 4425// UpdateStaticSiteResponder handles the response to the UpdateStaticSite request. The method always 4426// closes the http.Response Body. 4427func (client StaticSitesClient) UpdateStaticSiteResponder(resp *http.Response) (result StaticSiteARMResource, err error) { 4428 err = autorest.Respond( 4429 resp, 4430 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 4431 autorest.ByUnmarshallingJSON(&result), 4432 autorest.ByClosing()) 4433 result.Response = autorest.Response{Response: resp} 4434 return 4435} 4436 4437// UpdateStaticSiteUser description for Updates a user entry with the listed roles 4438// Parameters: 4439// resourceGroupName - name of the resource group to which the resource belongs. 4440// name - name of the static site. 4441// authprovider - the auth provider for this user. 4442// userid - the user id of the user. 4443// staticSiteUserEnvelope - a JSON representation of the StaticSiteUser properties. See example. 4444func (client StaticSitesClient) UpdateStaticSiteUser(ctx context.Context, resourceGroupName string, name string, authprovider string, userid string, staticSiteUserEnvelope StaticSiteUserARMResource) (result StaticSiteUserARMResource, err error) { 4445 if tracing.IsEnabled() { 4446 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.UpdateStaticSiteUser") 4447 defer func() { 4448 sc := -1 4449 if result.Response.Response != nil { 4450 sc = result.Response.Response.StatusCode 4451 } 4452 tracing.EndSpan(ctx, sc, err) 4453 }() 4454 } 4455 if err := validation.Validate([]validation.Validation{ 4456 {TargetValue: resourceGroupName, 4457 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 4458 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 4459 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 4460 return result, validation.NewError("web.StaticSitesClient", "UpdateStaticSiteUser", err.Error()) 4461 } 4462 4463 req, err := client.UpdateStaticSiteUserPreparer(ctx, resourceGroupName, name, authprovider, userid, staticSiteUserEnvelope) 4464 if err != nil { 4465 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "UpdateStaticSiteUser", nil, "Failure preparing request") 4466 return 4467 } 4468 4469 resp, err := client.UpdateStaticSiteUserSender(req) 4470 if err != nil { 4471 result.Response = autorest.Response{Response: resp} 4472 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "UpdateStaticSiteUser", resp, "Failure sending request") 4473 return 4474 } 4475 4476 result, err = client.UpdateStaticSiteUserResponder(resp) 4477 if err != nil { 4478 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "UpdateStaticSiteUser", resp, "Failure responding to request") 4479 return 4480 } 4481 4482 return 4483} 4484 4485// UpdateStaticSiteUserPreparer prepares the UpdateStaticSiteUser request. 4486func (client StaticSitesClient) UpdateStaticSiteUserPreparer(ctx context.Context, resourceGroupName string, name string, authprovider string, userid string, staticSiteUserEnvelope StaticSiteUserARMResource) (*http.Request, error) { 4487 pathParameters := map[string]interface{}{ 4488 "authprovider": autorest.Encode("path", authprovider), 4489 "name": autorest.Encode("path", name), 4490 "resourceGroupName": autorest.Encode("path", resourceGroupName), 4491 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 4492 "userid": autorest.Encode("path", userid), 4493 } 4494 4495 const APIVersion = "2020-12-01" 4496 queryParameters := map[string]interface{}{ 4497 "api-version": APIVersion, 4498 } 4499 4500 preparer := autorest.CreatePreparer( 4501 autorest.AsContentType("application/json; charset=utf-8"), 4502 autorest.AsPatch(), 4503 autorest.WithBaseURL(client.BaseURI), 4504 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/authproviders/{authprovider}/users/{userid}", pathParameters), 4505 autorest.WithJSON(staticSiteUserEnvelope), 4506 autorest.WithQueryParameters(queryParameters)) 4507 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 4508} 4509 4510// UpdateStaticSiteUserSender sends the UpdateStaticSiteUser request. The method will close the 4511// http.Response Body if it receives an error. 4512func (client StaticSitesClient) UpdateStaticSiteUserSender(req *http.Request) (*http.Response, error) { 4513 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 4514} 4515 4516// UpdateStaticSiteUserResponder handles the response to the UpdateStaticSiteUser request. The method always 4517// closes the http.Response Body. 4518func (client StaticSitesClient) UpdateStaticSiteUserResponder(resp *http.Response) (result StaticSiteUserARMResource, err error) { 4519 err = autorest.Respond( 4520 resp, 4521 azure.WithErrorUnlessStatusCode(http.StatusOK), 4522 autorest.ByUnmarshallingJSON(&result), 4523 autorest.ByClosing()) 4524 result.Response = autorest.Response{Response: resp} 4525 return 4526} 4527 4528// ValidateCustomDomainCanBeAddedToStaticSite description for Validates a particular custom domain can be added to a 4529// static site. 4530// Parameters: 4531// resourceGroupName - name of the resource group to which the resource belongs. 4532// name - name of the static site. 4533// domainName - the custom domain to validate. 4534// staticSiteCustomDomainRequestPropertiesEnvelope - a JSON representation of the static site custom domain 4535// request properties. See example. 4536func (client StaticSitesClient) ValidateCustomDomainCanBeAddedToStaticSite(ctx context.Context, resourceGroupName string, name string, domainName string, staticSiteCustomDomainRequestPropertiesEnvelope StaticSiteCustomDomainRequestPropertiesARMResource) (result StaticSitesValidateCustomDomainCanBeAddedToStaticSiteFuture, err error) { 4537 if tracing.IsEnabled() { 4538 ctx = tracing.StartSpan(ctx, fqdn+"/StaticSitesClient.ValidateCustomDomainCanBeAddedToStaticSite") 4539 defer func() { 4540 sc := -1 4541 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 4542 sc = result.FutureAPI.Response().StatusCode 4543 } 4544 tracing.EndSpan(ctx, sc, err) 4545 }() 4546 } 4547 if err := validation.Validate([]validation.Validation{ 4548 {TargetValue: resourceGroupName, 4549 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 4550 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 4551 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil { 4552 return result, validation.NewError("web.StaticSitesClient", "ValidateCustomDomainCanBeAddedToStaticSite", err.Error()) 4553 } 4554 4555 req, err := client.ValidateCustomDomainCanBeAddedToStaticSitePreparer(ctx, resourceGroupName, name, domainName, staticSiteCustomDomainRequestPropertiesEnvelope) 4556 if err != nil { 4557 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ValidateCustomDomainCanBeAddedToStaticSite", nil, "Failure preparing request") 4558 return 4559 } 4560 4561 result, err = client.ValidateCustomDomainCanBeAddedToStaticSiteSender(req) 4562 if err != nil { 4563 err = autorest.NewErrorWithError(err, "web.StaticSitesClient", "ValidateCustomDomainCanBeAddedToStaticSite", nil, "Failure sending request") 4564 return 4565 } 4566 4567 return 4568} 4569 4570// ValidateCustomDomainCanBeAddedToStaticSitePreparer prepares the ValidateCustomDomainCanBeAddedToStaticSite request. 4571func (client StaticSitesClient) ValidateCustomDomainCanBeAddedToStaticSitePreparer(ctx context.Context, resourceGroupName string, name string, domainName string, staticSiteCustomDomainRequestPropertiesEnvelope StaticSiteCustomDomainRequestPropertiesARMResource) (*http.Request, error) { 4572 pathParameters := map[string]interface{}{ 4573 "domainName": autorest.Encode("path", domainName), 4574 "name": autorest.Encode("path", name), 4575 "resourceGroupName": autorest.Encode("path", resourceGroupName), 4576 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 4577 } 4578 4579 const APIVersion = "2020-12-01" 4580 queryParameters := map[string]interface{}{ 4581 "api-version": APIVersion, 4582 } 4583 4584 preparer := autorest.CreatePreparer( 4585 autorest.AsContentType("application/json; charset=utf-8"), 4586 autorest.AsPost(), 4587 autorest.WithBaseURL(client.BaseURI), 4588 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/staticSites/{name}/customDomains/{domainName}/validate", pathParameters), 4589 autorest.WithJSON(staticSiteCustomDomainRequestPropertiesEnvelope), 4590 autorest.WithQueryParameters(queryParameters)) 4591 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 4592} 4593 4594// ValidateCustomDomainCanBeAddedToStaticSiteSender sends the ValidateCustomDomainCanBeAddedToStaticSite request. The method will close the 4595// http.Response Body if it receives an error. 4596func (client StaticSitesClient) ValidateCustomDomainCanBeAddedToStaticSiteSender(req *http.Request) (future StaticSitesValidateCustomDomainCanBeAddedToStaticSiteFuture, err error) { 4597 var resp *http.Response 4598 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 4599 if err != nil { 4600 return 4601 } 4602 var azf azure.Future 4603 azf, err = azure.NewFutureFromResponse(resp) 4604 future.FutureAPI = &azf 4605 future.Result = future.result 4606 return 4607} 4608 4609// ValidateCustomDomainCanBeAddedToStaticSiteResponder handles the response to the ValidateCustomDomainCanBeAddedToStaticSite request. The method always 4610// closes the http.Response Body. 4611func (client StaticSitesClient) ValidateCustomDomainCanBeAddedToStaticSiteResponder(resp *http.Response) (result autorest.Response, err error) { 4612 err = autorest.Respond( 4613 resp, 4614 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 4615 autorest.ByClosing()) 4616 result.Response = resp 4617 return 4618} 4619