managementlocks.go

Documentation: github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2015-01-01/locks

     1  package locks
     2  
     3  // Copyright (c) Microsoft Corporation. All rights reserved.
     4  // Licensed under the MIT License. See License.txt in the project root for license information.
     5  //
     6  // Code generated by Microsoft (R) AutoRest Code Generator.
     7  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
     8  
     9  import (
    10  	"context"
    11  	"github.com/Azure/go-autorest/autorest"
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	"github.com/Azure/go-autorest/autorest/validation"
    14  	"github.com/Azure/go-autorest/tracing"
    15  	"net/http"
    16  )
    17  
    18  // ManagementLocksClient is the client for the ManagementLocks methods of the Locks service.
    19  type ManagementLocksClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewManagementLocksClient creates an instance of the ManagementLocksClient client.
    24  func NewManagementLocksClient(subscriptionID string) ManagementLocksClient {
    25  	return NewManagementLocksClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewManagementLocksClientWithBaseURI creates an instance of the ManagementLocksClient client using a custom endpoint.
    29  // Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    30  func NewManagementLocksClientWithBaseURI(baseURI string, subscriptionID string) ManagementLocksClient {
    31  	return ManagementLocksClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CreateOrUpdateAtResourceGroupLevel create or update a management lock at the resource group level.
    35  // Parameters:
    36  // resourceGroupName - the resource group name.
    37  // lockName - the lock name.
    38  // parameters - the management lock parameters.
    39  func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevel(ctx context.Context, resourceGroupName string, lockName string, parameters ManagementLockObject) (result ManagementLockObject, err error) {
    40  	if tracing.IsEnabled() {
    41  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.CreateOrUpdateAtResourceGroupLevel")
    42  		defer func() {
    43  			sc := -1
    44  			if result.Response.Response != nil {
    45  				sc = result.Response.Response.StatusCode
    46  			}
    47  			tracing.EndSpan(ctx, sc, err)
    48  		}()
    49  	}
    50  	if err := validation.Validate([]validation.Validation{
    51  		{TargetValue: resourceGroupName,
    52  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
    53  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
    54  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\p{L}\._\(\)\w]+$`, Chain: nil}}}}); err != nil {
    55  		return result, validation.NewError("locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel", err.Error())
    56  	}
    57  
    58  	req, err := client.CreateOrUpdateAtResourceGroupLevelPreparer(ctx, resourceGroupName, lockName, parameters)
    59  	if err != nil {
    60  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel", nil, "Failure preparing request")
    61  		return
    62  	}
    63  
    64  	resp, err := client.CreateOrUpdateAtResourceGroupLevelSender(req)
    65  	if err != nil {
    66  		result.Response = autorest.Response{Response: resp}
    67  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel", resp, "Failure sending request")
    68  		return
    69  	}
    70  
    71  	result, err = client.CreateOrUpdateAtResourceGroupLevelResponder(resp)
    72  	if err != nil {
    73  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceGroupLevel", resp, "Failure responding to request")
    74  		return
    75  	}
    76  
    77  	return
    78  }
    79  
    80  // CreateOrUpdateAtResourceGroupLevelPreparer prepares the CreateOrUpdateAtResourceGroupLevel request.
    81  func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelPreparer(ctx context.Context, resourceGroupName string, lockName string, parameters ManagementLockObject) (*http.Request, error) {
    82  	pathParameters := map[string]interface{}{
    83  		"lockName":          autorest.Encode("path", lockName),
    84  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    85  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    86  	}
    87  
    88  	const APIVersion = "2015-01-01"
    89  	queryParameters := map[string]interface{}{
    90  		"api-version": APIVersion,
    91  	}
    92  
    93  	parameters.ID = nil
    94  	parameters.Type = nil
    95  	preparer := autorest.CreatePreparer(
    96  		autorest.AsContentType("application/json; charset=utf-8"),
    97  		autorest.AsPut(),
    98  		autorest.WithBaseURL(client.BaseURI),
    99  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   100  		autorest.WithJSON(parameters),
   101  		autorest.WithQueryParameters(queryParameters))
   102  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   103  }
   104  
   105  // CreateOrUpdateAtResourceGroupLevelSender sends the CreateOrUpdateAtResourceGroupLevel request. The method will close the
   106  // http.Response Body if it receives an error.
   107  func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) {
   108  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   109  }
   110  
   111  // CreateOrUpdateAtResourceGroupLevelResponder handles the response to the CreateOrUpdateAtResourceGroupLevel request. The method always
   112  // closes the http.Response Body.
   113  func (client ManagementLocksClient) CreateOrUpdateAtResourceGroupLevelResponder(resp *http.Response) (result ManagementLockObject, err error) {
   114  	err = autorest.Respond(
   115  		resp,
   116  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   117  		autorest.ByUnmarshallingJSON(&result),
   118  		autorest.ByClosing())
   119  	result.Response = autorest.Response{Response: resp}
   120  	return
   121  }
   122  
   123  // CreateOrUpdateAtResourceLevel create or update a management lock at the resource level or any level below resource.
   124  // Parameters:
   125  // resourceGroupName - the name of the resource group.
   126  // resourceProviderNamespace - resource identity.
   127  // parentResourcePath - resource identity.
   128  // resourceType - resource identity.
   129  // resourceName - resource identity.
   130  // lockName - the name of lock.
   131  // parameters - create or update management lock parameters.
   132  func (client ManagementLocksClient) CreateOrUpdateAtResourceLevel(ctx context.Context, resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string, parameters ManagementLockObject) (result ManagementLockObject, err error) {
   133  	if tracing.IsEnabled() {
   134  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.CreateOrUpdateAtResourceLevel")
   135  		defer func() {
   136  			sc := -1
   137  			if result.Response.Response != nil {
   138  				sc = result.Response.Response.StatusCode
   139  			}
   140  			tracing.EndSpan(ctx, sc, err)
   141  		}()
   142  	}
   143  	if err := validation.Validate([]validation.Validation{
   144  		{TargetValue: resourceGroupName,
   145  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   146  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   147  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\p{L}\._\(\)\w]+$`, Chain: nil}}}}); err != nil {
   148  		return result, validation.NewError("locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel", err.Error())
   149  	}
   150  
   151  	req, err := client.CreateOrUpdateAtResourceLevelPreparer(ctx, resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, lockName, parameters)
   152  	if err != nil {
   153  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel", nil, "Failure preparing request")
   154  		return
   155  	}
   156  
   157  	resp, err := client.CreateOrUpdateAtResourceLevelSender(req)
   158  	if err != nil {
   159  		result.Response = autorest.Response{Response: resp}
   160  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel", resp, "Failure sending request")
   161  		return
   162  	}
   163  
   164  	result, err = client.CreateOrUpdateAtResourceLevelResponder(resp)
   165  	if err != nil {
   166  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtResourceLevel", resp, "Failure responding to request")
   167  		return
   168  	}
   169  
   170  	return
   171  }
   172  
   173  // CreateOrUpdateAtResourceLevelPreparer prepares the CreateOrUpdateAtResourceLevel request.
   174  func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelPreparer(ctx context.Context, resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string, parameters ManagementLockObject) (*http.Request, error) {
   175  	pathParameters := map[string]interface{}{
   176  		"lockName":                  autorest.Encode("path", lockName),
   177  		"parentResourcePath":        parentResourcePath,
   178  		"resourceGroupName":         autorest.Encode("path", resourceGroupName),
   179  		"resourceName":              autorest.Encode("path", resourceName),
   180  		"resourceProviderNamespace": autorest.Encode("path", resourceProviderNamespace),
   181  		"resourceType":              resourceType,
   182  		"subscriptionId":            autorest.Encode("path", client.SubscriptionID),
   183  	}
   184  
   185  	const APIVersion = "2015-01-01"
   186  	queryParameters := map[string]interface{}{
   187  		"api-version": APIVersion,
   188  	}
   189  
   190  	parameters.ID = nil
   191  	parameters.Type = nil
   192  	preparer := autorest.CreatePreparer(
   193  		autorest.AsContentType("application/json; charset=utf-8"),
   194  		autorest.AsPut(),
   195  		autorest.WithBaseURL(client.BaseURI),
   196  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   197  		autorest.WithJSON(parameters),
   198  		autorest.WithQueryParameters(queryParameters))
   199  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   200  }
   201  
   202  // CreateOrUpdateAtResourceLevelSender sends the CreateOrUpdateAtResourceLevel request. The method will close the
   203  // http.Response Body if it receives an error.
   204  func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelSender(req *http.Request) (*http.Response, error) {
   205  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   206  }
   207  
   208  // CreateOrUpdateAtResourceLevelResponder handles the response to the CreateOrUpdateAtResourceLevel request. The method always
   209  // closes the http.Response Body.
   210  func (client ManagementLocksClient) CreateOrUpdateAtResourceLevelResponder(resp *http.Response) (result ManagementLockObject, err error) {
   211  	err = autorest.Respond(
   212  		resp,
   213  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   214  		autorest.ByUnmarshallingJSON(&result),
   215  		autorest.ByClosing())
   216  	result.Response = autorest.Response{Response: resp}
   217  	return
   218  }
   219  
   220  // CreateOrUpdateAtSubscriptionLevel create or update a management lock at the subscription level.
   221  // Parameters:
   222  // lockName - the name of lock.
   223  // parameters - the management lock parameters.
   224  func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevel(ctx context.Context, lockName string, parameters ManagementLockObject) (result ManagementLockObject, err error) {
   225  	if tracing.IsEnabled() {
   226  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.CreateOrUpdateAtSubscriptionLevel")
   227  		defer func() {
   228  			sc := -1
   229  			if result.Response.Response != nil {
   230  				sc = result.Response.Response.StatusCode
   231  			}
   232  			tracing.EndSpan(ctx, sc, err)
   233  		}()
   234  	}
   235  	req, err := client.CreateOrUpdateAtSubscriptionLevelPreparer(ctx, lockName, parameters)
   236  	if err != nil {
   237  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtSubscriptionLevel", nil, "Failure preparing request")
   238  		return
   239  	}
   240  
   241  	resp, err := client.CreateOrUpdateAtSubscriptionLevelSender(req)
   242  	if err != nil {
   243  		result.Response = autorest.Response{Response: resp}
   244  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtSubscriptionLevel", resp, "Failure sending request")
   245  		return
   246  	}
   247  
   248  	result, err = client.CreateOrUpdateAtSubscriptionLevelResponder(resp)
   249  	if err != nil {
   250  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "CreateOrUpdateAtSubscriptionLevel", resp, "Failure responding to request")
   251  		return
   252  	}
   253  
   254  	return
   255  }
   256  
   257  // CreateOrUpdateAtSubscriptionLevelPreparer prepares the CreateOrUpdateAtSubscriptionLevel request.
   258  func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelPreparer(ctx context.Context, lockName string, parameters ManagementLockObject) (*http.Request, error) {
   259  	pathParameters := map[string]interface{}{
   260  		"lockName":       autorest.Encode("path", lockName),
   261  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   262  	}
   263  
   264  	const APIVersion = "2015-01-01"
   265  	queryParameters := map[string]interface{}{
   266  		"api-version": APIVersion,
   267  	}
   268  
   269  	parameters.ID = nil
   270  	parameters.Type = nil
   271  	preparer := autorest.CreatePreparer(
   272  		autorest.AsContentType("application/json; charset=utf-8"),
   273  		autorest.AsPut(),
   274  		autorest.WithBaseURL(client.BaseURI),
   275  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   276  		autorest.WithJSON(parameters),
   277  		autorest.WithQueryParameters(queryParameters))
   278  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   279  }
   280  
   281  // CreateOrUpdateAtSubscriptionLevelSender sends the CreateOrUpdateAtSubscriptionLevel request. The method will close the
   282  // http.Response Body if it receives an error.
   283  func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) {
   284  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   285  }
   286  
   287  // CreateOrUpdateAtSubscriptionLevelResponder handles the response to the CreateOrUpdateAtSubscriptionLevel request. The method always
   288  // closes the http.Response Body.
   289  func (client ManagementLocksClient) CreateOrUpdateAtSubscriptionLevelResponder(resp *http.Response) (result ManagementLockObject, err error) {
   290  	err = autorest.Respond(
   291  		resp,
   292  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   293  		autorest.ByUnmarshallingJSON(&result),
   294  		autorest.ByClosing())
   295  	result.Response = autorest.Response{Response: resp}
   296  	return
   297  }
   298  
   299  // DeleteAtResourceGroupLevel deletes the management lock of a resource group.
   300  // Parameters:
   301  // resourceGroupName - the resource group name.
   302  // lockName - the name of lock.
   303  func (client ManagementLocksClient) DeleteAtResourceGroupLevel(ctx context.Context, resourceGroupName string, lockName string) (result autorest.Response, err error) {
   304  	if tracing.IsEnabled() {
   305  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.DeleteAtResourceGroupLevel")
   306  		defer func() {
   307  			sc := -1
   308  			if result.Response != nil {
   309  				sc = result.Response.StatusCode
   310  			}
   311  			tracing.EndSpan(ctx, sc, err)
   312  		}()
   313  	}
   314  	if err := validation.Validate([]validation.Validation{
   315  		{TargetValue: resourceGroupName,
   316  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   317  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   318  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\p{L}\._\(\)\w]+$`, Chain: nil}}}}); err != nil {
   319  		return result, validation.NewError("locks.ManagementLocksClient", "DeleteAtResourceGroupLevel", err.Error())
   320  	}
   321  
   322  	req, err := client.DeleteAtResourceGroupLevelPreparer(ctx, resourceGroupName, lockName)
   323  	if err != nil {
   324  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceGroupLevel", nil, "Failure preparing request")
   325  		return
   326  	}
   327  
   328  	resp, err := client.DeleteAtResourceGroupLevelSender(req)
   329  	if err != nil {
   330  		result.Response = resp
   331  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceGroupLevel", resp, "Failure sending request")
   332  		return
   333  	}
   334  
   335  	result, err = client.DeleteAtResourceGroupLevelResponder(resp)
   336  	if err != nil {
   337  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceGroupLevel", resp, "Failure responding to request")
   338  		return
   339  	}
   340  
   341  	return
   342  }
   343  
   344  // DeleteAtResourceGroupLevelPreparer prepares the DeleteAtResourceGroupLevel request.
   345  func (client ManagementLocksClient) DeleteAtResourceGroupLevelPreparer(ctx context.Context, resourceGroupName string, lockName string) (*http.Request, error) {
   346  	pathParameters := map[string]interface{}{
   347  		"lockName":          autorest.Encode("path", lockName),
   348  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   349  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   350  	}
   351  
   352  	const APIVersion = "2015-01-01"
   353  	queryParameters := map[string]interface{}{
   354  		"api-version": APIVersion,
   355  	}
   356  
   357  	preparer := autorest.CreatePreparer(
   358  		autorest.AsDelete(),
   359  		autorest.WithBaseURL(client.BaseURI),
   360  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   361  		autorest.WithQueryParameters(queryParameters))
   362  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   363  }
   364  
   365  // DeleteAtResourceGroupLevelSender sends the DeleteAtResourceGroupLevel request. The method will close the
   366  // http.Response Body if it receives an error.
   367  func (client ManagementLocksClient) DeleteAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) {
   368  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   369  }
   370  
   371  // DeleteAtResourceGroupLevelResponder handles the response to the DeleteAtResourceGroupLevel request. The method always
   372  // closes the http.Response Body.
   373  func (client ManagementLocksClient) DeleteAtResourceGroupLevelResponder(resp *http.Response) (result autorest.Response, err error) {
   374  	err = autorest.Respond(
   375  		resp,
   376  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   377  		autorest.ByClosing())
   378  	result.Response = resp
   379  	return
   380  }
   381  
   382  // DeleteAtResourceLevel deletes the management lock of a resource or any level below resource.
   383  // Parameters:
   384  // resourceGroupName - the name of the resource group.
   385  // resourceProviderNamespace - resource identity.
   386  // parentResourcePath - resource identity.
   387  // resourceType - resource identity.
   388  // resourceName - resource identity.
   389  // lockName - the name of lock.
   390  func (client ManagementLocksClient) DeleteAtResourceLevel(ctx context.Context, resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string) (result autorest.Response, err error) {
   391  	if tracing.IsEnabled() {
   392  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.DeleteAtResourceLevel")
   393  		defer func() {
   394  			sc := -1
   395  			if result.Response != nil {
   396  				sc = result.Response.StatusCode
   397  			}
   398  			tracing.EndSpan(ctx, sc, err)
   399  		}()
   400  	}
   401  	if err := validation.Validate([]validation.Validation{
   402  		{TargetValue: resourceGroupName,
   403  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   404  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   405  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\p{L}\._\(\)\w]+$`, Chain: nil}}}}); err != nil {
   406  		return result, validation.NewError("locks.ManagementLocksClient", "DeleteAtResourceLevel", err.Error())
   407  	}
   408  
   409  	req, err := client.DeleteAtResourceLevelPreparer(ctx, resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, lockName)
   410  	if err != nil {
   411  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceLevel", nil, "Failure preparing request")
   412  		return
   413  	}
   414  
   415  	resp, err := client.DeleteAtResourceLevelSender(req)
   416  	if err != nil {
   417  		result.Response = resp
   418  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceLevel", resp, "Failure sending request")
   419  		return
   420  	}
   421  
   422  	result, err = client.DeleteAtResourceLevelResponder(resp)
   423  	if err != nil {
   424  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtResourceLevel", resp, "Failure responding to request")
   425  		return
   426  	}
   427  
   428  	return
   429  }
   430  
   431  // DeleteAtResourceLevelPreparer prepares the DeleteAtResourceLevel request.
   432  func (client ManagementLocksClient) DeleteAtResourceLevelPreparer(ctx context.Context, resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, lockName string) (*http.Request, error) {
   433  	pathParameters := map[string]interface{}{
   434  		"lockName":                  autorest.Encode("path", lockName),
   435  		"parentResourcePath":        parentResourcePath,
   436  		"resourceGroupName":         autorest.Encode("path", resourceGroupName),
   437  		"resourceName":              autorest.Encode("path", resourceName),
   438  		"resourceProviderNamespace": autorest.Encode("path", resourceProviderNamespace),
   439  		"resourceType":              resourceType,
   440  		"subscriptionId":            autorest.Encode("path", client.SubscriptionID),
   441  	}
   442  
   443  	const APIVersion = "2015-01-01"
   444  	queryParameters := map[string]interface{}{
   445  		"api-version": APIVersion,
   446  	}
   447  
   448  	preparer := autorest.CreatePreparer(
   449  		autorest.AsDelete(),
   450  		autorest.WithBaseURL(client.BaseURI),
   451  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   452  		autorest.WithQueryParameters(queryParameters))
   453  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   454  }
   455  
   456  // DeleteAtResourceLevelSender sends the DeleteAtResourceLevel request. The method will close the
   457  // http.Response Body if it receives an error.
   458  func (client ManagementLocksClient) DeleteAtResourceLevelSender(req *http.Request) (*http.Response, error) {
   459  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   460  }
   461  
   462  // DeleteAtResourceLevelResponder handles the response to the DeleteAtResourceLevel request. The method always
   463  // closes the http.Response Body.
   464  func (client ManagementLocksClient) DeleteAtResourceLevelResponder(resp *http.Response) (result autorest.Response, err error) {
   465  	err = autorest.Respond(
   466  		resp,
   467  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   468  		autorest.ByClosing())
   469  	result.Response = resp
   470  	return
   471  }
   472  
   473  // DeleteAtSubscriptionLevel deletes the management lock of a subscription.
   474  // Parameters:
   475  // lockName - the name of lock.
   476  func (client ManagementLocksClient) DeleteAtSubscriptionLevel(ctx context.Context, lockName string) (result autorest.Response, err error) {
   477  	if tracing.IsEnabled() {
   478  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.DeleteAtSubscriptionLevel")
   479  		defer func() {
   480  			sc := -1
   481  			if result.Response != nil {
   482  				sc = result.Response.StatusCode
   483  			}
   484  			tracing.EndSpan(ctx, sc, err)
   485  		}()
   486  	}
   487  	req, err := client.DeleteAtSubscriptionLevelPreparer(ctx, lockName)
   488  	if err != nil {
   489  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtSubscriptionLevel", nil, "Failure preparing request")
   490  		return
   491  	}
   492  
   493  	resp, err := client.DeleteAtSubscriptionLevelSender(req)
   494  	if err != nil {
   495  		result.Response = resp
   496  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtSubscriptionLevel", resp, "Failure sending request")
   497  		return
   498  	}
   499  
   500  	result, err = client.DeleteAtSubscriptionLevelResponder(resp)
   501  	if err != nil {
   502  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "DeleteAtSubscriptionLevel", resp, "Failure responding to request")
   503  		return
   504  	}
   505  
   506  	return
   507  }
   508  
   509  // DeleteAtSubscriptionLevelPreparer prepares the DeleteAtSubscriptionLevel request.
   510  func (client ManagementLocksClient) DeleteAtSubscriptionLevelPreparer(ctx context.Context, lockName string) (*http.Request, error) {
   511  	pathParameters := map[string]interface{}{
   512  		"lockName":       autorest.Encode("path", lockName),
   513  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   514  	}
   515  
   516  	const APIVersion = "2015-01-01"
   517  	queryParameters := map[string]interface{}{
   518  		"api-version": APIVersion,
   519  	}
   520  
   521  	preparer := autorest.CreatePreparer(
   522  		autorest.AsDelete(),
   523  		autorest.WithBaseURL(client.BaseURI),
   524  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   525  		autorest.WithQueryParameters(queryParameters))
   526  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   527  }
   528  
   529  // DeleteAtSubscriptionLevelSender sends the DeleteAtSubscriptionLevel request. The method will close the
   530  // http.Response Body if it receives an error.
   531  func (client ManagementLocksClient) DeleteAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) {
   532  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   533  }
   534  
   535  // DeleteAtSubscriptionLevelResponder handles the response to the DeleteAtSubscriptionLevel request. The method always
   536  // closes the http.Response Body.
   537  func (client ManagementLocksClient) DeleteAtSubscriptionLevelResponder(resp *http.Response) (result autorest.Response, err error) {
   538  	err = autorest.Respond(
   539  		resp,
   540  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   541  		autorest.ByClosing())
   542  	result.Response = resp
   543  	return
   544  }
   545  
   546  // Get gets the management lock of a scope.
   547  // Parameters:
   548  // lockName - name of the management lock.
   549  func (client ManagementLocksClient) Get(ctx context.Context, lockName string) (result ManagementLockObject, err error) {
   550  	if tracing.IsEnabled() {
   551  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.Get")
   552  		defer func() {
   553  			sc := -1
   554  			if result.Response.Response != nil {
   555  				sc = result.Response.Response.StatusCode
   556  			}
   557  			tracing.EndSpan(ctx, sc, err)
   558  		}()
   559  	}
   560  	req, err := client.GetPreparer(ctx, lockName)
   561  	if err != nil {
   562  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "Get", nil, "Failure preparing request")
   563  		return
   564  	}
   565  
   566  	resp, err := client.GetSender(req)
   567  	if err != nil {
   568  		result.Response = autorest.Response{Response: resp}
   569  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "Get", resp, "Failure sending request")
   570  		return
   571  	}
   572  
   573  	result, err = client.GetResponder(resp)
   574  	if err != nil {
   575  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "Get", resp, "Failure responding to request")
   576  		return
   577  	}
   578  
   579  	return
   580  }
   581  
   582  // GetPreparer prepares the Get request.
   583  func (client ManagementLocksClient) GetPreparer(ctx context.Context, lockName string) (*http.Request, error) {
   584  	pathParameters := map[string]interface{}{
   585  		"lockName":       autorest.Encode("path", lockName),
   586  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   587  	}
   588  
   589  	const APIVersion = "2015-01-01"
   590  	queryParameters := map[string]interface{}{
   591  		"api-version": APIVersion,
   592  	}
   593  
   594  	preparer := autorest.CreatePreparer(
   595  		autorest.AsGet(),
   596  		autorest.WithBaseURL(client.BaseURI),
   597  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   598  		autorest.WithQueryParameters(queryParameters))
   599  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   600  }
   601  
   602  // GetSender sends the Get request. The method will close the
   603  // http.Response Body if it receives an error.
   604  func (client ManagementLocksClient) GetSender(req *http.Request) (*http.Response, error) {
   605  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   606  }
   607  
   608  // GetResponder handles the response to the Get request. The method always
   609  // closes the http.Response Body.
   610  func (client ManagementLocksClient) GetResponder(resp *http.Response) (result ManagementLockObject, err error) {
   611  	err = autorest.Respond(
   612  		resp,
   613  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   614  		autorest.ByUnmarshallingJSON(&result),
   615  		autorest.ByClosing())
   616  	result.Response = autorest.Response{Response: resp}
   617  	return
   618  }
   619  
   620  // GetAtResourceGroupLevel gets a management lock at the resource group level.
   621  // Parameters:
   622  // resourceGroupName - the resource group name.
   623  // lockName - the lock name.
   624  func (client ManagementLocksClient) GetAtResourceGroupLevel(ctx context.Context, resourceGroupName string, lockName string) (result ManagementLockObject, err error) {
   625  	if tracing.IsEnabled() {
   626  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.GetAtResourceGroupLevel")
   627  		defer func() {
   628  			sc := -1
   629  			if result.Response.Response != nil {
   630  				sc = result.Response.Response.StatusCode
   631  			}
   632  			tracing.EndSpan(ctx, sc, err)
   633  		}()
   634  	}
   635  	if err := validation.Validate([]validation.Validation{
   636  		{TargetValue: resourceGroupName,
   637  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   638  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   639  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\p{L}\._\(\)\w]+$`, Chain: nil}}}}); err != nil {
   640  		return result, validation.NewError("locks.ManagementLocksClient", "GetAtResourceGroupLevel", err.Error())
   641  	}
   642  
   643  	req, err := client.GetAtResourceGroupLevelPreparer(ctx, resourceGroupName, lockName)
   644  	if err != nil {
   645  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceGroupLevel", nil, "Failure preparing request")
   646  		return
   647  	}
   648  
   649  	resp, err := client.GetAtResourceGroupLevelSender(req)
   650  	if err != nil {
   651  		result.Response = autorest.Response{Response: resp}
   652  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceGroupLevel", resp, "Failure sending request")
   653  		return
   654  	}
   655  
   656  	result, err = client.GetAtResourceGroupLevelResponder(resp)
   657  	if err != nil {
   658  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "GetAtResourceGroupLevel", resp, "Failure responding to request")
   659  		return
   660  	}
   661  
   662  	return
   663  }
   664  
   665  // GetAtResourceGroupLevelPreparer prepares the GetAtResourceGroupLevel request.
   666  func (client ManagementLocksClient) GetAtResourceGroupLevelPreparer(ctx context.Context, resourceGroupName string, lockName string) (*http.Request, error) {
   667  	pathParameters := map[string]interface{}{
   668  		"lockName":          autorest.Encode("path", lockName),
   669  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   670  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   671  	}
   672  
   673  	const APIVersion = "2015-01-01"
   674  	queryParameters := map[string]interface{}{
   675  		"api-version": APIVersion,
   676  	}
   677  
   678  	preparer := autorest.CreatePreparer(
   679  		autorest.AsGet(),
   680  		autorest.WithBaseURL(client.BaseURI),
   681  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks/{lockName}", pathParameters),
   682  		autorest.WithQueryParameters(queryParameters))
   683  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   684  }
   685  
   686  // GetAtResourceGroupLevelSender sends the GetAtResourceGroupLevel request. The method will close the
   687  // http.Response Body if it receives an error.
   688  func (client ManagementLocksClient) GetAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) {
   689  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   690  }
   691  
   692  // GetAtResourceGroupLevelResponder handles the response to the GetAtResourceGroupLevel request. The method always
   693  // closes the http.Response Body.
   694  func (client ManagementLocksClient) GetAtResourceGroupLevelResponder(resp *http.Response) (result ManagementLockObject, err error) {
   695  	err = autorest.Respond(
   696  		resp,
   697  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   698  		autorest.ByUnmarshallingJSON(&result),
   699  		autorest.ByClosing())
   700  	result.Response = autorest.Response{Response: resp}
   701  	return
   702  }
   703  
   704  // ListAtResourceGroupLevel gets all the management locks of a resource group.
   705  // Parameters:
   706  // resourceGroupName - resource group name.
   707  // filter - the filter to apply on the operation.
   708  func (client ManagementLocksClient) ListAtResourceGroupLevel(ctx context.Context, resourceGroupName string, filter string) (result ManagementLockListResultPage, err error) {
   709  	if tracing.IsEnabled() {
   710  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.ListAtResourceGroupLevel")
   711  		defer func() {
   712  			sc := -1
   713  			if result.mllr.Response.Response != nil {
   714  				sc = result.mllr.Response.Response.StatusCode
   715  			}
   716  			tracing.EndSpan(ctx, sc, err)
   717  		}()
   718  	}
   719  	if err := validation.Validate([]validation.Validation{
   720  		{TargetValue: resourceGroupName,
   721  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   722  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   723  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\p{L}\._\(\)\w]+$`, Chain: nil}}}}); err != nil {
   724  		return result, validation.NewError("locks.ManagementLocksClient", "ListAtResourceGroupLevel", err.Error())
   725  	}
   726  
   727  	result.fn = client.listAtResourceGroupLevelNextResults
   728  	req, err := client.ListAtResourceGroupLevelPreparer(ctx, resourceGroupName, filter)
   729  	if err != nil {
   730  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", nil, "Failure preparing request")
   731  		return
   732  	}
   733  
   734  	resp, err := client.ListAtResourceGroupLevelSender(req)
   735  	if err != nil {
   736  		result.mllr.Response = autorest.Response{Response: resp}
   737  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", resp, "Failure sending request")
   738  		return
   739  	}
   740  
   741  	result.mllr, err = client.ListAtResourceGroupLevelResponder(resp)
   742  	if err != nil {
   743  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceGroupLevel", resp, "Failure responding to request")
   744  		return
   745  	}
   746  	if result.mllr.hasNextLink() && result.mllr.IsEmpty() {
   747  		err = result.NextWithContext(ctx)
   748  		return
   749  	}
   750  
   751  	return
   752  }
   753  
   754  // ListAtResourceGroupLevelPreparer prepares the ListAtResourceGroupLevel request.
   755  func (client ManagementLocksClient) ListAtResourceGroupLevelPreparer(ctx context.Context, resourceGroupName string, filter string) (*http.Request, error) {
   756  	pathParameters := map[string]interface{}{
   757  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   758  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   759  	}
   760  
   761  	const APIVersion = "2015-01-01"
   762  	queryParameters := map[string]interface{}{
   763  		"api-version": APIVersion,
   764  	}
   765  	if len(filter) > 0 {
   766  		queryParameters["$filter"] = autorest.Encode("query", filter)
   767  	}
   768  
   769  	preparer := autorest.CreatePreparer(
   770  		autorest.AsGet(),
   771  		autorest.WithBaseURL(client.BaseURI),
   772  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Authorization/locks", pathParameters),
   773  		autorest.WithQueryParameters(queryParameters))
   774  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   775  }
   776  
   777  // ListAtResourceGroupLevelSender sends the ListAtResourceGroupLevel request. The method will close the
   778  // http.Response Body if it receives an error.
   779  func (client ManagementLocksClient) ListAtResourceGroupLevelSender(req *http.Request) (*http.Response, error) {
   780  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   781  }
   782  
   783  // ListAtResourceGroupLevelResponder handles the response to the ListAtResourceGroupLevel request. The method always
   784  // closes the http.Response Body.
   785  func (client ManagementLocksClient) ListAtResourceGroupLevelResponder(resp *http.Response) (result ManagementLockListResult, err error) {
   786  	err = autorest.Respond(
   787  		resp,
   788  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   789  		autorest.ByUnmarshallingJSON(&result),
   790  		autorest.ByClosing())
   791  	result.Response = autorest.Response{Response: resp}
   792  	return
   793  }
   794  
   795  // listAtResourceGroupLevelNextResults retrieves the next set of results, if any.
   796  func (client ManagementLocksClient) listAtResourceGroupLevelNextResults(ctx context.Context, lastResults ManagementLockListResult) (result ManagementLockListResult, err error) {
   797  	req, err := lastResults.managementLockListResultPreparer(ctx)
   798  	if err != nil {
   799  		return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtResourceGroupLevelNextResults", nil, "Failure preparing next results request")
   800  	}
   801  	if req == nil {
   802  		return
   803  	}
   804  	resp, err := client.ListAtResourceGroupLevelSender(req)
   805  	if err != nil {
   806  		result.Response = autorest.Response{Response: resp}
   807  		return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtResourceGroupLevelNextResults", resp, "Failure sending next results request")
   808  	}
   809  	result, err = client.ListAtResourceGroupLevelResponder(resp)
   810  	if err != nil {
   811  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtResourceGroupLevelNextResults", resp, "Failure responding to next results request")
   812  	}
   813  	return
   814  }
   815  
   816  // ListAtResourceGroupLevelComplete enumerates all values, automatically crossing page boundaries as required.
   817  func (client ManagementLocksClient) ListAtResourceGroupLevelComplete(ctx context.Context, resourceGroupName string, filter string) (result ManagementLockListResultIterator, err error) {
   818  	if tracing.IsEnabled() {
   819  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.ListAtResourceGroupLevel")
   820  		defer func() {
   821  			sc := -1
   822  			if result.Response().Response.Response != nil {
   823  				sc = result.page.Response().Response.Response.StatusCode
   824  			}
   825  			tracing.EndSpan(ctx, sc, err)
   826  		}()
   827  	}
   828  	result.page, err = client.ListAtResourceGroupLevel(ctx, resourceGroupName, filter)
   829  	return
   830  }
   831  
   832  // ListAtResourceLevel gets all the management locks of a resource or any level below resource.
   833  // Parameters:
   834  // resourceGroupName - the name of the resource group. The name is case insensitive.
   835  // resourceProviderNamespace - resource identity.
   836  // parentResourcePath - resource identity.
   837  // resourceType - resource identity.
   838  // resourceName - resource identity.
   839  // filter - the filter to apply on the operation.
   840  func (client ManagementLocksClient) ListAtResourceLevel(ctx context.Context, resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, filter string) (result ManagementLockListResultPage, err error) {
   841  	if tracing.IsEnabled() {
   842  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.ListAtResourceLevel")
   843  		defer func() {
   844  			sc := -1
   845  			if result.mllr.Response.Response != nil {
   846  				sc = result.mllr.Response.Response.StatusCode
   847  			}
   848  			tracing.EndSpan(ctx, sc, err)
   849  		}()
   850  	}
   851  	if err := validation.Validate([]validation.Validation{
   852  		{TargetValue: resourceGroupName,
   853  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   854  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   855  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\p{L}\._\(\)\w]+$`, Chain: nil}}}}); err != nil {
   856  		return result, validation.NewError("locks.ManagementLocksClient", "ListAtResourceLevel", err.Error())
   857  	}
   858  
   859  	result.fn = client.listAtResourceLevelNextResults
   860  	req, err := client.ListAtResourceLevelPreparer(ctx, resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, filter)
   861  	if err != nil {
   862  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", nil, "Failure preparing request")
   863  		return
   864  	}
   865  
   866  	resp, err := client.ListAtResourceLevelSender(req)
   867  	if err != nil {
   868  		result.mllr.Response = autorest.Response{Response: resp}
   869  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", resp, "Failure sending request")
   870  		return
   871  	}
   872  
   873  	result.mllr, err = client.ListAtResourceLevelResponder(resp)
   874  	if err != nil {
   875  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtResourceLevel", resp, "Failure responding to request")
   876  		return
   877  	}
   878  	if result.mllr.hasNextLink() && result.mllr.IsEmpty() {
   879  		err = result.NextWithContext(ctx)
   880  		return
   881  	}
   882  
   883  	return
   884  }
   885  
   886  // ListAtResourceLevelPreparer prepares the ListAtResourceLevel request.
   887  func (client ManagementLocksClient) ListAtResourceLevelPreparer(ctx context.Context, resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, filter string) (*http.Request, error) {
   888  	pathParameters := map[string]interface{}{
   889  		"parentResourcePath":        parentResourcePath,
   890  		"resourceGroupName":         autorest.Encode("path", resourceGroupName),
   891  		"resourceName":              autorest.Encode("path", resourceName),
   892  		"resourceProviderNamespace": autorest.Encode("path", resourceProviderNamespace),
   893  		"resourceType":              resourceType,
   894  		"subscriptionId":            autorest.Encode("path", client.SubscriptionID),
   895  	}
   896  
   897  	const APIVersion = "2015-01-01"
   898  	queryParameters := map[string]interface{}{
   899  		"api-version": APIVersion,
   900  	}
   901  	if len(filter) > 0 {
   902  		queryParameters["$filter"] = autorest.Encode("query", filter)
   903  	}
   904  
   905  	preparer := autorest.CreatePreparer(
   906  		autorest.AsGet(),
   907  		autorest.WithBaseURL(client.BaseURI),
   908  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{parentResourcePath}/{resourceType}/{resourceName}/providers/Microsoft.Authorization/locks", pathParameters),
   909  		autorest.WithQueryParameters(queryParameters))
   910  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   911  }
   912  
   913  // ListAtResourceLevelSender sends the ListAtResourceLevel request. The method will close the
   914  // http.Response Body if it receives an error.
   915  func (client ManagementLocksClient) ListAtResourceLevelSender(req *http.Request) (*http.Response, error) {
   916  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   917  }
   918  
   919  // ListAtResourceLevelResponder handles the response to the ListAtResourceLevel request. The method always
   920  // closes the http.Response Body.
   921  func (client ManagementLocksClient) ListAtResourceLevelResponder(resp *http.Response) (result ManagementLockListResult, err error) {
   922  	err = autorest.Respond(
   923  		resp,
   924  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   925  		autorest.ByUnmarshallingJSON(&result),
   926  		autorest.ByClosing())
   927  	result.Response = autorest.Response{Response: resp}
   928  	return
   929  }
   930  
   931  // listAtResourceLevelNextResults retrieves the next set of results, if any.
   932  func (client ManagementLocksClient) listAtResourceLevelNextResults(ctx context.Context, lastResults ManagementLockListResult) (result ManagementLockListResult, err error) {
   933  	req, err := lastResults.managementLockListResultPreparer(ctx)
   934  	if err != nil {
   935  		return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtResourceLevelNextResults", nil, "Failure preparing next results request")
   936  	}
   937  	if req == nil {
   938  		return
   939  	}
   940  	resp, err := client.ListAtResourceLevelSender(req)
   941  	if err != nil {
   942  		result.Response = autorest.Response{Response: resp}
   943  		return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtResourceLevelNextResults", resp, "Failure sending next results request")
   944  	}
   945  	result, err = client.ListAtResourceLevelResponder(resp)
   946  	if err != nil {
   947  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtResourceLevelNextResults", resp, "Failure responding to next results request")
   948  	}
   949  	return
   950  }
   951  
   952  // ListAtResourceLevelComplete enumerates all values, automatically crossing page boundaries as required.
   953  func (client ManagementLocksClient) ListAtResourceLevelComplete(ctx context.Context, resourceGroupName string, resourceProviderNamespace string, parentResourcePath string, resourceType string, resourceName string, filter string) (result ManagementLockListResultIterator, err error) {
   954  	if tracing.IsEnabled() {
   955  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.ListAtResourceLevel")
   956  		defer func() {
   957  			sc := -1
   958  			if result.Response().Response.Response != nil {
   959  				sc = result.page.Response().Response.Response.StatusCode
   960  			}
   961  			tracing.EndSpan(ctx, sc, err)
   962  		}()
   963  	}
   964  	result.page, err = client.ListAtResourceLevel(ctx, resourceGroupName, resourceProviderNamespace, parentResourcePath, resourceType, resourceName, filter)
   965  	return
   966  }
   967  
   968  // ListAtSubscriptionLevel gets all the management locks of a subscription.
   969  // Parameters:
   970  // filter - the filter to apply on the operation.
   971  func (client ManagementLocksClient) ListAtSubscriptionLevel(ctx context.Context, filter string) (result ManagementLockListResultPage, err error) {
   972  	if tracing.IsEnabled() {
   973  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.ListAtSubscriptionLevel")
   974  		defer func() {
   975  			sc := -1
   976  			if result.mllr.Response.Response != nil {
   977  				sc = result.mllr.Response.Response.StatusCode
   978  			}
   979  			tracing.EndSpan(ctx, sc, err)
   980  		}()
   981  	}
   982  	result.fn = client.listAtSubscriptionLevelNextResults
   983  	req, err := client.ListAtSubscriptionLevelPreparer(ctx, filter)
   984  	if err != nil {
   985  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", nil, "Failure preparing request")
   986  		return
   987  	}
   988  
   989  	resp, err := client.ListAtSubscriptionLevelSender(req)
   990  	if err != nil {
   991  		result.mllr.Response = autorest.Response{Response: resp}
   992  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", resp, "Failure sending request")
   993  		return
   994  	}
   995  
   996  	result.mllr, err = client.ListAtSubscriptionLevelResponder(resp)
   997  	if err != nil {
   998  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "ListAtSubscriptionLevel", resp, "Failure responding to request")
   999  		return
  1000  	}
  1001  	if result.mllr.hasNextLink() && result.mllr.IsEmpty() {
  1002  		err = result.NextWithContext(ctx)
  1003  		return
  1004  	}
  1005  
  1006  	return
  1007  }
  1008  
  1009  // ListAtSubscriptionLevelPreparer prepares the ListAtSubscriptionLevel request.
  1010  func (client ManagementLocksClient) ListAtSubscriptionLevelPreparer(ctx context.Context, filter string) (*http.Request, error) {
  1011  	pathParameters := map[string]interface{}{
  1012  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
  1013  	}
  1014  
  1015  	const APIVersion = "2015-01-01"
  1016  	queryParameters := map[string]interface{}{
  1017  		"api-version": APIVersion,
  1018  	}
  1019  	if len(filter) > 0 {
  1020  		queryParameters["$filter"] = autorest.Encode("query", filter)
  1021  	}
  1022  
  1023  	preparer := autorest.CreatePreparer(
  1024  		autorest.AsGet(),
  1025  		autorest.WithBaseURL(client.BaseURI),
  1026  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Authorization/locks", pathParameters),
  1027  		autorest.WithQueryParameters(queryParameters))
  1028  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1029  }
  1030  
  1031  // ListAtSubscriptionLevelSender sends the ListAtSubscriptionLevel request. The method will close the
  1032  // http.Response Body if it receives an error.
  1033  func (client ManagementLocksClient) ListAtSubscriptionLevelSender(req *http.Request) (*http.Response, error) {
  1034  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1035  }
  1036  
  1037  // ListAtSubscriptionLevelResponder handles the response to the ListAtSubscriptionLevel request. The method always
  1038  // closes the http.Response Body.
  1039  func (client ManagementLocksClient) ListAtSubscriptionLevelResponder(resp *http.Response) (result ManagementLockListResult, err error) {
  1040  	err = autorest.Respond(
  1041  		resp,
  1042  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1043  		autorest.ByUnmarshallingJSON(&result),
  1044  		autorest.ByClosing())
  1045  	result.Response = autorest.Response{Response: resp}
  1046  	return
  1047  }
  1048  
  1049  // listAtSubscriptionLevelNextResults retrieves the next set of results, if any.
  1050  func (client ManagementLocksClient) listAtSubscriptionLevelNextResults(ctx context.Context, lastResults ManagementLockListResult) (result ManagementLockListResult, err error) {
  1051  	req, err := lastResults.managementLockListResultPreparer(ctx)
  1052  	if err != nil {
  1053  		return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtSubscriptionLevelNextResults", nil, "Failure preparing next results request")
  1054  	}
  1055  	if req == nil {
  1056  		return
  1057  	}
  1058  	resp, err := client.ListAtSubscriptionLevelSender(req)
  1059  	if err != nil {
  1060  		result.Response = autorest.Response{Response: resp}
  1061  		return result, autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtSubscriptionLevelNextResults", resp, "Failure sending next results request")
  1062  	}
  1063  	result, err = client.ListAtSubscriptionLevelResponder(resp)
  1064  	if err != nil {
  1065  		err = autorest.NewErrorWithError(err, "locks.ManagementLocksClient", "listAtSubscriptionLevelNextResults", resp, "Failure responding to next results request")
  1066  	}
  1067  	return
  1068  }
  1069  
  1070  // ListAtSubscriptionLevelComplete enumerates all values, automatically crossing page boundaries as required.
  1071  func (client ManagementLocksClient) ListAtSubscriptionLevelComplete(ctx context.Context, filter string) (result ManagementLockListResultIterator, err error) {
  1072  	if tracing.IsEnabled() {
  1073  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagementLocksClient.ListAtSubscriptionLevel")
  1074  		defer func() {
  1075  			sc := -1
  1076  			if result.Response().Response.Response != nil {
  1077  				sc = result.page.Response().Response.Response.StatusCode
  1078  			}
  1079  			tracing.EndSpan(ctx, sc, err)
  1080  		}()
  1081  	}
  1082  	result.page, err = client.ListAtSubscriptionLevel(ctx, filter)
  1083  	return
  1084  }
  1085
View as plain text