diff --git a/services/web/mgmt/2015-08-preview/web/certificates.go b/services/web/mgmt/2015-08-preview/web/certificatesgroup.go
similarity index 67%
rename from services/web/mgmt/2015-08-preview/web/certificates.go
rename to services/web/mgmt/2015-08-preview/web/certificatesgroup.go
index ae262a78683c..ae455408bbc3 100644
--- a/services/web/mgmt/2015-08-preview/web/certificates.go
+++ b/services/web/mgmt/2015-08-preview/web/certificatesgroup.go
@@ -24,49 +24,49 @@ import (
"net/http"
)
-// CertificatesClient is the webSite Management Client
-type CertificatesClient struct {
+// CertificatesGroupClient is the webSite Management Client
+type CertificatesGroupClient struct {
BaseClient
}
-// NewCertificatesClient creates an instance of the CertificatesClient client.
-func NewCertificatesClient(subscriptionID string) CertificatesClient {
- return NewCertificatesClientWithBaseURI(DefaultBaseURI, subscriptionID)
+// NewCertificatesGroupClient creates an instance of the CertificatesGroupClient client.
+func NewCertificatesGroupClient(subscriptionID string) CertificatesGroupClient {
+ return NewCertificatesGroupClientWithBaseURI(DefaultBaseURI, subscriptionID)
}
-// NewCertificatesClientWithBaseURI creates an instance of the CertificatesClient client.
-func NewCertificatesClientWithBaseURI(baseURI string, subscriptionID string) CertificatesClient {
- return CertificatesClient{NewWithBaseURI(baseURI, subscriptionID)}
+// NewCertificatesGroupClientWithBaseURI creates an instance of the CertificatesGroupClient client.
+func NewCertificatesGroupClientWithBaseURI(baseURI string, subscriptionID string) CertificatesGroupClient {
+ return CertificatesGroupClient{NewWithBaseURI(baseURI, subscriptionID)}
}
// CreateOrUpdateCertificate sends the create or update certificate request.
//
// resourceGroupName is name of the resource group name is name of the certificate. certificateEnvelope is details
// of certificate if it exists already.
-func (client CertificatesClient) CreateOrUpdateCertificate(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (result Certificate, err error) {
+func (client CertificatesGroupClient) CreateOrUpdateCertificate(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (result Certificate, err error) {
req, err := client.CreateOrUpdateCertificatePreparer(ctx, resourceGroupName, name, certificateEnvelope)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdateCertificate", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "CreateOrUpdateCertificate", nil, "Failure preparing request")
return
}
resp, err := client.CreateOrUpdateCertificateSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdateCertificate", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "CreateOrUpdateCertificate", resp, "Failure sending request")
return
}
result, err = client.CreateOrUpdateCertificateResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdateCertificate", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "CreateOrUpdateCertificate", resp, "Failure responding to request")
}
return
}
// CreateOrUpdateCertificatePreparer prepares the CreateOrUpdateCertificate request.
-func (client CertificatesClient) CreateOrUpdateCertificatePreparer(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (*http.Request, error) {
+func (client CertificatesGroupClient) CreateOrUpdateCertificatePreparer(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -90,14 +90,14 @@ func (client CertificatesClient) CreateOrUpdateCertificatePreparer(ctx context.C
// CreateOrUpdateCertificateSender sends the CreateOrUpdateCertificate request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) CreateOrUpdateCertificateSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) CreateOrUpdateCertificateSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// CreateOrUpdateCertificateResponder handles the response to the CreateOrUpdateCertificate request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) CreateOrUpdateCertificateResponder(resp *http.Response) (result Certificate, err error) {
+func (client CertificatesGroupClient) CreateOrUpdateCertificateResponder(resp *http.Response) (result Certificate, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -112,30 +112,30 @@ func (client CertificatesClient) CreateOrUpdateCertificateResponder(resp *http.R
//
// resourceGroupName is name of the resource group name is name of the certificate. csrEnvelope is details of
// certificate signing request if it exists already.
-func (client CertificatesClient) CreateOrUpdateCsr(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (result Csr, err error) {
+func (client CertificatesGroupClient) CreateOrUpdateCsr(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (result Csr, err error) {
req, err := client.CreateOrUpdateCsrPreparer(ctx, resourceGroupName, name, csrEnvelope)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdateCsr", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "CreateOrUpdateCsr", nil, "Failure preparing request")
return
}
resp, err := client.CreateOrUpdateCsrSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdateCsr", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "CreateOrUpdateCsr", resp, "Failure sending request")
return
}
result, err = client.CreateOrUpdateCsrResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "CreateOrUpdateCsr", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "CreateOrUpdateCsr", resp, "Failure responding to request")
}
return
}
// CreateOrUpdateCsrPreparer prepares the CreateOrUpdateCsr request.
-func (client CertificatesClient) CreateOrUpdateCsrPreparer(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (*http.Request, error) {
+func (client CertificatesGroupClient) CreateOrUpdateCsrPreparer(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -159,14 +159,14 @@ func (client CertificatesClient) CreateOrUpdateCsrPreparer(ctx context.Context,
// CreateOrUpdateCsrSender sends the CreateOrUpdateCsr request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) CreateOrUpdateCsrSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) CreateOrUpdateCsrSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// CreateOrUpdateCsrResponder handles the response to the CreateOrUpdateCsr request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) CreateOrUpdateCsrResponder(resp *http.Response) (result Csr, err error) {
+func (client CertificatesGroupClient) CreateOrUpdateCsrResponder(resp *http.Response) (result Csr, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -180,30 +180,30 @@ func (client CertificatesClient) CreateOrUpdateCsrResponder(resp *http.Response)
// DeleteCertificate sends the delete certificate request.
//
// resourceGroupName is name of the resource group name is name of the certificate to be deleted.
-func (client CertificatesClient) DeleteCertificate(ctx context.Context, resourceGroupName string, name string) (result SetObject, err error) {
+func (client CertificatesGroupClient) DeleteCertificate(ctx context.Context, resourceGroupName string, name string) (result SetObject, err error) {
req, err := client.DeleteCertificatePreparer(ctx, resourceGroupName, name)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "DeleteCertificate", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "DeleteCertificate", nil, "Failure preparing request")
return
}
resp, err := client.DeleteCertificateSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "DeleteCertificate", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "DeleteCertificate", resp, "Failure sending request")
return
}
result, err = client.DeleteCertificateResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "DeleteCertificate", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "DeleteCertificate", resp, "Failure responding to request")
}
return
}
// DeleteCertificatePreparer prepares the DeleteCertificate request.
-func (client CertificatesClient) DeleteCertificatePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
+func (client CertificatesGroupClient) DeleteCertificatePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -225,14 +225,14 @@ func (client CertificatesClient) DeleteCertificatePreparer(ctx context.Context,
// DeleteCertificateSender sends the DeleteCertificate request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) DeleteCertificateSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) DeleteCertificateSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// DeleteCertificateResponder handles the response to the DeleteCertificate request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) DeleteCertificateResponder(resp *http.Response) (result SetObject, err error) {
+func (client CertificatesGroupClient) DeleteCertificateResponder(resp *http.Response) (result SetObject, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -246,30 +246,30 @@ func (client CertificatesClient) DeleteCertificateResponder(resp *http.Response)
// DeleteCsr sends the delete csr request.
//
// resourceGroupName is name of the resource group name is name of the certificate signing request.
-func (client CertificatesClient) DeleteCsr(ctx context.Context, resourceGroupName string, name string) (result SetObject, err error) {
+func (client CertificatesGroupClient) DeleteCsr(ctx context.Context, resourceGroupName string, name string) (result SetObject, err error) {
req, err := client.DeleteCsrPreparer(ctx, resourceGroupName, name)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "DeleteCsr", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "DeleteCsr", nil, "Failure preparing request")
return
}
resp, err := client.DeleteCsrSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "DeleteCsr", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "DeleteCsr", resp, "Failure sending request")
return
}
result, err = client.DeleteCsrResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "DeleteCsr", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "DeleteCsr", resp, "Failure responding to request")
}
return
}
// DeleteCsrPreparer prepares the DeleteCsr request.
-func (client CertificatesClient) DeleteCsrPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
+func (client CertificatesGroupClient) DeleteCsrPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -291,14 +291,14 @@ func (client CertificatesClient) DeleteCsrPreparer(ctx context.Context, resource
// DeleteCsrSender sends the DeleteCsr request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) DeleteCsrSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) DeleteCsrSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// DeleteCsrResponder handles the response to the DeleteCsr request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) DeleteCsrResponder(resp *http.Response) (result SetObject, err error) {
+func (client CertificatesGroupClient) DeleteCsrResponder(resp *http.Response) (result SetObject, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -312,30 +312,30 @@ func (client CertificatesClient) DeleteCsrResponder(resp *http.Response) (result
// GetCertificate sends the get certificate request.
//
// resourceGroupName is name of the resource group name is name of the certificate.
-func (client CertificatesClient) GetCertificate(ctx context.Context, resourceGroupName string, name string) (result Certificate, err error) {
+func (client CertificatesGroupClient) GetCertificate(ctx context.Context, resourceGroupName string, name string) (result Certificate, err error) {
req, err := client.GetCertificatePreparer(ctx, resourceGroupName, name)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCertificate", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCertificate", nil, "Failure preparing request")
return
}
resp, err := client.GetCertificateSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCertificate", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCertificate", resp, "Failure sending request")
return
}
result, err = client.GetCertificateResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCertificate", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCertificate", resp, "Failure responding to request")
}
return
}
// GetCertificatePreparer prepares the GetCertificate request.
-func (client CertificatesClient) GetCertificatePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
+func (client CertificatesGroupClient) GetCertificatePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -357,14 +357,14 @@ func (client CertificatesClient) GetCertificatePreparer(ctx context.Context, res
// GetCertificateSender sends the GetCertificate request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) GetCertificateSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) GetCertificateSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetCertificateResponder handles the response to the GetCertificate request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) GetCertificateResponder(resp *http.Response) (result Certificate, err error) {
+func (client CertificatesGroupClient) GetCertificateResponder(resp *http.Response) (result Certificate, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -378,31 +378,31 @@ func (client CertificatesClient) GetCertificateResponder(resp *http.Response) (r
// GetCertificates sends the get certificates request.
//
// resourceGroupName is name of the resource group
-func (client CertificatesClient) GetCertificates(ctx context.Context, resourceGroupName string) (result CertificateCollectionPage, err error) {
+func (client CertificatesGroupClient) GetCertificates(ctx context.Context, resourceGroupName string) (result CertificateCollectionPage, err error) {
result.fn = client.getCertificatesNextResults
req, err := client.GetCertificatesPreparer(ctx, resourceGroupName)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCertificates", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCertificates", nil, "Failure preparing request")
return
}
resp, err := client.GetCertificatesSender(req)
if err != nil {
result.cc.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCertificates", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCertificates", resp, "Failure sending request")
return
}
result.cc, err = client.GetCertificatesResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCertificates", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCertificates", resp, "Failure responding to request")
}
return
}
// GetCertificatesPreparer prepares the GetCertificates request.
-func (client CertificatesClient) GetCertificatesPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+func (client CertificatesGroupClient) GetCertificatesPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"resourceGroupName": autorest.Encode("path", resourceGroupName),
"subscriptionId": autorest.Encode("path", client.SubscriptionID),
@@ -423,14 +423,14 @@ func (client CertificatesClient) GetCertificatesPreparer(ctx context.Context, re
// GetCertificatesSender sends the GetCertificates request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) GetCertificatesSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) GetCertificatesSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetCertificatesResponder handles the response to the GetCertificates request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) GetCertificatesResponder(resp *http.Response) (result CertificateCollection, err error) {
+func (client CertificatesGroupClient) GetCertificatesResponder(resp *http.Response) (result CertificateCollection, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -442,10 +442,10 @@ func (client CertificatesClient) GetCertificatesResponder(resp *http.Response) (
}
// getCertificatesNextResults retrieves the next set of results, if any.
-func (client CertificatesClient) getCertificatesNextResults(lastResults CertificateCollection) (result CertificateCollection, err error) {
+func (client CertificatesGroupClient) getCertificatesNextResults(lastResults CertificateCollection) (result CertificateCollection, err error) {
req, err := lastResults.certificateCollectionPreparer()
if err != nil {
- return result, autorest.NewErrorWithError(err, "web.CertificatesClient", "getCertificatesNextResults", nil, "Failure preparing next results request")
+ return result, autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "getCertificatesNextResults", nil, "Failure preparing next results request")
}
if req == nil {
return
@@ -453,17 +453,17 @@ func (client CertificatesClient) getCertificatesNextResults(lastResults Certific
resp, err := client.GetCertificatesSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.CertificatesClient", "getCertificatesNextResults", resp, "Failure sending next results request")
+ return result, autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "getCertificatesNextResults", resp, "Failure sending next results request")
}
result, err = client.GetCertificatesResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "getCertificatesNextResults", resp, "Failure responding to next results request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "getCertificatesNextResults", resp, "Failure responding to next results request")
}
return
}
// GetCertificatesComplete enumerates all values, automatically crossing page boundaries as required.
-func (client CertificatesClient) GetCertificatesComplete(ctx context.Context, resourceGroupName string) (result CertificateCollectionIterator, err error) {
+func (client CertificatesGroupClient) GetCertificatesComplete(ctx context.Context, resourceGroupName string) (result CertificateCollectionIterator, err error) {
result.page, err = client.GetCertificates(ctx, resourceGroupName)
return
}
@@ -471,30 +471,30 @@ func (client CertificatesClient) GetCertificatesComplete(ctx context.Context, re
// GetCsr sends the get csr request.
//
// resourceGroupName is name of the resource group name is name of the certificate.
-func (client CertificatesClient) GetCsr(ctx context.Context, resourceGroupName string, name string) (result Csr, err error) {
+func (client CertificatesGroupClient) GetCsr(ctx context.Context, resourceGroupName string, name string) (result Csr, err error) {
req, err := client.GetCsrPreparer(ctx, resourceGroupName, name)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCsr", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCsr", nil, "Failure preparing request")
return
}
resp, err := client.GetCsrSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCsr", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCsr", resp, "Failure sending request")
return
}
result, err = client.GetCsrResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCsr", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCsr", resp, "Failure responding to request")
}
return
}
// GetCsrPreparer prepares the GetCsr request.
-func (client CertificatesClient) GetCsrPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
+func (client CertificatesGroupClient) GetCsrPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -516,14 +516,14 @@ func (client CertificatesClient) GetCsrPreparer(ctx context.Context, resourceGro
// GetCsrSender sends the GetCsr request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) GetCsrSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) GetCsrSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetCsrResponder handles the response to the GetCsr request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) GetCsrResponder(resp *http.Response) (result Csr, err error) {
+func (client CertificatesGroupClient) GetCsrResponder(resp *http.Response) (result Csr, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -537,30 +537,30 @@ func (client CertificatesClient) GetCsrResponder(resp *http.Response) (result Cs
// GetCsrs sends the get csrs request.
//
// resourceGroupName is name of the resource group
-func (client CertificatesClient) GetCsrs(ctx context.Context, resourceGroupName string) (result ListCsr, err error) {
+func (client CertificatesGroupClient) GetCsrs(ctx context.Context, resourceGroupName string) (result ListCsr, err error) {
req, err := client.GetCsrsPreparer(ctx, resourceGroupName)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCsrs", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCsrs", nil, "Failure preparing request")
return
}
resp, err := client.GetCsrsSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCsrs", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCsrs", resp, "Failure sending request")
return
}
result, err = client.GetCsrsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "GetCsrs", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "GetCsrs", resp, "Failure responding to request")
}
return
}
// GetCsrsPreparer prepares the GetCsrs request.
-func (client CertificatesClient) GetCsrsPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+func (client CertificatesGroupClient) GetCsrsPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"resourceGroupName": autorest.Encode("path", resourceGroupName),
"subscriptionId": autorest.Encode("path", client.SubscriptionID),
@@ -581,14 +581,14 @@ func (client CertificatesClient) GetCsrsPreparer(ctx context.Context, resourceGr
// GetCsrsSender sends the GetCsrs request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) GetCsrsSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) GetCsrsSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetCsrsResponder handles the response to the GetCsrs request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) GetCsrsResponder(resp *http.Response) (result ListCsr, err error) {
+func (client CertificatesGroupClient) GetCsrsResponder(resp *http.Response) (result ListCsr, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -603,30 +603,30 @@ func (client CertificatesClient) GetCsrsResponder(resp *http.Response) (result L
//
// resourceGroupName is name of the resource group name is name of the certificate. certificateEnvelope is details
// of certificate if it exists already.
-func (client CertificatesClient) UpdateCertificate(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (result Certificate, err error) {
+func (client CertificatesGroupClient) UpdateCertificate(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (result Certificate, err error) {
req, err := client.UpdateCertificatePreparer(ctx, resourceGroupName, name, certificateEnvelope)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "UpdateCertificate", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "UpdateCertificate", nil, "Failure preparing request")
return
}
resp, err := client.UpdateCertificateSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "UpdateCertificate", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "UpdateCertificate", resp, "Failure sending request")
return
}
result, err = client.UpdateCertificateResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "UpdateCertificate", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "UpdateCertificate", resp, "Failure responding to request")
}
return
}
// UpdateCertificatePreparer prepares the UpdateCertificate request.
-func (client CertificatesClient) UpdateCertificatePreparer(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (*http.Request, error) {
+func (client CertificatesGroupClient) UpdateCertificatePreparer(ctx context.Context, resourceGroupName string, name string, certificateEnvelope Certificate) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -650,14 +650,14 @@ func (client CertificatesClient) UpdateCertificatePreparer(ctx context.Context,
// UpdateCertificateSender sends the UpdateCertificate request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) UpdateCertificateSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) UpdateCertificateSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// UpdateCertificateResponder handles the response to the UpdateCertificate request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) UpdateCertificateResponder(resp *http.Response) (result Certificate, err error) {
+func (client CertificatesGroupClient) UpdateCertificateResponder(resp *http.Response) (result Certificate, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -672,30 +672,30 @@ func (client CertificatesClient) UpdateCertificateResponder(resp *http.Response)
//
// resourceGroupName is name of the resource group name is name of the certificate. csrEnvelope is details of
// certificate signing request if it exists already.
-func (client CertificatesClient) UpdateCsr(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (result Csr, err error) {
+func (client CertificatesGroupClient) UpdateCsr(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (result Csr, err error) {
req, err := client.UpdateCsrPreparer(ctx, resourceGroupName, name, csrEnvelope)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "UpdateCsr", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "UpdateCsr", nil, "Failure preparing request")
return
}
resp, err := client.UpdateCsrSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "UpdateCsr", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "UpdateCsr", resp, "Failure sending request")
return
}
result, err = client.UpdateCsrResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.CertificatesClient", "UpdateCsr", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.CertificatesGroupClient", "UpdateCsr", resp, "Failure responding to request")
}
return
}
// UpdateCsrPreparer prepares the UpdateCsr request.
-func (client CertificatesClient) UpdateCsrPreparer(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (*http.Request, error) {
+func (client CertificatesGroupClient) UpdateCsrPreparer(ctx context.Context, resourceGroupName string, name string, csrEnvelope Csr) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -719,14 +719,14 @@ func (client CertificatesClient) UpdateCsrPreparer(ctx context.Context, resource
// UpdateCsrSender sends the UpdateCsr request. The method will close the
// http.Response Body if it receives an error.
-func (client CertificatesClient) UpdateCsrSender(req *http.Request) (*http.Response, error) {
+func (client CertificatesGroupClient) UpdateCsrSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// UpdateCsrResponder handles the response to the UpdateCsr request. The method always
// closes the http.Response Body.
-func (client CertificatesClient) UpdateCsrResponder(resp *http.Response) (result Csr, err error) {
+func (client CertificatesGroupClient) UpdateCsrResponder(resp *http.Response) (result Csr, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
diff --git a/services/web/mgmt/2015-08-preview/web/domains.go b/services/web/mgmt/2015-08-preview/web/domainsgroup.go
similarity index 67%
rename from services/web/mgmt/2015-08-preview/web/domains.go
rename to services/web/mgmt/2015-08-preview/web/domainsgroup.go
index b9bc99696810..e42c94af23c6 100644
--- a/services/web/mgmt/2015-08-preview/web/domains.go
+++ b/services/web/mgmt/2015-08-preview/web/domainsgroup.go
@@ -24,49 +24,49 @@ import (
"net/http"
)
-// DomainsClient is the webSite Management Client
-type DomainsClient struct {
+// DomainsGroupClient is the webSite Management Client
+type DomainsGroupClient struct {
BaseClient
}
-// NewDomainsClient creates an instance of the DomainsClient client.
-func NewDomainsClient(subscriptionID string) DomainsClient {
- return NewDomainsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+// NewDomainsGroupClient creates an instance of the DomainsGroupClient client.
+func NewDomainsGroupClient(subscriptionID string) DomainsGroupClient {
+ return NewDomainsGroupClientWithBaseURI(DefaultBaseURI, subscriptionID)
}
-// NewDomainsClientWithBaseURI creates an instance of the DomainsClient client.
-func NewDomainsClientWithBaseURI(baseURI string, subscriptionID string) DomainsClient {
- return DomainsClient{NewWithBaseURI(baseURI, subscriptionID)}
+// NewDomainsGroupClientWithBaseURI creates an instance of the DomainsGroupClient client.
+func NewDomainsGroupClientWithBaseURI(baseURI string, subscriptionID string) DomainsGroupClient {
+ return DomainsGroupClient{NewWithBaseURI(baseURI, subscriptionID)}
}
// CreateOrUpdateDomain sends the create or update domain request.
//
// resourceGroupName is >Name of the resource group domainName is name of the domain domain is domain
// registration information
-func (client DomainsClient) CreateOrUpdateDomain(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (result Domain, err error) {
+func (client DomainsGroupClient) CreateOrUpdateDomain(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (result Domain, err error) {
req, err := client.CreateOrUpdateDomainPreparer(ctx, resourceGroupName, domainName, domain)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdateDomain", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "CreateOrUpdateDomain", nil, "Failure preparing request")
return
}
resp, err := client.CreateOrUpdateDomainSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdateDomain", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "CreateOrUpdateDomain", resp, "Failure sending request")
return
}
result, err = client.CreateOrUpdateDomainResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "CreateOrUpdateDomain", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "CreateOrUpdateDomain", resp, "Failure responding to request")
}
return
}
// CreateOrUpdateDomainPreparer prepares the CreateOrUpdateDomain request.
-func (client DomainsClient) CreateOrUpdateDomainPreparer(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (*http.Request, error) {
+func (client DomainsGroupClient) CreateOrUpdateDomainPreparer(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (*http.Request, error) {
pathParameters := map[string]interface{}{
"domainName": autorest.Encode("path", domainName),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -90,14 +90,14 @@ func (client DomainsClient) CreateOrUpdateDomainPreparer(ctx context.Context, re
// CreateOrUpdateDomainSender sends the CreateOrUpdateDomain request. The method will close the
// http.Response Body if it receives an error.
-func (client DomainsClient) CreateOrUpdateDomainSender(req *http.Request) (*http.Response, error) {
+func (client DomainsGroupClient) CreateOrUpdateDomainSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// CreateOrUpdateDomainResponder handles the response to the CreateOrUpdateDomain request. The method always
// closes the http.Response Body.
-func (client DomainsClient) CreateOrUpdateDomainResponder(resp *http.Response) (result Domain, err error) {
+func (client DomainsGroupClient) CreateOrUpdateDomainResponder(resp *http.Response) (result Domain, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -112,30 +112,30 @@ func (client DomainsClient) CreateOrUpdateDomainResponder(resp *http.Response) (
//
// resourceGroupName is name of the resource group domainName is name of the domain forceHardDeleteDomain is if
// true then the domain will be deleted immediately instead of after 24 hours
-func (client DomainsClient) DeleteDomain(ctx context.Context, resourceGroupName string, domainName string, forceHardDeleteDomain *bool) (result SetObject, err error) {
+func (client DomainsGroupClient) DeleteDomain(ctx context.Context, resourceGroupName string, domainName string, forceHardDeleteDomain *bool) (result SetObject, err error) {
req, err := client.DeleteDomainPreparer(ctx, resourceGroupName, domainName, forceHardDeleteDomain)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "DeleteDomain", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "DeleteDomain", nil, "Failure preparing request")
return
}
resp, err := client.DeleteDomainSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "DeleteDomain", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "DeleteDomain", resp, "Failure sending request")
return
}
result, err = client.DeleteDomainResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "DeleteDomain", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "DeleteDomain", resp, "Failure responding to request")
}
return
}
// DeleteDomainPreparer prepares the DeleteDomain request.
-func (client DomainsClient) DeleteDomainPreparer(ctx context.Context, resourceGroupName string, domainName string, forceHardDeleteDomain *bool) (*http.Request, error) {
+func (client DomainsGroupClient) DeleteDomainPreparer(ctx context.Context, resourceGroupName string, domainName string, forceHardDeleteDomain *bool) (*http.Request, error) {
pathParameters := map[string]interface{}{
"domainName": autorest.Encode("path", domainName),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -160,14 +160,14 @@ func (client DomainsClient) DeleteDomainPreparer(ctx context.Context, resourceGr
// DeleteDomainSender sends the DeleteDomain request. The method will close the
// http.Response Body if it receives an error.
-func (client DomainsClient) DeleteDomainSender(req *http.Request) (*http.Response, error) {
+func (client DomainsGroupClient) DeleteDomainSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// DeleteDomainResponder handles the response to the DeleteDomain request. The method always
// closes the http.Response Body.
-func (client DomainsClient) DeleteDomainResponder(resp *http.Response) (result SetObject, err error) {
+func (client DomainsGroupClient) DeleteDomainResponder(resp *http.Response) (result SetObject, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -181,30 +181,30 @@ func (client DomainsClient) DeleteDomainResponder(resp *http.Response) (result S
// GetDomain sends the get domain request.
//
// resourceGroupName is name of the resource group domainName is name of the domain
-func (client DomainsClient) GetDomain(ctx context.Context, resourceGroupName string, domainName string) (result Domain, err error) {
+func (client DomainsGroupClient) GetDomain(ctx context.Context, resourceGroupName string, domainName string) (result Domain, err error) {
req, err := client.GetDomainPreparer(ctx, resourceGroupName, domainName)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomain", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomain", nil, "Failure preparing request")
return
}
resp, err := client.GetDomainSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomain", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomain", resp, "Failure sending request")
return
}
result, err = client.GetDomainResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomain", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomain", resp, "Failure responding to request")
}
return
}
// GetDomainPreparer prepares the GetDomain request.
-func (client DomainsClient) GetDomainPreparer(ctx context.Context, resourceGroupName string, domainName string) (*http.Request, error) {
+func (client DomainsGroupClient) GetDomainPreparer(ctx context.Context, resourceGroupName string, domainName string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"domainName": autorest.Encode("path", domainName),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -226,14 +226,14 @@ func (client DomainsClient) GetDomainPreparer(ctx context.Context, resourceGroup
// GetDomainSender sends the GetDomain request. The method will close the
// http.Response Body if it receives an error.
-func (client DomainsClient) GetDomainSender(req *http.Request) (*http.Response, error) {
+func (client DomainsGroupClient) GetDomainSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetDomainResponder handles the response to the GetDomain request. The method always
// closes the http.Response Body.
-func (client DomainsClient) GetDomainResponder(resp *http.Response) (result Domain, err error) {
+func (client DomainsGroupClient) GetDomainResponder(resp *http.Response) (result Domain, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -248,30 +248,30 @@ func (client DomainsClient) GetDomainResponder(resp *http.Response) (result Doma
//
// resourceGroupName is name of the resource group domainName is name of the domain operationID is domain purchase
// operation Id
-func (client DomainsClient) GetDomainOperation(ctx context.Context, resourceGroupName string, domainName string, operationID string) (result Domain, err error) {
+func (client DomainsGroupClient) GetDomainOperation(ctx context.Context, resourceGroupName string, domainName string, operationID string) (result Domain, err error) {
req, err := client.GetDomainOperationPreparer(ctx, resourceGroupName, domainName, operationID)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomainOperation", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomainOperation", nil, "Failure preparing request")
return
}
resp, err := client.GetDomainOperationSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomainOperation", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomainOperation", resp, "Failure sending request")
return
}
result, err = client.GetDomainOperationResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomainOperation", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomainOperation", resp, "Failure responding to request")
}
return
}
// GetDomainOperationPreparer prepares the GetDomainOperation request.
-func (client DomainsClient) GetDomainOperationPreparer(ctx context.Context, resourceGroupName string, domainName string, operationID string) (*http.Request, error) {
+func (client DomainsGroupClient) GetDomainOperationPreparer(ctx context.Context, resourceGroupName string, domainName string, operationID string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"domainName": autorest.Encode("path", domainName),
"operationId": autorest.Encode("path", operationID),
@@ -294,14 +294,14 @@ func (client DomainsClient) GetDomainOperationPreparer(ctx context.Context, reso
// GetDomainOperationSender sends the GetDomainOperation request. The method will close the
// http.Response Body if it receives an error.
-func (client DomainsClient) GetDomainOperationSender(req *http.Request) (*http.Response, error) {
+func (client DomainsGroupClient) GetDomainOperationSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetDomainOperationResponder handles the response to the GetDomainOperation request. The method always
// closes the http.Response Body.
-func (client DomainsClient) GetDomainOperationResponder(resp *http.Response) (result Domain, err error) {
+func (client DomainsGroupClient) GetDomainOperationResponder(resp *http.Response) (result Domain, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -315,31 +315,31 @@ func (client DomainsClient) GetDomainOperationResponder(resp *http.Response) (re
// GetDomains sends the get domains request.
//
// resourceGroupName is name of the resource group
-func (client DomainsClient) GetDomains(ctx context.Context, resourceGroupName string) (result DomainCollectionPage, err error) {
+func (client DomainsGroupClient) GetDomains(ctx context.Context, resourceGroupName string) (result DomainCollectionPage, err error) {
result.fn = client.getDomainsNextResults
req, err := client.GetDomainsPreparer(ctx, resourceGroupName)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomains", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomains", nil, "Failure preparing request")
return
}
resp, err := client.GetDomainsSender(req)
if err != nil {
result.dc.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomains", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomains", resp, "Failure sending request")
return
}
result.dc, err = client.GetDomainsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "GetDomains", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "GetDomains", resp, "Failure responding to request")
}
return
}
// GetDomainsPreparer prepares the GetDomains request.
-func (client DomainsClient) GetDomainsPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+func (client DomainsGroupClient) GetDomainsPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"resourceGroupName": autorest.Encode("path", resourceGroupName),
"subscriptionId": autorest.Encode("path", client.SubscriptionID),
@@ -360,14 +360,14 @@ func (client DomainsClient) GetDomainsPreparer(ctx context.Context, resourceGrou
// GetDomainsSender sends the GetDomains request. The method will close the
// http.Response Body if it receives an error.
-func (client DomainsClient) GetDomainsSender(req *http.Request) (*http.Response, error) {
+func (client DomainsGroupClient) GetDomainsSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetDomainsResponder handles the response to the GetDomains request. The method always
// closes the http.Response Body.
-func (client DomainsClient) GetDomainsResponder(resp *http.Response) (result DomainCollection, err error) {
+func (client DomainsGroupClient) GetDomainsResponder(resp *http.Response) (result DomainCollection, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -379,10 +379,10 @@ func (client DomainsClient) GetDomainsResponder(resp *http.Response) (result Dom
}
// getDomainsNextResults retrieves the next set of results, if any.
-func (client DomainsClient) getDomainsNextResults(lastResults DomainCollection) (result DomainCollection, err error) {
+func (client DomainsGroupClient) getDomainsNextResults(lastResults DomainCollection) (result DomainCollection, err error) {
req, err := lastResults.domainCollectionPreparer()
if err != nil {
- return result, autorest.NewErrorWithError(err, "web.DomainsClient", "getDomainsNextResults", nil, "Failure preparing next results request")
+ return result, autorest.NewErrorWithError(err, "web.DomainsGroupClient", "getDomainsNextResults", nil, "Failure preparing next results request")
}
if req == nil {
return
@@ -390,17 +390,17 @@ func (client DomainsClient) getDomainsNextResults(lastResults DomainCollection)
resp, err := client.GetDomainsSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.DomainsClient", "getDomainsNextResults", resp, "Failure sending next results request")
+ return result, autorest.NewErrorWithError(err, "web.DomainsGroupClient", "getDomainsNextResults", resp, "Failure sending next results request")
}
result, err = client.GetDomainsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "getDomainsNextResults", resp, "Failure responding to next results request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "getDomainsNextResults", resp, "Failure responding to next results request")
}
return
}
// GetDomainsComplete enumerates all values, automatically crossing page boundaries as required.
-func (client DomainsClient) GetDomainsComplete(ctx context.Context, resourceGroupName string) (result DomainCollectionIterator, err error) {
+func (client DomainsGroupClient) GetDomainsComplete(ctx context.Context, resourceGroupName string) (result DomainCollectionIterator, err error) {
result.page, err = client.GetDomains(ctx, resourceGroupName)
return
}
@@ -409,30 +409,30 @@ func (client DomainsClient) GetDomainsComplete(ctx context.Context, resourceGrou
//
// resourceGroupName is >Name of the resource group domainName is name of the domain domain is domain
// registration information
-func (client DomainsClient) UpdateDomain(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (result Domain, err error) {
+func (client DomainsGroupClient) UpdateDomain(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (result Domain, err error) {
req, err := client.UpdateDomainPreparer(ctx, resourceGroupName, domainName, domain)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "UpdateDomain", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "UpdateDomain", nil, "Failure preparing request")
return
}
resp, err := client.UpdateDomainSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "UpdateDomain", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "UpdateDomain", resp, "Failure sending request")
return
}
result, err = client.UpdateDomainResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.DomainsClient", "UpdateDomain", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.DomainsGroupClient", "UpdateDomain", resp, "Failure responding to request")
}
return
}
// UpdateDomainPreparer prepares the UpdateDomain request.
-func (client DomainsClient) UpdateDomainPreparer(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (*http.Request, error) {
+func (client DomainsGroupClient) UpdateDomainPreparer(ctx context.Context, resourceGroupName string, domainName string, domain Domain) (*http.Request, error) {
pathParameters := map[string]interface{}{
"domainName": autorest.Encode("path", domainName),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -456,14 +456,14 @@ func (client DomainsClient) UpdateDomainPreparer(ctx context.Context, resourceGr
// UpdateDomainSender sends the UpdateDomain request. The method will close the
// http.Response Body if it receives an error.
-func (client DomainsClient) UpdateDomainSender(req *http.Request) (*http.Response, error) {
+func (client DomainsGroupClient) UpdateDomainSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// UpdateDomainResponder handles the response to the UpdateDomain request. The method always
// closes the http.Response Body.
-func (client DomainsClient) UpdateDomainResponder(resp *http.Response) (result Domain, err error) {
+func (client DomainsGroupClient) UpdateDomainResponder(resp *http.Response) (result Domain, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
diff --git a/services/web/mgmt/2015-08-preview/web/provider.go b/services/web/mgmt/2015-08-preview/web/providergroup.go
similarity index 63%
rename from services/web/mgmt/2015-08-preview/web/provider.go
rename to services/web/mgmt/2015-08-preview/web/providergroup.go
index dfb5f5d2e6ba..a2b94bdeee38 100644
--- a/services/web/mgmt/2015-08-preview/web/provider.go
+++ b/services/web/mgmt/2015-08-preview/web/providergroup.go
@@ -24,46 +24,46 @@ import (
"net/http"
)
-// ProviderClient is the webSite Management Client
-type ProviderClient struct {
+// ProviderGroupClient is the webSite Management Client
+type ProviderGroupClient struct {
BaseClient
}
-// NewProviderClient creates an instance of the ProviderClient client.
-func NewProviderClient(subscriptionID string) ProviderClient {
- return NewProviderClientWithBaseURI(DefaultBaseURI, subscriptionID)
+// NewProviderGroupClient creates an instance of the ProviderGroupClient client.
+func NewProviderGroupClient(subscriptionID string) ProviderGroupClient {
+ return NewProviderGroupClientWithBaseURI(DefaultBaseURI, subscriptionID)
}
-// NewProviderClientWithBaseURI creates an instance of the ProviderClient client.
-func NewProviderClientWithBaseURI(baseURI string, subscriptionID string) ProviderClient {
- return ProviderClient{NewWithBaseURI(baseURI, subscriptionID)}
+// NewProviderGroupClientWithBaseURI creates an instance of the ProviderGroupClient client.
+func NewProviderGroupClientWithBaseURI(baseURI string, subscriptionID string) ProviderGroupClient {
+ return ProviderGroupClient{NewWithBaseURI(baseURI, subscriptionID)}
}
// GetPublishingUser sends the get publishing user request.
-func (client ProviderClient) GetPublishingUser(ctx context.Context) (result User, err error) {
+func (client ProviderGroupClient) GetPublishingUser(ctx context.Context) (result User, err error) {
req, err := client.GetPublishingUserPreparer(ctx)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetPublishingUser", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetPublishingUser", nil, "Failure preparing request")
return
}
resp, err := client.GetPublishingUserSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetPublishingUser", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetPublishingUser", resp, "Failure sending request")
return
}
result, err = client.GetPublishingUserResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetPublishingUser", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetPublishingUser", resp, "Failure responding to request")
}
return
}
// GetPublishingUserPreparer prepares the GetPublishingUser request.
-func (client ProviderClient) GetPublishingUserPreparer(ctx context.Context) (*http.Request, error) {
+func (client ProviderGroupClient) GetPublishingUserPreparer(ctx context.Context) (*http.Request, error) {
const APIVersion = "2015-08-01"
queryParameters := map[string]interface{}{
"api-version": APIVersion,
@@ -79,14 +79,14 @@ func (client ProviderClient) GetPublishingUserPreparer(ctx context.Context) (*ht
// GetPublishingUserSender sends the GetPublishingUser request. The method will close the
// http.Response Body if it receives an error.
-func (client ProviderClient) GetPublishingUserSender(req *http.Request) (*http.Response, error) {
+func (client ProviderGroupClient) GetPublishingUserSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}
// GetPublishingUserResponder handles the response to the GetPublishingUser request. The method always
// closes the http.Response Body.
-func (client ProviderClient) GetPublishingUserResponder(resp *http.Response) (result User, err error) {
+func (client ProviderGroupClient) GetPublishingUserResponder(resp *http.Response) (result User, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -100,30 +100,30 @@ func (client ProviderClient) GetPublishingUserResponder(resp *http.Response) (re
// GetSourceControl sends the get source control request.
//
// sourceControlType is type of source control
-func (client ProviderClient) GetSourceControl(ctx context.Context, sourceControlType string) (result SourceControl, err error) {
+func (client ProviderGroupClient) GetSourceControl(ctx context.Context, sourceControlType string) (result SourceControl, err error) {
req, err := client.GetSourceControlPreparer(ctx, sourceControlType)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetSourceControl", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetSourceControl", nil, "Failure preparing request")
return
}
resp, err := client.GetSourceControlSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetSourceControl", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetSourceControl", resp, "Failure sending request")
return
}
result, err = client.GetSourceControlResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetSourceControl", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetSourceControl", resp, "Failure responding to request")
}
return
}
// GetSourceControlPreparer prepares the GetSourceControl request.
-func (client ProviderClient) GetSourceControlPreparer(ctx context.Context, sourceControlType string) (*http.Request, error) {
+func (client ProviderGroupClient) GetSourceControlPreparer(ctx context.Context, sourceControlType string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"sourceControlType": autorest.Encode("path", sourceControlType),
}
@@ -143,14 +143,14 @@ func (client ProviderClient) GetSourceControlPreparer(ctx context.Context, sourc
// GetSourceControlSender sends the GetSourceControl request. The method will close the
// http.Response Body if it receives an error.
-func (client ProviderClient) GetSourceControlSender(req *http.Request) (*http.Response, error) {
+func (client ProviderGroupClient) GetSourceControlSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}
// GetSourceControlResponder handles the response to the GetSourceControl request. The method always
// closes the http.Response Body.
-func (client ProviderClient) GetSourceControlResponder(resp *http.Response) (result SourceControl, err error) {
+func (client ProviderGroupClient) GetSourceControlResponder(resp *http.Response) (result SourceControl, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -162,31 +162,31 @@ func (client ProviderClient) GetSourceControlResponder(resp *http.Response) (res
}
// GetSourceControls sends the get source controls request.
-func (client ProviderClient) GetSourceControls(ctx context.Context) (result SourceControlCollectionPage, err error) {
+func (client ProviderGroupClient) GetSourceControls(ctx context.Context) (result SourceControlCollectionPage, err error) {
result.fn = client.getSourceControlsNextResults
req, err := client.GetSourceControlsPreparer(ctx)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetSourceControls", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetSourceControls", nil, "Failure preparing request")
return
}
resp, err := client.GetSourceControlsSender(req)
if err != nil {
result.scc.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetSourceControls", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetSourceControls", resp, "Failure sending request")
return
}
result.scc, err = client.GetSourceControlsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "GetSourceControls", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "GetSourceControls", resp, "Failure responding to request")
}
return
}
// GetSourceControlsPreparer prepares the GetSourceControls request.
-func (client ProviderClient) GetSourceControlsPreparer(ctx context.Context) (*http.Request, error) {
+func (client ProviderGroupClient) GetSourceControlsPreparer(ctx context.Context) (*http.Request, error) {
const APIVersion = "2015-08-01"
queryParameters := map[string]interface{}{
"api-version": APIVersion,
@@ -202,14 +202,14 @@ func (client ProviderClient) GetSourceControlsPreparer(ctx context.Context) (*ht
// GetSourceControlsSender sends the GetSourceControls request. The method will close the
// http.Response Body if it receives an error.
-func (client ProviderClient) GetSourceControlsSender(req *http.Request) (*http.Response, error) {
+func (client ProviderGroupClient) GetSourceControlsSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}
// GetSourceControlsResponder handles the response to the GetSourceControls request. The method always
// closes the http.Response Body.
-func (client ProviderClient) GetSourceControlsResponder(resp *http.Response) (result SourceControlCollection, err error) {
+func (client ProviderGroupClient) GetSourceControlsResponder(resp *http.Response) (result SourceControlCollection, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -221,10 +221,10 @@ func (client ProviderClient) GetSourceControlsResponder(resp *http.Response) (re
}
// getSourceControlsNextResults retrieves the next set of results, if any.
-func (client ProviderClient) getSourceControlsNextResults(lastResults SourceControlCollection) (result SourceControlCollection, err error) {
+func (client ProviderGroupClient) getSourceControlsNextResults(lastResults SourceControlCollection) (result SourceControlCollection, err error) {
req, err := lastResults.sourceControlCollectionPreparer()
if err != nil {
- return result, autorest.NewErrorWithError(err, "web.ProviderClient", "getSourceControlsNextResults", nil, "Failure preparing next results request")
+ return result, autorest.NewErrorWithError(err, "web.ProviderGroupClient", "getSourceControlsNextResults", nil, "Failure preparing next results request")
}
if req == nil {
return
@@ -232,17 +232,17 @@ func (client ProviderClient) getSourceControlsNextResults(lastResults SourceCont
resp, err := client.GetSourceControlsSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.ProviderClient", "getSourceControlsNextResults", resp, "Failure sending next results request")
+ return result, autorest.NewErrorWithError(err, "web.ProviderGroupClient", "getSourceControlsNextResults", resp, "Failure sending next results request")
}
result, err = client.GetSourceControlsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "getSourceControlsNextResults", resp, "Failure responding to next results request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "getSourceControlsNextResults", resp, "Failure responding to next results request")
}
return
}
// GetSourceControlsComplete enumerates all values, automatically crossing page boundaries as required.
-func (client ProviderClient) GetSourceControlsComplete(ctx context.Context) (result SourceControlCollectionIterator, err error) {
+func (client ProviderGroupClient) GetSourceControlsComplete(ctx context.Context) (result SourceControlCollectionIterator, err error) {
result.page, err = client.GetSourceControls(ctx)
return
}
@@ -250,30 +250,30 @@ func (client ProviderClient) GetSourceControlsComplete(ctx context.Context) (res
// UpdatePublishingUser sends the update publishing user request.
//
// requestMessage is details of publishing user
-func (client ProviderClient) UpdatePublishingUser(ctx context.Context, requestMessage User) (result User, err error) {
+func (client ProviderGroupClient) UpdatePublishingUser(ctx context.Context, requestMessage User) (result User, err error) {
req, err := client.UpdatePublishingUserPreparer(ctx, requestMessage)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "UpdatePublishingUser", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "UpdatePublishingUser", nil, "Failure preparing request")
return
}
resp, err := client.UpdatePublishingUserSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "UpdatePublishingUser", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "UpdatePublishingUser", resp, "Failure sending request")
return
}
result, err = client.UpdatePublishingUserResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "UpdatePublishingUser", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "UpdatePublishingUser", resp, "Failure responding to request")
}
return
}
// UpdatePublishingUserPreparer prepares the UpdatePublishingUser request.
-func (client ProviderClient) UpdatePublishingUserPreparer(ctx context.Context, requestMessage User) (*http.Request, error) {
+func (client ProviderGroupClient) UpdatePublishingUserPreparer(ctx context.Context, requestMessage User) (*http.Request, error) {
const APIVersion = "2015-08-01"
queryParameters := map[string]interface{}{
"api-version": APIVersion,
@@ -291,14 +291,14 @@ func (client ProviderClient) UpdatePublishingUserPreparer(ctx context.Context, r
// UpdatePublishingUserSender sends the UpdatePublishingUser request. The method will close the
// http.Response Body if it receives an error.
-func (client ProviderClient) UpdatePublishingUserSender(req *http.Request) (*http.Response, error) {
+func (client ProviderGroupClient) UpdatePublishingUserSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}
// UpdatePublishingUserResponder handles the response to the UpdatePublishingUser request. The method always
// closes the http.Response Body.
-func (client ProviderClient) UpdatePublishingUserResponder(resp *http.Response) (result User, err error) {
+func (client ProviderGroupClient) UpdatePublishingUserResponder(resp *http.Response) (result User, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -312,30 +312,30 @@ func (client ProviderClient) UpdatePublishingUserResponder(resp *http.Response)
// UpdateSourceControl sends the update source control request.
//
// sourceControlType is type of source control requestMessage is source control token information
-func (client ProviderClient) UpdateSourceControl(ctx context.Context, sourceControlType string, requestMessage SourceControl) (result SourceControl, err error) {
+func (client ProviderGroupClient) UpdateSourceControl(ctx context.Context, sourceControlType string, requestMessage SourceControl) (result SourceControl, err error) {
req, err := client.UpdateSourceControlPreparer(ctx, sourceControlType, requestMessage)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "UpdateSourceControl", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "UpdateSourceControl", nil, "Failure preparing request")
return
}
resp, err := client.UpdateSourceControlSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "UpdateSourceControl", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "UpdateSourceControl", resp, "Failure sending request")
return
}
result, err = client.UpdateSourceControlResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.ProviderClient", "UpdateSourceControl", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.ProviderGroupClient", "UpdateSourceControl", resp, "Failure responding to request")
}
return
}
// UpdateSourceControlPreparer prepares the UpdateSourceControl request.
-func (client ProviderClient) UpdateSourceControlPreparer(ctx context.Context, sourceControlType string, requestMessage SourceControl) (*http.Request, error) {
+func (client ProviderGroupClient) UpdateSourceControlPreparer(ctx context.Context, sourceControlType string, requestMessage SourceControl) (*http.Request, error) {
pathParameters := map[string]interface{}{
"sourceControlType": autorest.Encode("path", sourceControlType),
}
@@ -357,14 +357,14 @@ func (client ProviderClient) UpdateSourceControlPreparer(ctx context.Context, so
// UpdateSourceControlSender sends the UpdateSourceControl request. The method will close the
// http.Response Body if it receives an error.
-func (client ProviderClient) UpdateSourceControlSender(req *http.Request) (*http.Response, error) {
+func (client ProviderGroupClient) UpdateSourceControlSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}
// UpdateSourceControlResponder handles the response to the UpdateSourceControl request. The method always
// closes the http.Response Body.
-func (client ProviderClient) UpdateSourceControlResponder(resp *http.Response) (result SourceControl, err error) {
+func (client ProviderGroupClient) UpdateSourceControlResponder(resp *http.Response) (result SourceControl, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
diff --git a/services/web/mgmt/2015-08-preview/web/recommendations.go b/services/web/mgmt/2015-08-preview/web/recommendationsgroup.go
similarity index 69%
rename from services/web/mgmt/2015-08-preview/web/recommendations.go
rename to services/web/mgmt/2015-08-preview/web/recommendationsgroup.go
index b57b1904e93c..cb3972824074 100644
--- a/services/web/mgmt/2015-08-preview/web/recommendations.go
+++ b/services/web/mgmt/2015-08-preview/web/recommendationsgroup.go
@@ -24,19 +24,19 @@ import (
"net/http"
)
-// RecommendationsClient is the webSite Management Client
-type RecommendationsClient struct {
+// RecommendationsGroupClient is the webSite Management Client
+type RecommendationsGroupClient struct {
BaseClient
}
-// NewRecommendationsClient creates an instance of the RecommendationsClient client.
-func NewRecommendationsClient(subscriptionID string) RecommendationsClient {
- return NewRecommendationsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+// NewRecommendationsGroupClient creates an instance of the RecommendationsGroupClient client.
+func NewRecommendationsGroupClient(subscriptionID string) RecommendationsGroupClient {
+ return NewRecommendationsGroupClientWithBaseURI(DefaultBaseURI, subscriptionID)
}
-// NewRecommendationsClientWithBaseURI creates an instance of the RecommendationsClient client.
-func NewRecommendationsClientWithBaseURI(baseURI string, subscriptionID string) RecommendationsClient {
- return RecommendationsClient{NewWithBaseURI(baseURI, subscriptionID)}
+// NewRecommendationsGroupClientWithBaseURI creates an instance of the RecommendationsGroupClient client.
+func NewRecommendationsGroupClientWithBaseURI(baseURI string, subscriptionID string) RecommendationsGroupClient {
+ return RecommendationsGroupClient{NewWithBaseURI(baseURI, subscriptionID)}
}
// GetRecommendationBySubscription sends the get recommendation by subscription request.
@@ -44,30 +44,30 @@ func NewRecommendationsClientWithBaseURI(baseURI string, subscriptionID string)
// featured is if set, this API returns only the most critical recommendation among the others. Otherwise this API
// returns all recommendations available filter is return only channels specified in the filter. Filter is
// specified by using OData syntax. Example: $filter=channels eq 'Api' or channel eq 'Notification'
-func (client RecommendationsClient) GetRecommendationBySubscription(ctx context.Context, featured *bool, filter string) (result ListRecommendation, err error) {
+func (client RecommendationsGroupClient) GetRecommendationBySubscription(ctx context.Context, featured *bool, filter string) (result ListRecommendation, err error) {
req, err := client.GetRecommendationBySubscriptionPreparer(ctx, featured, filter)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendationBySubscription", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendationBySubscription", nil, "Failure preparing request")
return
}
resp, err := client.GetRecommendationBySubscriptionSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendationBySubscription", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendationBySubscription", resp, "Failure sending request")
return
}
result, err = client.GetRecommendationBySubscriptionResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendationBySubscription", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendationBySubscription", resp, "Failure responding to request")
}
return
}
// GetRecommendationBySubscriptionPreparer prepares the GetRecommendationBySubscription request.
-func (client RecommendationsClient) GetRecommendationBySubscriptionPreparer(ctx context.Context, featured *bool, filter string) (*http.Request, error) {
+func (client RecommendationsGroupClient) GetRecommendationBySubscriptionPreparer(ctx context.Context, featured *bool, filter string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"subscriptionId": autorest.Encode("path", client.SubscriptionID),
}
@@ -93,14 +93,14 @@ func (client RecommendationsClient) GetRecommendationBySubscriptionPreparer(ctx
// GetRecommendationBySubscriptionSender sends the GetRecommendationBySubscription request. The method will close the
// http.Response Body if it receives an error.
-func (client RecommendationsClient) GetRecommendationBySubscriptionSender(req *http.Request) (*http.Response, error) {
+func (client RecommendationsGroupClient) GetRecommendationBySubscriptionSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetRecommendationBySubscriptionResponder handles the response to the GetRecommendationBySubscription request. The method always
// closes the http.Response Body.
-func (client RecommendationsClient) GetRecommendationBySubscriptionResponder(resp *http.Response) (result ListRecommendation, err error) {
+func (client RecommendationsGroupClient) GetRecommendationBySubscriptionResponder(resp *http.Response) (result ListRecommendation, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -117,30 +117,30 @@ func (client RecommendationsClient) GetRecommendationBySubscriptionResponder(res
// query, e.g. $filter=startTime eq '2015-01-01T00:00:00Z' and endTime eq '2015-01-02T00:00:00Z' endTime is the end
// time of a time range to query, e.g. $filter=startTime eq '2015-01-01T00:00:00Z' and endTime eq
// '2015-01-02T00:00:00Z'
-func (client RecommendationsClient) GetRecommendationHistoryForSite(ctx context.Context, resourceGroupName string, siteName string, startTime string, endTime string) (result ListRecommendation, err error) {
+func (client RecommendationsGroupClient) GetRecommendationHistoryForSite(ctx context.Context, resourceGroupName string, siteName string, startTime string, endTime string) (result ListRecommendation, err error) {
req, err := client.GetRecommendationHistoryForSitePreparer(ctx, resourceGroupName, siteName, startTime, endTime)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendationHistoryForSite", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendationHistoryForSite", nil, "Failure preparing request")
return
}
resp, err := client.GetRecommendationHistoryForSiteSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendationHistoryForSite", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendationHistoryForSite", resp, "Failure sending request")
return
}
result, err = client.GetRecommendationHistoryForSiteResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendationHistoryForSite", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendationHistoryForSite", resp, "Failure responding to request")
}
return
}
// GetRecommendationHistoryForSitePreparer prepares the GetRecommendationHistoryForSite request.
-func (client RecommendationsClient) GetRecommendationHistoryForSitePreparer(ctx context.Context, resourceGroupName string, siteName string, startTime string, endTime string) (*http.Request, error) {
+func (client RecommendationsGroupClient) GetRecommendationHistoryForSitePreparer(ctx context.Context, resourceGroupName string, siteName string, startTime string, endTime string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"resourceGroupName": autorest.Encode("path", resourceGroupName),
"siteName": autorest.Encode("path", siteName),
@@ -168,14 +168,14 @@ func (client RecommendationsClient) GetRecommendationHistoryForSitePreparer(ctx
// GetRecommendationHistoryForSiteSender sends the GetRecommendationHistoryForSite request. The method will close the
// http.Response Body if it receives an error.
-func (client RecommendationsClient) GetRecommendationHistoryForSiteSender(req *http.Request) (*http.Response, error) {
+func (client RecommendationsGroupClient) GetRecommendationHistoryForSiteSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetRecommendationHistoryForSiteResponder handles the response to the GetRecommendationHistoryForSite request. The method always
// closes the http.Response Body.
-func (client RecommendationsClient) GetRecommendationHistoryForSiteResponder(resp *http.Response) (result ListRecommendation, err error) {
+func (client RecommendationsGroupClient) GetRecommendationHistoryForSiteResponder(resp *http.Response) (result ListRecommendation, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -191,30 +191,30 @@ func (client RecommendationsClient) GetRecommendationHistoryForSiteResponder(res
// resourceGroupName is resource group name siteName is site name featured is if set, this API returns only the
// most critical recommendation among the others. Otherwise this API returns all recommendations available siteSku
// is the name of site SKU. numSlots is the number of site slots associated to the site
-func (client RecommendationsClient) GetRecommendedRulesForSite(ctx context.Context, resourceGroupName string, siteName string, featured *bool, siteSku string, numSlots *int32) (result ListRecommendation, err error) {
+func (client RecommendationsGroupClient) GetRecommendedRulesForSite(ctx context.Context, resourceGroupName string, siteName string, featured *bool, siteSku string, numSlots *int32) (result ListRecommendation, err error) {
req, err := client.GetRecommendedRulesForSitePreparer(ctx, resourceGroupName, siteName, featured, siteSku, numSlots)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendedRulesForSite", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendedRulesForSite", nil, "Failure preparing request")
return
}
resp, err := client.GetRecommendedRulesForSiteSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendedRulesForSite", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendedRulesForSite", resp, "Failure sending request")
return
}
result, err = client.GetRecommendedRulesForSiteResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRecommendedRulesForSite", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRecommendedRulesForSite", resp, "Failure responding to request")
}
return
}
// GetRecommendedRulesForSitePreparer prepares the GetRecommendedRulesForSite request.
-func (client RecommendationsClient) GetRecommendedRulesForSitePreparer(ctx context.Context, resourceGroupName string, siteName string, featured *bool, siteSku string, numSlots *int32) (*http.Request, error) {
+func (client RecommendationsGroupClient) GetRecommendedRulesForSitePreparer(ctx context.Context, resourceGroupName string, siteName string, featured *bool, siteSku string, numSlots *int32) (*http.Request, error) {
pathParameters := map[string]interface{}{
"resourceGroupName": autorest.Encode("path", resourceGroupName),
"siteName": autorest.Encode("path", siteName),
@@ -245,14 +245,14 @@ func (client RecommendationsClient) GetRecommendedRulesForSitePreparer(ctx conte
// GetRecommendedRulesForSiteSender sends the GetRecommendedRulesForSite request. The method will close the
// http.Response Body if it receives an error.
-func (client RecommendationsClient) GetRecommendedRulesForSiteSender(req *http.Request) (*http.Response, error) {
+func (client RecommendationsGroupClient) GetRecommendedRulesForSiteSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetRecommendedRulesForSiteResponder handles the response to the GetRecommendedRulesForSite request. The method always
// closes the http.Response Body.
-func (client RecommendationsClient) GetRecommendedRulesForSiteResponder(resp *http.Response) (result ListRecommendation, err error) {
+func (client RecommendationsGroupClient) GetRecommendedRulesForSiteResponder(resp *http.Response) (result ListRecommendation, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -266,30 +266,30 @@ func (client RecommendationsClient) GetRecommendedRulesForSiteResponder(resp *ht
// GetRuleDetailsBySiteName sends the get rule details by site name request.
//
// resourceGroupName is resource group name siteName is site name name is recommendation rule name
-func (client RecommendationsClient) GetRuleDetailsBySiteName(ctx context.Context, resourceGroupName string, siteName string, name string) (result RecommendationRule, err error) {
+func (client RecommendationsGroupClient) GetRuleDetailsBySiteName(ctx context.Context, resourceGroupName string, siteName string, name string) (result RecommendationRule, err error) {
req, err := client.GetRuleDetailsBySiteNamePreparer(ctx, resourceGroupName, siteName, name)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRuleDetailsBySiteName", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRuleDetailsBySiteName", nil, "Failure preparing request")
return
}
resp, err := client.GetRuleDetailsBySiteNameSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRuleDetailsBySiteName", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRuleDetailsBySiteName", resp, "Failure sending request")
return
}
result, err = client.GetRuleDetailsBySiteNameResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRuleDetailsBySiteName", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.RecommendationsGroupClient", "GetRuleDetailsBySiteName", resp, "Failure responding to request")
}
return
}
// GetRuleDetailsBySiteNamePreparer prepares the GetRuleDetailsBySiteName request.
-func (client RecommendationsClient) GetRuleDetailsBySiteNamePreparer(ctx context.Context, resourceGroupName string, siteName string, name string) (*http.Request, error) {
+func (client RecommendationsGroupClient) GetRuleDetailsBySiteNamePreparer(ctx context.Context, resourceGroupName string, siteName string, name string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -312,14 +312,14 @@ func (client RecommendationsClient) GetRuleDetailsBySiteNamePreparer(ctx context
// GetRuleDetailsBySiteNameSender sends the GetRuleDetailsBySiteName request. The method will close the
// http.Response Body if it receives an error.
-func (client RecommendationsClient) GetRuleDetailsBySiteNameSender(req *http.Request) (*http.Response, error) {
+func (client RecommendationsGroupClient) GetRuleDetailsBySiteNameSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetRuleDetailsBySiteNameResponder handles the response to the GetRuleDetailsBySiteName request. The method always
// closes the http.Response Body.
-func (client RecommendationsClient) GetRuleDetailsBySiteNameResponder(resp *http.Response) (result RecommendationRule, err error) {
+func (client RecommendationsGroupClient) GetRuleDetailsBySiteNameResponder(resp *http.Response) (result RecommendationRule, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
diff --git a/services/web/mgmt/2015-08-preview/web/topleveldomains.go b/services/web/mgmt/2015-08-preview/web/topleveldomainsgroup.go
similarity index 61%
rename from services/web/mgmt/2015-08-preview/web/topleveldomains.go
rename to services/web/mgmt/2015-08-preview/web/topleveldomainsgroup.go
index cce9797214ea..e3118a8e461b 100644
--- a/services/web/mgmt/2015-08-preview/web/topleveldomains.go
+++ b/services/web/mgmt/2015-08-preview/web/topleveldomainsgroup.go
@@ -24,47 +24,47 @@ import (
"net/http"
)
-// TopLevelDomainsClient is the webSite Management Client
-type TopLevelDomainsClient struct {
+// TopLevelDomainsGroupClient is the webSite Management Client
+type TopLevelDomainsGroupClient struct {
BaseClient
}
-// NewTopLevelDomainsClient creates an instance of the TopLevelDomainsClient client.
-func NewTopLevelDomainsClient(subscriptionID string) TopLevelDomainsClient {
- return NewTopLevelDomainsClientWithBaseURI(DefaultBaseURI, subscriptionID)
+// NewTopLevelDomainsGroupClient creates an instance of the TopLevelDomainsGroupClient client.
+func NewTopLevelDomainsGroupClient(subscriptionID string) TopLevelDomainsGroupClient {
+ return NewTopLevelDomainsGroupClientWithBaseURI(DefaultBaseURI, subscriptionID)
}
-// NewTopLevelDomainsClientWithBaseURI creates an instance of the TopLevelDomainsClient client.
-func NewTopLevelDomainsClientWithBaseURI(baseURI string, subscriptionID string) TopLevelDomainsClient {
- return TopLevelDomainsClient{NewWithBaseURI(baseURI, subscriptionID)}
+// NewTopLevelDomainsGroupClientWithBaseURI creates an instance of the TopLevelDomainsGroupClient client.
+func NewTopLevelDomainsGroupClientWithBaseURI(baseURI string, subscriptionID string) TopLevelDomainsGroupClient {
+ return TopLevelDomainsGroupClient{NewWithBaseURI(baseURI, subscriptionID)}
}
// GetGetTopLevelDomains sends the get get top level domains request.
-func (client TopLevelDomainsClient) GetGetTopLevelDomains(ctx context.Context) (result TopLevelDomainCollectionPage, err error) {
+func (client TopLevelDomainsGroupClient) GetGetTopLevelDomains(ctx context.Context) (result TopLevelDomainCollectionPage, err error) {
result.fn = client.getGetTopLevelDomainsNextResults
req, err := client.GetGetTopLevelDomainsPreparer(ctx)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "GetGetTopLevelDomains", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "GetGetTopLevelDomains", nil, "Failure preparing request")
return
}
resp, err := client.GetGetTopLevelDomainsSender(req)
if err != nil {
result.tldc.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "GetGetTopLevelDomains", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "GetGetTopLevelDomains", resp, "Failure sending request")
return
}
result.tldc, err = client.GetGetTopLevelDomainsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "GetGetTopLevelDomains", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "GetGetTopLevelDomains", resp, "Failure responding to request")
}
return
}
// GetGetTopLevelDomainsPreparer prepares the GetGetTopLevelDomains request.
-func (client TopLevelDomainsClient) GetGetTopLevelDomainsPreparer(ctx context.Context) (*http.Request, error) {
+func (client TopLevelDomainsGroupClient) GetGetTopLevelDomainsPreparer(ctx context.Context) (*http.Request, error) {
pathParameters := map[string]interface{}{
"subscriptionId": autorest.Encode("path", client.SubscriptionID),
}
@@ -84,14 +84,14 @@ func (client TopLevelDomainsClient) GetGetTopLevelDomainsPreparer(ctx context.Co
// GetGetTopLevelDomainsSender sends the GetGetTopLevelDomains request. The method will close the
// http.Response Body if it receives an error.
-func (client TopLevelDomainsClient) GetGetTopLevelDomainsSender(req *http.Request) (*http.Response, error) {
+func (client TopLevelDomainsGroupClient) GetGetTopLevelDomainsSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetGetTopLevelDomainsResponder handles the response to the GetGetTopLevelDomains request. The method always
// closes the http.Response Body.
-func (client TopLevelDomainsClient) GetGetTopLevelDomainsResponder(resp *http.Response) (result TopLevelDomainCollection, err error) {
+func (client TopLevelDomainsGroupClient) GetGetTopLevelDomainsResponder(resp *http.Response) (result TopLevelDomainCollection, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -103,10 +103,10 @@ func (client TopLevelDomainsClient) GetGetTopLevelDomainsResponder(resp *http.Re
}
// getGetTopLevelDomainsNextResults retrieves the next set of results, if any.
-func (client TopLevelDomainsClient) getGetTopLevelDomainsNextResults(lastResults TopLevelDomainCollection) (result TopLevelDomainCollection, err error) {
+func (client TopLevelDomainsGroupClient) getGetTopLevelDomainsNextResults(lastResults TopLevelDomainCollection) (result TopLevelDomainCollection, err error) {
req, err := lastResults.topLevelDomainCollectionPreparer()
if err != nil {
- return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "getGetTopLevelDomainsNextResults", nil, "Failure preparing next results request")
+ return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "getGetTopLevelDomainsNextResults", nil, "Failure preparing next results request")
}
if req == nil {
return
@@ -114,17 +114,17 @@ func (client TopLevelDomainsClient) getGetTopLevelDomainsNextResults(lastResults
resp, err := client.GetGetTopLevelDomainsSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "getGetTopLevelDomainsNextResults", resp, "Failure sending next results request")
+ return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "getGetTopLevelDomainsNextResults", resp, "Failure sending next results request")
}
result, err = client.GetGetTopLevelDomainsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "getGetTopLevelDomainsNextResults", resp, "Failure responding to next results request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "getGetTopLevelDomainsNextResults", resp, "Failure responding to next results request")
}
return
}
// GetGetTopLevelDomainsComplete enumerates all values, automatically crossing page boundaries as required.
-func (client TopLevelDomainsClient) GetGetTopLevelDomainsComplete(ctx context.Context) (result TopLevelDomainCollectionIterator, err error) {
+func (client TopLevelDomainsGroupClient) GetGetTopLevelDomainsComplete(ctx context.Context) (result TopLevelDomainCollectionIterator, err error) {
result.page, err = client.GetGetTopLevelDomains(ctx)
return
}
@@ -132,30 +132,30 @@ func (client TopLevelDomainsClient) GetGetTopLevelDomainsComplete(ctx context.Co
// GetTopLevelDomain sends the get top level domain request.
//
// name is name of the top level domain
-func (client TopLevelDomainsClient) GetTopLevelDomain(ctx context.Context, name string) (result TopLevelDomain, err error) {
+func (client TopLevelDomainsGroupClient) GetTopLevelDomain(ctx context.Context, name string) (result TopLevelDomain, err error) {
req, err := client.GetTopLevelDomainPreparer(ctx, name)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "GetTopLevelDomain", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "GetTopLevelDomain", nil, "Failure preparing request")
return
}
resp, err := client.GetTopLevelDomainSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "GetTopLevelDomain", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "GetTopLevelDomain", resp, "Failure sending request")
return
}
result, err = client.GetTopLevelDomainResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "GetTopLevelDomain", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "GetTopLevelDomain", resp, "Failure responding to request")
}
return
}
// GetTopLevelDomainPreparer prepares the GetTopLevelDomain request.
-func (client TopLevelDomainsClient) GetTopLevelDomainPreparer(ctx context.Context, name string) (*http.Request, error) {
+func (client TopLevelDomainsGroupClient) GetTopLevelDomainPreparer(ctx context.Context, name string) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"subscriptionId": autorest.Encode("path", client.SubscriptionID),
@@ -176,14 +176,14 @@ func (client TopLevelDomainsClient) GetTopLevelDomainPreparer(ctx context.Contex
// GetTopLevelDomainSender sends the GetTopLevelDomain request. The method will close the
// http.Response Body if it receives an error.
-func (client TopLevelDomainsClient) GetTopLevelDomainSender(req *http.Request) (*http.Response, error) {
+func (client TopLevelDomainsGroupClient) GetTopLevelDomainSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// GetTopLevelDomainResponder handles the response to the GetTopLevelDomain request. The method always
// closes the http.Response Body.
-func (client TopLevelDomainsClient) GetTopLevelDomainResponder(resp *http.Response) (result TopLevelDomain, err error) {
+func (client TopLevelDomainsGroupClient) GetTopLevelDomainResponder(resp *http.Response) (result TopLevelDomain, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -197,31 +197,31 @@ func (client TopLevelDomainsClient) GetTopLevelDomainResponder(resp *http.Respon
// ListTopLevelDomainAgreements sends the list top level domain agreements request.
//
// name is name of the top level domain agreementOption is domain agreement options
-func (client TopLevelDomainsClient) ListTopLevelDomainAgreements(ctx context.Context, name string, agreementOption TopLevelDomainAgreementOption) (result TldLegalAgreementCollectionPage, err error) {
+func (client TopLevelDomainsGroupClient) ListTopLevelDomainAgreements(ctx context.Context, name string, agreementOption TopLevelDomainAgreementOption) (result TldLegalAgreementCollectionPage, err error) {
result.fn = client.listTopLevelDomainAgreementsNextResults
req, err := client.ListTopLevelDomainAgreementsPreparer(ctx, name, agreementOption)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListTopLevelDomainAgreements", nil, "Failure preparing request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "ListTopLevelDomainAgreements", nil, "Failure preparing request")
return
}
resp, err := client.ListTopLevelDomainAgreementsSender(req)
if err != nil {
result.tlac.Response = autorest.Response{Response: resp}
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListTopLevelDomainAgreements", resp, "Failure sending request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "ListTopLevelDomainAgreements", resp, "Failure sending request")
return
}
result.tlac, err = client.ListTopLevelDomainAgreementsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "ListTopLevelDomainAgreements", resp, "Failure responding to request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "ListTopLevelDomainAgreements", resp, "Failure responding to request")
}
return
}
// ListTopLevelDomainAgreementsPreparer prepares the ListTopLevelDomainAgreements request.
-func (client TopLevelDomainsClient) ListTopLevelDomainAgreementsPreparer(ctx context.Context, name string, agreementOption TopLevelDomainAgreementOption) (*http.Request, error) {
+func (client TopLevelDomainsGroupClient) ListTopLevelDomainAgreementsPreparer(ctx context.Context, name string, agreementOption TopLevelDomainAgreementOption) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"subscriptionId": autorest.Encode("path", client.SubscriptionID),
@@ -244,14 +244,14 @@ func (client TopLevelDomainsClient) ListTopLevelDomainAgreementsPreparer(ctx con
// ListTopLevelDomainAgreementsSender sends the ListTopLevelDomainAgreements request. The method will close the
// http.Response Body if it receives an error.
-func (client TopLevelDomainsClient) ListTopLevelDomainAgreementsSender(req *http.Request) (*http.Response, error) {
+func (client TopLevelDomainsGroupClient) ListTopLevelDomainAgreementsSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
azure.DoRetryWithRegistration(client.Client))
}
// ListTopLevelDomainAgreementsResponder handles the response to the ListTopLevelDomainAgreements request. The method always
// closes the http.Response Body.
-func (client TopLevelDomainsClient) ListTopLevelDomainAgreementsResponder(resp *http.Response) (result TldLegalAgreementCollection, err error) {
+func (client TopLevelDomainsGroupClient) ListTopLevelDomainAgreementsResponder(resp *http.Response) (result TldLegalAgreementCollection, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
@@ -263,10 +263,10 @@ func (client TopLevelDomainsClient) ListTopLevelDomainAgreementsResponder(resp *
}
// listTopLevelDomainAgreementsNextResults retrieves the next set of results, if any.
-func (client TopLevelDomainsClient) listTopLevelDomainAgreementsNextResults(lastResults TldLegalAgreementCollection) (result TldLegalAgreementCollection, err error) {
+func (client TopLevelDomainsGroupClient) listTopLevelDomainAgreementsNextResults(lastResults TldLegalAgreementCollection) (result TldLegalAgreementCollection, err error) {
req, err := lastResults.tldLegalAgreementCollectionPreparer()
if err != nil {
- return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "listTopLevelDomainAgreementsNextResults", nil, "Failure preparing next results request")
+ return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "listTopLevelDomainAgreementsNextResults", nil, "Failure preparing next results request")
}
if req == nil {
return
@@ -274,17 +274,17 @@ func (client TopLevelDomainsClient) listTopLevelDomainAgreementsNextResults(last
resp, err := client.ListTopLevelDomainAgreementsSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "listTopLevelDomainAgreementsNextResults", resp, "Failure sending next results request")
+ return result, autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "listTopLevelDomainAgreementsNextResults", resp, "Failure sending next results request")
}
result, err = client.ListTopLevelDomainAgreementsResponder(resp)
if err != nil {
- err = autorest.NewErrorWithError(err, "web.TopLevelDomainsClient", "listTopLevelDomainAgreementsNextResults", resp, "Failure responding to next results request")
+ err = autorest.NewErrorWithError(err, "web.TopLevelDomainsGroupClient", "listTopLevelDomainAgreementsNextResults", resp, "Failure responding to next results request")
}
return
}
// ListTopLevelDomainAgreementsComplete enumerates all values, automatically crossing page boundaries as required.
-func (client TopLevelDomainsClient) ListTopLevelDomainAgreementsComplete(ctx context.Context, name string, agreementOption TopLevelDomainAgreementOption) (result TldLegalAgreementCollectionIterator, err error) {
+func (client TopLevelDomainsGroupClient) ListTopLevelDomainAgreementsComplete(ctx context.Context, name string, agreementOption TopLevelDomainAgreementOption) (result TldLegalAgreementCollectionIterator, err error) {
result.page, err = client.ListTopLevelDomainAgreements(ctx, name, agreementOption)
return
}
diff --git a/services/web/mgmt/2016-09-01/web/models.go b/services/web/mgmt/2016-09-01/web/models.go
index f92303797b48..bf1f0a192939 100644
--- a/services/web/mgmt/2016-09-01/web/models.go
+++ b/services/web/mgmt/2016-09-01/web/models.go
@@ -731,19 +731,6 @@ func PossibleManagedPipelineModeValues() []ManagedPipelineMode {
return []ManagedPipelineMode{Classic, Integrated}
}
-// ManagedServiceIdentityType enumerates the values for managed service identity type.
-type ManagedServiceIdentityType string
-
-const (
- // SystemAssigned ...
- SystemAssigned ManagedServiceIdentityType = "SystemAssigned"
-)
-
-// PossibleManagedServiceIdentityTypeValues returns an array of possible values for the ManagedServiceIdentityType const type.
-func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType {
- return []ManagedServiceIdentityType{SystemAssigned}
-}
-
// MSDeployLogEntryType enumerates the values for ms deploy log entry type.
type MSDeployLogEntryType string
@@ -6878,6 +6865,35 @@ type DataSource struct {
DataSourceURI *[]NameValuePair `json:"dataSourceUri,omitempty"`
}
+// DefaultErrorResponse app Service error response.
+type DefaultErrorResponse struct {
+ // Error - Error model.
+ Error *DefaultErrorResponseError `json:"error,omitempty"`
+}
+
+// DefaultErrorResponseError error model.
+type DefaultErrorResponseError struct {
+ // Code - Standardized string to programmatically identify the error.
+ Code *string `json:"code,omitempty"`
+ // Message - Detailed error description and debugging information.
+ Message *string `json:"message,omitempty"`
+ // Target - Detailed error description and debugging information.
+ Target *string `json:"target,omitempty"`
+ Details *[]DefaultErrorResponseErrorDetailsItem `json:"details,omitempty"`
+ // Innererror - More information to debug error.
+ Innererror *string `json:"innererror,omitempty"`
+}
+
+// DefaultErrorResponseErrorDetailsItem detailed errors.
+type DefaultErrorResponseErrorDetailsItem struct {
+ // Code - Standardized string to programmatically identify the error.
+ Code *string `json:"code,omitempty"`
+ // Message - Detailed error description and debugging information.
+ Message *string `json:"message,omitempty"`
+ // Target - Detailed error description and debugging information.
+ Target *string `json:"target,omitempty"`
+}
+
// DeletedSite a deleted app.
type DeletedSite struct {
// ID - Numeric id for the deleted site
@@ -10597,6 +10613,12 @@ type ListOperation struct {
Value *[]Operation `json:"value,omitempty"`
}
+// ListRecommendation ...
+type ListRecommendation struct {
+ autorest.Response `json:"-"`
+ Value *[]Recommendation `json:"value,omitempty"`
+}
+
// ListVnetInfo ...
type ListVnetInfo struct {
autorest.Response `json:"-"`
@@ -10619,8 +10641,8 @@ type LocalizableString struct {
// ManagedServiceIdentity managed service identity.
type ManagedServiceIdentity struct {
- // Type - Type of managed service identity. Possible values include: 'SystemAssigned'
- Type ManagedServiceIdentityType `json:"type,omitempty"`
+ // Type - Type of managed service identity.
+ Type interface{} `json:"type,omitempty"`
// TenantID - Tenant of managed service identity.
TenantID *string `json:"tenantId,omitempty"`
// PrincipalID - Principal Id of managed service identity.
@@ -13340,203 +13362,6 @@ type ReadCloser struct {
// Recommendation represents a recommendation result generated by the recommendation engine.
type Recommendation struct {
- // RecommendationProperties - Recommendation resource specific properties
- *RecommendationProperties `json:"properties,omitempty"`
- // ID - Resource Id.
- ID *string `json:"id,omitempty"`
- // Name - Resource Name.
- Name *string `json:"name,omitempty"`
- // Kind - Kind of resource.
- Kind *string `json:"kind,omitempty"`
- // Type - Resource type.
- Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for Recommendation.
-func (r Recommendation) MarshalJSON() ([]byte, error) {
- objectMap := make(map[string]interface{})
- if r.RecommendationProperties != nil {
- objectMap["properties"] = r.RecommendationProperties
- }
- if r.ID != nil {
- objectMap["id"] = r.ID
- }
- if r.Name != nil {
- objectMap["name"] = r.Name
- }
- if r.Kind != nil {
- objectMap["kind"] = r.Kind
- }
- if r.Type != nil {
- objectMap["type"] = r.Type
- }
- return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for Recommendation struct.
-func (r *Recommendation) UnmarshalJSON(body []byte) error {
- var m map[string]*json.RawMessage
- err := json.Unmarshal(body, &m)
- if err != nil {
- return err
- }
- for k, v := range m {
- switch k {
- case "properties":
- if v != nil {
- var recommendationProperties RecommendationProperties
- err = json.Unmarshal(*v, &recommendationProperties)
- if err != nil {
- return err
- }
- r.RecommendationProperties = &recommendationProperties
- }
- case "id":
- if v != nil {
- var ID string
- err = json.Unmarshal(*v, &ID)
- if err != nil {
- return err
- }
- r.ID = &ID
- }
- case "name":
- if v != nil {
- var name string
- err = json.Unmarshal(*v, &name)
- if err != nil {
- return err
- }
- r.Name = &name
- }
- case "kind":
- if v != nil {
- var kind string
- err = json.Unmarshal(*v, &kind)
- if err != nil {
- return err
- }
- r.Kind = &kind
- }
- case "type":
- if v != nil {
- var typeVar string
- err = json.Unmarshal(*v, &typeVar)
- if err != nil {
- return err
- }
- r.Type = &typeVar
- }
- }
- }
-
- return nil
-}
-
-// RecommendationCollection collection of recommendations.
-type RecommendationCollection struct {
- autorest.Response `json:"-"`
- // Value - Collection of resources.
- Value *[]Recommendation `json:"value,omitempty"`
- // NextLink - Link to next page of resources.
- NextLink *string `json:"nextLink,omitempty"`
-}
-
-// RecommendationCollectionIterator provides access to a complete listing of Recommendation values.
-type RecommendationCollectionIterator struct {
- i int
- page RecommendationCollectionPage
-}
-
-// Next advances to the next value. If there was an error making
-// the request the iterator does not advance and the error is returned.
-func (iter *RecommendationCollectionIterator) Next() error {
- iter.i++
- if iter.i < len(iter.page.Values()) {
- return nil
- }
- err := iter.page.Next()
- if err != nil {
- iter.i--
- return err
- }
- iter.i = 0
- return nil
-}
-
-// NotDone returns true if the enumeration should be started or is not yet complete.
-func (iter RecommendationCollectionIterator) NotDone() bool {
- return iter.page.NotDone() && iter.i < len(iter.page.Values())
-}
-
-// Response returns the raw server response from the last page request.
-func (iter RecommendationCollectionIterator) Response() RecommendationCollection {
- return iter.page.Response()
-}
-
-// Value returns the current value or a zero-initialized value if the
-// iterator has advanced beyond the end of the collection.
-func (iter RecommendationCollectionIterator) Value() Recommendation {
- if !iter.page.NotDone() {
- return Recommendation{}
- }
- return iter.page.Values()[iter.i]
-}
-
-// IsEmpty returns true if the ListResult contains no values.
-func (rc RecommendationCollection) IsEmpty() bool {
- return rc.Value == nil || len(*rc.Value) == 0
-}
-
-// recommendationCollectionPreparer prepares a request to retrieve the next set of results.
-// It returns nil if no more results exist.
-func (rc RecommendationCollection) recommendationCollectionPreparer() (*http.Request, error) {
- if rc.NextLink == nil || len(to.String(rc.NextLink)) < 1 {
- return nil, nil
- }
- return autorest.Prepare(&http.Request{},
- autorest.AsJSON(),
- autorest.AsGet(),
- autorest.WithBaseURL(to.String(rc.NextLink)))
-}
-
-// RecommendationCollectionPage contains a page of Recommendation values.
-type RecommendationCollectionPage struct {
- fn func(RecommendationCollection) (RecommendationCollection, error)
- rc RecommendationCollection
-}
-
-// Next advances to the next page of values. If there was an error making
-// the request the page does not advance and the error is returned.
-func (page *RecommendationCollectionPage) Next() error {
- next, err := page.fn(page.rc)
- if err != nil {
- return err
- }
- page.rc = next
- return nil
-}
-
-// NotDone returns true if the page enumeration should be started or is not yet complete.
-func (page RecommendationCollectionPage) NotDone() bool {
- return !page.rc.IsEmpty()
-}
-
-// Response returns the raw server response from the last page request.
-func (page RecommendationCollectionPage) Response() RecommendationCollection {
- return page.rc
-}
-
-// Values returns the slice of values for the current page or nil if there are no values.
-func (page RecommendationCollectionPage) Values() []Recommendation {
- if page.rc.IsEmpty() {
- return nil
- }
- return *page.rc.Value
-}
-
-// RecommendationProperties recommendation resource specific properties
-type RecommendationProperties struct {
// CreationTime - Timestamp when this instance was created.
CreationTime *date.Time `json:"creationTime,omitempty"`
// RecommendationID - A GUID value that each recommendation object is associated with.
@@ -13584,101 +13409,6 @@ type RecommendationProperties struct {
// RecommendationRule represents a recommendation rule that the recommendation engine can perform.
type RecommendationRule struct {
autorest.Response `json:"-"`
- // RecommendationRuleProperties - RecommendationRule resource specific properties
- *RecommendationRuleProperties `json:"properties,omitempty"`
- // ID - Resource Id.
- ID *string `json:"id,omitempty"`
- // Name - Resource Name.
- Name *string `json:"name,omitempty"`
- // Kind - Kind of resource.
- Kind *string `json:"kind,omitempty"`
- // Type - Resource type.
- Type *string `json:"type,omitempty"`
-}
-
-// MarshalJSON is the custom marshaler for RecommendationRule.
-func (rr RecommendationRule) MarshalJSON() ([]byte, error) {
- objectMap := make(map[string]interface{})
- if rr.RecommendationRuleProperties != nil {
- objectMap["properties"] = rr.RecommendationRuleProperties
- }
- if rr.ID != nil {
- objectMap["id"] = rr.ID
- }
- if rr.Name != nil {
- objectMap["name"] = rr.Name
- }
- if rr.Kind != nil {
- objectMap["kind"] = rr.Kind
- }
- if rr.Type != nil {
- objectMap["type"] = rr.Type
- }
- return json.Marshal(objectMap)
-}
-
-// UnmarshalJSON is the custom unmarshaler for RecommendationRule struct.
-func (rr *RecommendationRule) UnmarshalJSON(body []byte) error {
- var m map[string]*json.RawMessage
- err := json.Unmarshal(body, &m)
- if err != nil {
- return err
- }
- for k, v := range m {
- switch k {
- case "properties":
- if v != nil {
- var recommendationRuleProperties RecommendationRuleProperties
- err = json.Unmarshal(*v, &recommendationRuleProperties)
- if err != nil {
- return err
- }
- rr.RecommendationRuleProperties = &recommendationRuleProperties
- }
- case "id":
- if v != nil {
- var ID string
- err = json.Unmarshal(*v, &ID)
- if err != nil {
- return err
- }
- rr.ID = &ID
- }
- case "name":
- if v != nil {
- var name string
- err = json.Unmarshal(*v, &name)
- if err != nil {
- return err
- }
- rr.Name = &name
- }
- case "kind":
- if v != nil {
- var kind string
- err = json.Unmarshal(*v, &kind)
- if err != nil {
- return err
- }
- rr.Kind = &kind
- }
- case "type":
- if v != nil {
- var typeVar string
- err = json.Unmarshal(*v, &typeVar)
- if err != nil {
- return err
- }
- rr.Type = &typeVar
- }
- }
- }
-
- return nil
-}
-
-// RecommendationRuleProperties recommendationRule resource specific properties
-type RecommendationRuleProperties struct {
// Name - Unique name of the rule.
Name *string `json:"name,omitempty"`
// DisplayName - UI friendly name of the rule.
@@ -14177,6 +13907,212 @@ func (page ResourceCollectionPage) Values() []string {
return *page.rc.Value
}
+// ResourceHealthMetadata used for getting ResourceHealthCheck settings.
+type ResourceHealthMetadata struct {
+ autorest.Response `json:"-"`
+ // ResourceHealthMetadataProperties - ResourceHealthMetadata resource specific properties
+ *ResourceHealthMetadataProperties `json:"properties,omitempty"`
+ // ID - Resource Id.
+ ID *string `json:"id,omitempty"`
+ // Name - Resource Name.
+ Name *string `json:"name,omitempty"`
+ // Kind - Kind of resource.
+ Kind *string `json:"kind,omitempty"`
+ // Type - Resource type.
+ Type *string `json:"type,omitempty"`
+}
+
+// MarshalJSON is the custom marshaler for ResourceHealthMetadata.
+func (rhm ResourceHealthMetadata) MarshalJSON() ([]byte, error) {
+ objectMap := make(map[string]interface{})
+ if rhm.ResourceHealthMetadataProperties != nil {
+ objectMap["properties"] = rhm.ResourceHealthMetadataProperties
+ }
+ if rhm.ID != nil {
+ objectMap["id"] = rhm.ID
+ }
+ if rhm.Name != nil {
+ objectMap["name"] = rhm.Name
+ }
+ if rhm.Kind != nil {
+ objectMap["kind"] = rhm.Kind
+ }
+ if rhm.Type != nil {
+ objectMap["type"] = rhm.Type
+ }
+ return json.Marshal(objectMap)
+}
+
+// UnmarshalJSON is the custom unmarshaler for ResourceHealthMetadata struct.
+func (rhm *ResourceHealthMetadata) UnmarshalJSON(body []byte) error {
+ var m map[string]*json.RawMessage
+ err := json.Unmarshal(body, &m)
+ if err != nil {
+ return err
+ }
+ for k, v := range m {
+ switch k {
+ case "properties":
+ if v != nil {
+ var resourceHealthMetadataProperties ResourceHealthMetadataProperties
+ err = json.Unmarshal(*v, &resourceHealthMetadataProperties)
+ if err != nil {
+ return err
+ }
+ rhm.ResourceHealthMetadataProperties = &resourceHealthMetadataProperties
+ }
+ case "id":
+ if v != nil {
+ var ID string
+ err = json.Unmarshal(*v, &ID)
+ if err != nil {
+ return err
+ }
+ rhm.ID = &ID
+ }
+ case "name":
+ if v != nil {
+ var name string
+ err = json.Unmarshal(*v, &name)
+ if err != nil {
+ return err
+ }
+ rhm.Name = &name
+ }
+ case "kind":
+ if v != nil {
+ var kind string
+ err = json.Unmarshal(*v, &kind)
+ if err != nil {
+ return err
+ }
+ rhm.Kind = &kind
+ }
+ case "type":
+ if v != nil {
+ var typeVar string
+ err = json.Unmarshal(*v, &typeVar)
+ if err != nil {
+ return err
+ }
+ rhm.Type = &typeVar
+ }
+ }
+ }
+
+ return nil
+}
+
+// ResourceHealthMetadataCollection collection of resource health metadata.
+type ResourceHealthMetadataCollection struct {
+ autorest.Response `json:"-"`
+ // Value - Collection of resources.
+ Value *[]ResourceHealthMetadata `json:"value,omitempty"`
+ // NextLink - Link to next page of resources.
+ NextLink *string `json:"nextLink,omitempty"`
+}
+
+// ResourceHealthMetadataCollectionIterator provides access to a complete listing of ResourceHealthMetadata values.
+type ResourceHealthMetadataCollectionIterator struct {
+ i int
+ page ResourceHealthMetadataCollectionPage
+}
+
+// Next advances to the next value. If there was an error making
+// the request the iterator does not advance and the error is returned.
+func (iter *ResourceHealthMetadataCollectionIterator) Next() error {
+ iter.i++
+ if iter.i < len(iter.page.Values()) {
+ return nil
+ }
+ err := iter.page.Next()
+ if err != nil {
+ iter.i--
+ return err
+ }
+ iter.i = 0
+ return nil
+}
+
+// NotDone returns true if the enumeration should be started or is not yet complete.
+func (iter ResourceHealthMetadataCollectionIterator) NotDone() bool {
+ return iter.page.NotDone() && iter.i < len(iter.page.Values())
+}
+
+// Response returns the raw server response from the last page request.
+func (iter ResourceHealthMetadataCollectionIterator) Response() ResourceHealthMetadataCollection {
+ return iter.page.Response()
+}
+
+// Value returns the current value or a zero-initialized value if the
+// iterator has advanced beyond the end of the collection.
+func (iter ResourceHealthMetadataCollectionIterator) Value() ResourceHealthMetadata {
+ if !iter.page.NotDone() {
+ return ResourceHealthMetadata{}
+ }
+ return iter.page.Values()[iter.i]
+}
+
+// IsEmpty returns true if the ListResult contains no values.
+func (rhmc ResourceHealthMetadataCollection) IsEmpty() bool {
+ return rhmc.Value == nil || len(*rhmc.Value) == 0
+}
+
+// resourceHealthMetadataCollectionPreparer prepares a request to retrieve the next set of results.
+// It returns nil if no more results exist.
+func (rhmc ResourceHealthMetadataCollection) resourceHealthMetadataCollectionPreparer() (*http.Request, error) {
+ if rhmc.NextLink == nil || len(to.String(rhmc.NextLink)) < 1 {
+ return nil, nil
+ }
+ return autorest.Prepare(&http.Request{},
+ autorest.AsJSON(),
+ autorest.AsGet(),
+ autorest.WithBaseURL(to.String(rhmc.NextLink)))
+}
+
+// ResourceHealthMetadataCollectionPage contains a page of ResourceHealthMetadata values.
+type ResourceHealthMetadataCollectionPage struct {
+ fn func(ResourceHealthMetadataCollection) (ResourceHealthMetadataCollection, error)
+ rhmc ResourceHealthMetadataCollection
+}
+
+// Next advances to the next page of values. If there was an error making
+// the request the page does not advance and the error is returned.
+func (page *ResourceHealthMetadataCollectionPage) Next() error {
+ next, err := page.fn(page.rhmc)
+ if err != nil {
+ return err
+ }
+ page.rhmc = next
+ return nil
+}
+
+// NotDone returns true if the page enumeration should be started or is not yet complete.
+func (page ResourceHealthMetadataCollectionPage) NotDone() bool {
+ return !page.rhmc.IsEmpty()
+}
+
+// Response returns the raw server response from the last page request.
+func (page ResourceHealthMetadataCollectionPage) Response() ResourceHealthMetadataCollection {
+ return page.rhmc
+}
+
+// Values returns the slice of values for the current page or nil if there are no values.
+func (page ResourceHealthMetadataCollectionPage) Values() []ResourceHealthMetadata {
+ if page.rhmc.IsEmpty() {
+ return nil
+ }
+ return *page.rhmc.Value
+}
+
+// ResourceHealthMetadataProperties resourceHealthMetadata resource specific properties
+type ResourceHealthMetadataProperties struct {
+ // Category - The category that the resource matches in the RHC Policy File
+ Category *string `json:"category,omitempty"`
+ // SignalAvailability - Is there a health signal for the resource
+ SignalAvailability *bool `json:"signalAvailability,omitempty"`
+}
+
// ResourceMetric object representing a metric for any resource .
type ResourceMetric struct {
// Name - Name of metric.
diff --git a/services/web/mgmt/2016-09-01/web/recommendations.go b/services/web/mgmt/2016-09-01/web/recommendations.go
index eda8421f6d0a..f7a29a096df6 100644
--- a/services/web/mgmt/2016-09-01/web/recommendations.go
+++ b/services/web/mgmt/2016-09-01/web/recommendations.go
@@ -113,153 +113,12 @@ func (client RecommendationsClient) DisableAllForWebAppResponder(resp *http.Resp
return
}
-// DisableRecommendationForSite disables the specific rule for a web site permanently.
-//
-// resourceGroupName is name of the resource group to which the resource belongs. siteName is site name name is
-// rule name
-func (client RecommendationsClient) DisableRecommendationForSite(ctx context.Context, resourceGroupName string, siteName string, name string) (result autorest.Response, err error) {
- if err := validation.Validate([]validation.Validation{
- {TargetValue: resourceGroupName,
- Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
- {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
- {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
- return result, validation.NewError("web.RecommendationsClient", "DisableRecommendationForSite", err.Error())
- }
-
- req, err := client.DisableRecommendationForSitePreparer(ctx, resourceGroupName, siteName, name)
- if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableRecommendationForSite", nil, "Failure preparing request")
- return
- }
-
- resp, err := client.DisableRecommendationForSiteSender(req)
- if err != nil {
- result.Response = resp
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableRecommendationForSite", resp, "Failure sending request")
- return
- }
-
- result, err = client.DisableRecommendationForSiteResponder(resp)
- if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableRecommendationForSite", resp, "Failure responding to request")
- }
-
- return
-}
-
-// DisableRecommendationForSitePreparer prepares the DisableRecommendationForSite request.
-func (client RecommendationsClient) DisableRecommendationForSitePreparer(ctx context.Context, resourceGroupName string, siteName string, name string) (*http.Request, error) {
- pathParameters := map[string]interface{}{
- "name": autorest.Encode("path", name),
- "resourceGroupName": autorest.Encode("path", resourceGroupName),
- "siteName": autorest.Encode("path", siteName),
- "subscriptionId": autorest.Encode("path", client.SubscriptionID),
- }
-
- const APIVersion = "2016-03-01"
- queryParameters := map[string]interface{}{
- "api-version": APIVersion,
- }
-
- preparer := autorest.CreatePreparer(
- autorest.AsPost(),
- autorest.WithBaseURL(client.BaseURI),
- autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{siteName}/recommendations/{name}/disable", pathParameters),
- autorest.WithQueryParameters(queryParameters))
- return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DisableRecommendationForSiteSender sends the DisableRecommendationForSite request. The method will close the
-// http.Response Body if it receives an error.
-func (client RecommendationsClient) DisableRecommendationForSiteSender(req *http.Request) (*http.Response, error) {
- return autorest.SendWithSender(client, req,
- azure.DoRetryWithRegistration(client.Client))
-}
-
-// DisableRecommendationForSiteResponder handles the response to the DisableRecommendationForSite request. The method always
-// closes the http.Response Body.
-func (client RecommendationsClient) DisableRecommendationForSiteResponder(resp *http.Response) (result autorest.Response, err error) {
- err = autorest.Respond(
- resp,
- client.ByInspecting(),
- azure.WithErrorUnlessStatusCode(http.StatusOK),
- autorest.ByClosing())
- result.Response = resp
- return
-}
-
-// DisableRecommendationForSubscription disables the specified rule so it will not apply to a subscription in the
-// future.
-//
-// name is rule name
-func (client RecommendationsClient) DisableRecommendationForSubscription(ctx context.Context, name string) (result autorest.Response, err error) {
- req, err := client.DisableRecommendationForSubscriptionPreparer(ctx, name)
- if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableRecommendationForSubscription", nil, "Failure preparing request")
- return
- }
-
- resp, err := client.DisableRecommendationForSubscriptionSender(req)
- if err != nil {
- result.Response = resp
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableRecommendationForSubscription", resp, "Failure sending request")
- return
- }
-
- result, err = client.DisableRecommendationForSubscriptionResponder(resp)
- if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "DisableRecommendationForSubscription", resp, "Failure responding to request")
- }
-
- return
-}
-
-// DisableRecommendationForSubscriptionPreparer prepares the DisableRecommendationForSubscription request.
-func (client RecommendationsClient) DisableRecommendationForSubscriptionPreparer(ctx context.Context, name string) (*http.Request, error) {
- pathParameters := map[string]interface{}{
- "name": autorest.Encode("path", name),
- "subscriptionId": autorest.Encode("path", client.SubscriptionID),
- }
-
- const APIVersion = "2016-03-01"
- queryParameters := map[string]interface{}{
- "api-version": APIVersion,
- }
-
- preparer := autorest.CreatePreparer(
- autorest.AsPost(),
- autorest.WithBaseURL(client.BaseURI),
- autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/recommendations/{name}/disable", pathParameters),
- autorest.WithQueryParameters(queryParameters))
- return preparer.Prepare((&http.Request{}).WithContext(ctx))
-}
-
-// DisableRecommendationForSubscriptionSender sends the DisableRecommendationForSubscription request. The method will close the
-// http.Response Body if it receives an error.
-func (client RecommendationsClient) DisableRecommendationForSubscriptionSender(req *http.Request) (*http.Response, error) {
- return autorest.SendWithSender(client, req,
- azure.DoRetryWithRegistration(client.Client))
-}
-
-// DisableRecommendationForSubscriptionResponder handles the response to the DisableRecommendationForSubscription request. The method always
-// closes the http.Response Body.
-func (client RecommendationsClient) DisableRecommendationForSubscriptionResponder(resp *http.Response) (result autorest.Response, err error) {
- err = autorest.Respond(
- resp,
- client.ByInspecting(),
- azure.WithErrorUnlessStatusCode(http.StatusOK),
- autorest.ByClosing())
- result.Response = resp
- return
-}
-
// GetRuleDetailsByWebApp get a recommendation rule for an app.
//
// resourceGroupName is name of the resource group to which the resource belongs. siteName is name of the app. name
// is name of the recommendation. updateSeen is specify true to update the last-seen timestamp of the
-// recommendation object. recommendationID is the GUID of the recommedation object if you query an expired one. You
-// don't need to specify it to query an active entry.
-func (client RecommendationsClient) GetRuleDetailsByWebApp(ctx context.Context, resourceGroupName string, siteName string, name string, updateSeen *bool, recommendationID string) (result RecommendationRule, err error) {
+// recommendation object.
+func (client RecommendationsClient) GetRuleDetailsByWebApp(ctx context.Context, resourceGroupName string, siteName string, name string, updateSeen *bool) (result RecommendationRule, err error) {
if err := validation.Validate([]validation.Validation{
{TargetValue: resourceGroupName,
Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
@@ -268,7 +127,7 @@ func (client RecommendationsClient) GetRuleDetailsByWebApp(ctx context.Context,
return result, validation.NewError("web.RecommendationsClient", "GetRuleDetailsByWebApp", err.Error())
}
- req, err := client.GetRuleDetailsByWebAppPreparer(ctx, resourceGroupName, siteName, name, updateSeen, recommendationID)
+ req, err := client.GetRuleDetailsByWebAppPreparer(ctx, resourceGroupName, siteName, name, updateSeen)
if err != nil {
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "GetRuleDetailsByWebApp", nil, "Failure preparing request")
return
@@ -290,7 +149,7 @@ func (client RecommendationsClient) GetRuleDetailsByWebApp(ctx context.Context,
}
// GetRuleDetailsByWebAppPreparer prepares the GetRuleDetailsByWebApp request.
-func (client RecommendationsClient) GetRuleDetailsByWebAppPreparer(ctx context.Context, resourceGroupName string, siteName string, name string, updateSeen *bool, recommendationID string) (*http.Request, error) {
+func (client RecommendationsClient) GetRuleDetailsByWebAppPreparer(ctx context.Context, resourceGroupName string, siteName string, name string, updateSeen *bool) (*http.Request, error) {
pathParameters := map[string]interface{}{
"name": autorest.Encode("path", name),
"resourceGroupName": autorest.Encode("path", resourceGroupName),
@@ -305,9 +164,6 @@ func (client RecommendationsClient) GetRuleDetailsByWebAppPreparer(ctx context.C
if updateSeen != nil {
queryParameters["updateSeen"] = autorest.Encode("query", *updateSeen)
}
- if len(recommendationID) > 0 {
- queryParameters["recommendationId"] = autorest.Encode("query", recommendationID)
- }
preparer := autorest.CreatePreparer(
autorest.AsGet(),
@@ -343,8 +199,7 @@ func (client RecommendationsClient) GetRuleDetailsByWebAppResponder(resp *http.R
// false, which returns all recommendations. filter is filter is specified by using OData syntax.
// Example: $filter=channels eq 'Api' or channel eq 'Notification' and startTime eq '2014-01-01T00:00:00Z' and
// endTime eq '2014-12-31T23:59:59Z' and timeGrain eq duration'[PT1H|PT1M|P1D]
-func (client RecommendationsClient) List(ctx context.Context, featured *bool, filter string) (result RecommendationCollectionPage, err error) {
- result.fn = client.listNextResults
+func (client RecommendationsClient) List(ctx context.Context, featured *bool, filter string) (result ListRecommendation, err error) {
req, err := client.ListPreparer(ctx, featured, filter)
if err != nil {
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "List", nil, "Failure preparing request")
@@ -353,12 +208,12 @@ func (client RecommendationsClient) List(ctx context.Context, featured *bool, fi
resp, err := client.ListSender(req)
if err != nil {
- result.rc.Response = autorest.Response{Response: resp}
+ result.Response = autorest.Response{Response: resp}
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "List", resp, "Failure sending request")
return
}
- result.rc, err = client.ListResponder(resp)
+ result, err = client.ListResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "List", resp, "Failure responding to request")
}
@@ -400,51 +255,24 @@ func (client RecommendationsClient) ListSender(req *http.Request) (*http.Respons
// ListResponder handles the response to the List request. The method always
// closes the http.Response Body.
-func (client RecommendationsClient) ListResponder(resp *http.Response) (result RecommendationCollection, err error) {
+func (client RecommendationsClient) ListResponder(resp *http.Response) (result ListRecommendation, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
azure.WithErrorUnlessStatusCode(http.StatusOK),
- autorest.ByUnmarshallingJSON(&result),
+ autorest.ByUnmarshallingJSON(&result.Value),
autorest.ByClosing())
result.Response = autorest.Response{Response: resp}
return
}
-// listNextResults retrieves the next set of results, if any.
-func (client RecommendationsClient) listNextResults(lastResults RecommendationCollection) (result RecommendationCollection, err error) {
- req, err := lastResults.recommendationCollectionPreparer()
- if err != nil {
- return result, autorest.NewErrorWithError(err, "web.RecommendationsClient", "listNextResults", nil, "Failure preparing next results request")
- }
- if req == nil {
- return
- }
- resp, err := client.ListSender(req)
- if err != nil {
- result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.RecommendationsClient", "listNextResults", resp, "Failure sending next results request")
- }
- result, err = client.ListResponder(resp)
- if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "listNextResults", resp, "Failure responding to next results request")
- }
- return
-}
-
-// ListComplete enumerates all values, automatically crossing page boundaries as required.
-func (client RecommendationsClient) ListComplete(ctx context.Context, featured *bool, filter string) (result RecommendationCollectionIterator, err error) {
- result.page, err = client.List(ctx, featured, filter)
- return
-}
-
// ListHistoryForWebApp get past recommendations for an app, optionally specified by the time range.
//
// resourceGroupName is name of the resource group to which the resource belongs. siteName is name of the app.
// filter is filter is specified by using OData syntax. Example: $filter=channels eq 'Api' or channel eq
// 'Notification' and startTime eq '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain eq
// duration'[PT1H|PT1M|P1D]
-func (client RecommendationsClient) ListHistoryForWebApp(ctx context.Context, resourceGroupName string, siteName string, filter string) (result RecommendationCollectionPage, err error) {
+func (client RecommendationsClient) ListHistoryForWebApp(ctx context.Context, resourceGroupName string, siteName string, filter string) (result ListRecommendation, err error) {
if err := validation.Validate([]validation.Validation{
{TargetValue: resourceGroupName,
Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
@@ -453,7 +281,6 @@ func (client RecommendationsClient) ListHistoryForWebApp(ctx context.Context, re
return result, validation.NewError("web.RecommendationsClient", "ListHistoryForWebApp", err.Error())
}
- result.fn = client.listHistoryForWebAppNextResults
req, err := client.ListHistoryForWebAppPreparer(ctx, resourceGroupName, siteName, filter)
if err != nil {
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListHistoryForWebApp", nil, "Failure preparing request")
@@ -462,12 +289,12 @@ func (client RecommendationsClient) ListHistoryForWebApp(ctx context.Context, re
resp, err := client.ListHistoryForWebAppSender(req)
if err != nil {
- result.rc.Response = autorest.Response{Response: resp}
+ result.Response = autorest.Response{Response: resp}
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListHistoryForWebApp", resp, "Failure sending request")
return
}
- result.rc, err = client.ListHistoryForWebAppResponder(resp)
+ result, err = client.ListHistoryForWebAppResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListHistoryForWebApp", resp, "Failure responding to request")
}
@@ -508,51 +335,24 @@ func (client RecommendationsClient) ListHistoryForWebAppSender(req *http.Request
// ListHistoryForWebAppResponder handles the response to the ListHistoryForWebApp request. The method always
// closes the http.Response Body.
-func (client RecommendationsClient) ListHistoryForWebAppResponder(resp *http.Response) (result RecommendationCollection, err error) {
+func (client RecommendationsClient) ListHistoryForWebAppResponder(resp *http.Response) (result ListRecommendation, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
azure.WithErrorUnlessStatusCode(http.StatusOK),
- autorest.ByUnmarshallingJSON(&result),
+ autorest.ByUnmarshallingJSON(&result.Value),
autorest.ByClosing())
result.Response = autorest.Response{Response: resp}
return
}
-// listHistoryForWebAppNextResults retrieves the next set of results, if any.
-func (client RecommendationsClient) listHistoryForWebAppNextResults(lastResults RecommendationCollection) (result RecommendationCollection, err error) {
- req, err := lastResults.recommendationCollectionPreparer()
- if err != nil {
- return result, autorest.NewErrorWithError(err, "web.RecommendationsClient", "listHistoryForWebAppNextResults", nil, "Failure preparing next results request")
- }
- if req == nil {
- return
- }
- resp, err := client.ListHistoryForWebAppSender(req)
- if err != nil {
- result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.RecommendationsClient", "listHistoryForWebAppNextResults", resp, "Failure sending next results request")
- }
- result, err = client.ListHistoryForWebAppResponder(resp)
- if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "listHistoryForWebAppNextResults", resp, "Failure responding to next results request")
- }
- return
-}
-
-// ListHistoryForWebAppComplete enumerates all values, automatically crossing page boundaries as required.
-func (client RecommendationsClient) ListHistoryForWebAppComplete(ctx context.Context, resourceGroupName string, siteName string, filter string) (result RecommendationCollectionIterator, err error) {
- result.page, err = client.ListHistoryForWebApp(ctx, resourceGroupName, siteName, filter)
- return
-}
-
// ListRecommendedRulesForWebApp get all recommendations for an app.
//
// resourceGroupName is name of the resource group to which the resource belongs. siteName is name of the app.
// featured is specify true to return only the most critical recommendations. The default is
// false, which returns all recommendations. filter is return only channels specified in the filter.
// Filter is specified by using OData syntax. Example: $filter=channels eq 'Api' or channel eq 'Notification'
-func (client RecommendationsClient) ListRecommendedRulesForWebApp(ctx context.Context, resourceGroupName string, siteName string, featured *bool, filter string) (result RecommendationCollectionPage, err error) {
+func (client RecommendationsClient) ListRecommendedRulesForWebApp(ctx context.Context, resourceGroupName string, siteName string, featured *bool, filter string) (result ListRecommendation, err error) {
if err := validation.Validate([]validation.Validation{
{TargetValue: resourceGroupName,
Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
@@ -561,7 +361,6 @@ func (client RecommendationsClient) ListRecommendedRulesForWebApp(ctx context.Co
return result, validation.NewError("web.RecommendationsClient", "ListRecommendedRulesForWebApp", err.Error())
}
- result.fn = client.listRecommendedRulesForWebAppNextResults
req, err := client.ListRecommendedRulesForWebAppPreparer(ctx, resourceGroupName, siteName, featured, filter)
if err != nil {
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListRecommendedRulesForWebApp", nil, "Failure preparing request")
@@ -570,12 +369,12 @@ func (client RecommendationsClient) ListRecommendedRulesForWebApp(ctx context.Co
resp, err := client.ListRecommendedRulesForWebAppSender(req)
if err != nil {
- result.rc.Response = autorest.Response{Response: resp}
+ result.Response = autorest.Response{Response: resp}
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListRecommendedRulesForWebApp", resp, "Failure sending request")
return
}
- result.rc, err = client.ListRecommendedRulesForWebAppResponder(resp)
+ result, err = client.ListRecommendedRulesForWebAppResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "ListRecommendedRulesForWebApp", resp, "Failure responding to request")
}
@@ -619,44 +418,17 @@ func (client RecommendationsClient) ListRecommendedRulesForWebAppSender(req *htt
// ListRecommendedRulesForWebAppResponder handles the response to the ListRecommendedRulesForWebApp request. The method always
// closes the http.Response Body.
-func (client RecommendationsClient) ListRecommendedRulesForWebAppResponder(resp *http.Response) (result RecommendationCollection, err error) {
+func (client RecommendationsClient) ListRecommendedRulesForWebAppResponder(resp *http.Response) (result ListRecommendation, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
azure.WithErrorUnlessStatusCode(http.StatusOK),
- autorest.ByUnmarshallingJSON(&result),
+ autorest.ByUnmarshallingJSON(&result.Value),
autorest.ByClosing())
result.Response = autorest.Response{Response: resp}
return
}
-// listRecommendedRulesForWebAppNextResults retrieves the next set of results, if any.
-func (client RecommendationsClient) listRecommendedRulesForWebAppNextResults(lastResults RecommendationCollection) (result RecommendationCollection, err error) {
- req, err := lastResults.recommendationCollectionPreparer()
- if err != nil {
- return result, autorest.NewErrorWithError(err, "web.RecommendationsClient", "listRecommendedRulesForWebAppNextResults", nil, "Failure preparing next results request")
- }
- if req == nil {
- return
- }
- resp, err := client.ListRecommendedRulesForWebAppSender(req)
- if err != nil {
- result.Response = autorest.Response{Response: resp}
- return result, autorest.NewErrorWithError(err, "web.RecommendationsClient", "listRecommendedRulesForWebAppNextResults", resp, "Failure sending next results request")
- }
- result, err = client.ListRecommendedRulesForWebAppResponder(resp)
- if err != nil {
- err = autorest.NewErrorWithError(err, "web.RecommendationsClient", "listRecommendedRulesForWebAppNextResults", resp, "Failure responding to next results request")
- }
- return
-}
-
-// ListRecommendedRulesForWebAppComplete enumerates all values, automatically crossing page boundaries as required.
-func (client RecommendationsClient) ListRecommendedRulesForWebAppComplete(ctx context.Context, resourceGroupName string, siteName string, featured *bool, filter string) (result RecommendationCollectionIterator, err error) {
- result.page, err = client.ListRecommendedRulesForWebApp(ctx, resourceGroupName, siteName, featured, filter)
- return
-}
-
// ResetAllFilters reset all recommendation opt-out settings for a subscription.
func (client RecommendationsClient) ResetAllFilters(ctx context.Context) (result autorest.Response, err error) {
req, err := client.ResetAllFiltersPreparer(ctx)
diff --git a/services/web/mgmt/2016-09-01/web/resourcehealthmetadata.go b/services/web/mgmt/2016-09-01/web/resourcehealthmetadata.go
new file mode 100644
index 000000000000..c930970814da
--- /dev/null
+++ b/services/web/mgmt/2016-09-01/web/resourcehealthmetadata.go
@@ -0,0 +1,588 @@
+package web
+
+// Copyright (c) Microsoft and contributors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+ "context"
+ "github.com/Azure/go-autorest/autorest"
+ "github.com/Azure/go-autorest/autorest/azure"
+ "github.com/Azure/go-autorest/autorest/validation"
+ "net/http"
+)
+
+// ResourceHealthMetadataClient is the webSite Management Client
+type ResourceHealthMetadataClient struct {
+ BaseClient
+}
+
+// NewResourceHealthMetadataClient creates an instance of the ResourceHealthMetadataClient client.
+func NewResourceHealthMetadataClient(subscriptionID string) ResourceHealthMetadataClient {
+ return NewResourceHealthMetadataClientWithBaseURI(DefaultBaseURI, subscriptionID)
+}
+
+// NewResourceHealthMetadataClientWithBaseURI creates an instance of the ResourceHealthMetadataClient client.
+func NewResourceHealthMetadataClientWithBaseURI(baseURI string, subscriptionID string) ResourceHealthMetadataClient {
+ return ResourceHealthMetadataClient{NewWithBaseURI(baseURI, subscriptionID)}
+}
+
+// GetBySite gets the category of ResourceHealthMetadata to use for the given site
+//
+// resourceGroupName is name of the resource group to which the resource belongs. name is name of web app
+func (client ResourceHealthMetadataClient) GetBySite(ctx context.Context, resourceGroupName string, name string) (result ResourceHealthMetadata, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("web.ResourceHealthMetadataClient", "GetBySite", err.Error())
+ }
+
+ req, err := client.GetBySitePreparer(ctx, resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "GetBySite", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetBySiteSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "GetBySite", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetBySiteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "GetBySite", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetBySitePreparer prepares the GetBySite request.
+func (client ResourceHealthMetadataClient) GetBySitePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/resourceHealthMetadata/default", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetBySiteSender sends the GetBySite request. The method will close the
+// http.Response Body if it receives an error.
+func (client ResourceHealthMetadataClient) GetBySiteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetBySiteResponder handles the response to the GetBySite request. The method always
+// closes the http.Response Body.
+func (client ResourceHealthMetadataClient) GetBySiteResponder(resp *http.Response) (result ResourceHealthMetadata, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// GetBySiteSlot gets the category of ResourceHealthMetadata to use for the given site
+//
+// resourceGroupName is name of the resource group to which the resource belongs. name is name of web app slot is
+// name of web app slot. If not specified then will default to production slot.
+func (client ResourceHealthMetadataClient) GetBySiteSlot(ctx context.Context, resourceGroupName string, name string, slot string) (result ResourceHealthMetadata, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("web.ResourceHealthMetadataClient", "GetBySiteSlot", err.Error())
+ }
+
+ req, err := client.GetBySiteSlotPreparer(ctx, resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "GetBySiteSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.GetBySiteSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "GetBySiteSlot", resp, "Failure sending request")
+ return
+ }
+
+ result, err = client.GetBySiteSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "GetBySiteSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// GetBySiteSlotPreparer prepares the GetBySiteSlot request.
+func (client ResourceHealthMetadataClient) GetBySiteSlotPreparer(ctx context.Context, resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/resourceHealthMetadata/default", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// GetBySiteSlotSender sends the GetBySiteSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client ResourceHealthMetadataClient) GetBySiteSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// GetBySiteSlotResponder handles the response to the GetBySiteSlot request. The method always
+// closes the http.Response Body.
+func (client ResourceHealthMetadataClient) GetBySiteSlotResponder(resp *http.Response) (result ResourceHealthMetadata, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// List list all ResourceHealthMetadata for all sites in the subscription.
+func (client ResourceHealthMetadataClient) List(ctx context.Context) (result ResourceHealthMetadataCollectionPage, err error) {
+ result.fn = client.listNextResults
+ req, err := client.ListPreparer(ctx)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "List", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.rhmc.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "List", resp, "Failure sending request")
+ return
+ }
+
+ result.rhmc, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "List", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListPreparer prepares the List request.
+func (client ResourceHealthMetadataClient) ListPreparer(ctx context.Context) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Web/resourceHealthMetadata", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListSender sends the List request. The method will close the
+// http.Response Body if it receives an error.
+func (client ResourceHealthMetadataClient) ListSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListResponder handles the response to the List request. The method always
+// closes the http.Response Body.
+func (client ResourceHealthMetadataClient) ListResponder(resp *http.Response) (result ResourceHealthMetadataCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listNextResults retrieves the next set of results, if any.
+func (client ResourceHealthMetadataClient) listNextResults(lastResults ResourceHealthMetadataCollection) (result ResourceHealthMetadataCollection, err error) {
+ req, err := lastResults.resourceHealthMetadataCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ResourceHealthMetadataClient) ListComplete(ctx context.Context) (result ResourceHealthMetadataCollectionIterator, err error) {
+ result.page, err = client.List(ctx)
+ return
+}
+
+// ListByResourceGroup list all ResourceHealthMetadata for all sites in the resource group in the subscription.
+//
+// resourceGroupName is name of the resource group to which the resource belongs.
+func (client ResourceHealthMetadataClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ResourceHealthMetadataCollectionPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("web.ResourceHealthMetadataClient", "ListByResourceGroup", err.Error())
+ }
+
+ result.fn = client.listByResourceGroupNextResults
+ req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListByResourceGroup", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.rhmc.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListByResourceGroup", resp, "Failure sending request")
+ return
+ }
+
+ result.rhmc, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListByResourceGroup", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
+func (client ResourceHealthMetadataClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/resourceHealthMetadata", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
+// http.Response Body if it receives an error.
+func (client ResourceHealthMetadataClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
+// closes the http.Response Body.
+func (client ResourceHealthMetadataClient) ListByResourceGroupResponder(resp *http.Response) (result ResourceHealthMetadataCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listByResourceGroupNextResults retrieves the next set of results, if any.
+func (client ResourceHealthMetadataClient) listByResourceGroupNextResults(lastResults ResourceHealthMetadataCollection) (result ResourceHealthMetadataCollection, err error) {
+ req, err := lastResults.resourceHealthMetadataCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListByResourceGroupSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListByResourceGroupResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ResourceHealthMetadataClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ResourceHealthMetadataCollectionIterator, err error) {
+ result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
+ return
+}
+
+// ListBySite gets the category of ResourceHealthMetadata to use for the given site as a collection
+//
+// resourceGroupName is name of the resource group to which the resource belongs. name is name of web app.
+func (client ResourceHealthMetadataClient) ListBySite(ctx context.Context, resourceGroupName string, name string) (result ResourceHealthMetadataCollectionPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("web.ResourceHealthMetadataClient", "ListBySite", err.Error())
+ }
+
+ result.fn = client.listBySiteNextResults
+ req, err := client.ListBySitePreparer(ctx, resourceGroupName, name)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListBySite", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListBySiteSender(req)
+ if err != nil {
+ result.rhmc.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListBySite", resp, "Failure sending request")
+ return
+ }
+
+ result.rhmc, err = client.ListBySiteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListBySite", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListBySitePreparer prepares the ListBySite request.
+func (client ResourceHealthMetadataClient) ListBySitePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/resourceHealthMetadata", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListBySiteSender sends the ListBySite request. The method will close the
+// http.Response Body if it receives an error.
+func (client ResourceHealthMetadataClient) ListBySiteSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListBySiteResponder handles the response to the ListBySite request. The method always
+// closes the http.Response Body.
+func (client ResourceHealthMetadataClient) ListBySiteResponder(resp *http.Response) (result ResourceHealthMetadataCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listBySiteNextResults retrieves the next set of results, if any.
+func (client ResourceHealthMetadataClient) listBySiteNextResults(lastResults ResourceHealthMetadataCollection) (result ResourceHealthMetadataCollection, err error) {
+ req, err := lastResults.resourceHealthMetadataCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listBySiteNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListBySiteSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listBySiteNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListBySiteResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listBySiteNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListBySiteComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ResourceHealthMetadataClient) ListBySiteComplete(ctx context.Context, resourceGroupName string, name string) (result ResourceHealthMetadataCollectionIterator, err error) {
+ result.page, err = client.ListBySite(ctx, resourceGroupName, name)
+ return
+}
+
+// ListBySiteSlot gets the category of ResourceHealthMetadata to use for the given site as a collection
+//
+// resourceGroupName is name of the resource group to which the resource belongs. name is name of web app. slot is
+// name of web app slot. If not specified then will default to production slot.
+func (client ResourceHealthMetadataClient) ListBySiteSlot(ctx context.Context, resourceGroupName string, name string, slot string) (result ResourceHealthMetadataCollectionPage, err error) {
+ if err := validation.Validate([]validation.Validation{
+ {TargetValue: resourceGroupName,
+ Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
+ {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+[^\.]$`, Chain: nil}}}}); err != nil {
+ return result, validation.NewError("web.ResourceHealthMetadataClient", "ListBySiteSlot", err.Error())
+ }
+
+ result.fn = client.listBySiteSlotNextResults
+ req, err := client.ListBySiteSlotPreparer(ctx, resourceGroupName, name, slot)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListBySiteSlot", nil, "Failure preparing request")
+ return
+ }
+
+ resp, err := client.ListBySiteSlotSender(req)
+ if err != nil {
+ result.rhmc.Response = autorest.Response{Response: resp}
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListBySiteSlot", resp, "Failure sending request")
+ return
+ }
+
+ result.rhmc, err = client.ListBySiteSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "ListBySiteSlot", resp, "Failure responding to request")
+ }
+
+ return
+}
+
+// ListBySiteSlotPreparer prepares the ListBySiteSlot request.
+func (client ResourceHealthMetadataClient) ListBySiteSlotPreparer(ctx context.Context, resourceGroupName string, name string, slot string) (*http.Request, error) {
+ pathParameters := map[string]interface{}{
+ "name": autorest.Encode("path", name),
+ "resourceGroupName": autorest.Encode("path", resourceGroupName),
+ "slot": autorest.Encode("path", slot),
+ "subscriptionId": autorest.Encode("path", client.SubscriptionID),
+ }
+
+ const APIVersion = "2016-03-01"
+ queryParameters := map[string]interface{}{
+ "api-version": APIVersion,
+ }
+
+ preparer := autorest.CreatePreparer(
+ autorest.AsGet(),
+ autorest.WithBaseURL(client.BaseURI),
+ autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/sites/{name}/slots/{slot}/resourceHealthMetadata", pathParameters),
+ autorest.WithQueryParameters(queryParameters))
+ return preparer.Prepare((&http.Request{}).WithContext(ctx))
+}
+
+// ListBySiteSlotSender sends the ListBySiteSlot request. The method will close the
+// http.Response Body if it receives an error.
+func (client ResourceHealthMetadataClient) ListBySiteSlotSender(req *http.Request) (*http.Response, error) {
+ return autorest.SendWithSender(client, req,
+ azure.DoRetryWithRegistration(client.Client))
+}
+
+// ListBySiteSlotResponder handles the response to the ListBySiteSlot request. The method always
+// closes the http.Response Body.
+func (client ResourceHealthMetadataClient) ListBySiteSlotResponder(resp *http.Response) (result ResourceHealthMetadataCollection, err error) {
+ err = autorest.Respond(
+ resp,
+ client.ByInspecting(),
+ azure.WithErrorUnlessStatusCode(http.StatusOK),
+ autorest.ByUnmarshallingJSON(&result),
+ autorest.ByClosing())
+ result.Response = autorest.Response{Response: resp}
+ return
+}
+
+// listBySiteSlotNextResults retrieves the next set of results, if any.
+func (client ResourceHealthMetadataClient) listBySiteSlotNextResults(lastResults ResourceHealthMetadataCollection) (result ResourceHealthMetadataCollection, err error) {
+ req, err := lastResults.resourceHealthMetadataCollectionPreparer()
+ if err != nil {
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listBySiteSlotNextResults", nil, "Failure preparing next results request")
+ }
+ if req == nil {
+ return
+ }
+ resp, err := client.ListBySiteSlotSender(req)
+ if err != nil {
+ result.Response = autorest.Response{Response: resp}
+ return result, autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listBySiteSlotNextResults", resp, "Failure sending next results request")
+ }
+ result, err = client.ListBySiteSlotResponder(resp)
+ if err != nil {
+ err = autorest.NewErrorWithError(err, "web.ResourceHealthMetadataClient", "listBySiteSlotNextResults", resp, "Failure responding to next results request")
+ }
+ return
+}
+
+// ListBySiteSlotComplete enumerates all values, automatically crossing page boundaries as required.
+func (client ResourceHealthMetadataClient) ListBySiteSlotComplete(ctx context.Context, resourceGroupName string, name string, slot string) (result ResourceHealthMetadataCollectionIterator, err error) {
+ result.page, err = client.ListBySiteSlot(ctx, resourceGroupName, name, slot)
+ return
+}