Source file src/github.com/Azure/azure-sdk-for-go/services/provisioningservices/mgmt/2021-10-15/iothub/iotdpsresource.go

Documentation: github.com/Azure/azure-sdk-for-go/services/provisioningservices/mgmt/2021-10-15/iothub

     1  package iothub
     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  // IotDpsResourceClient is the API for using the Azure IoT Hub Device Provisioning Service features.
    19  type IotDpsResourceClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewIotDpsResourceClient creates an instance of the IotDpsResourceClient client.
    24  func NewIotDpsResourceClient(subscriptionID string) IotDpsResourceClient {
    25  	return NewIotDpsResourceClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewIotDpsResourceClientWithBaseURI creates an instance of the IotDpsResourceClient 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 NewIotDpsResourceClientWithBaseURI(baseURI string, subscriptionID string) IotDpsResourceClient {
    31  	return IotDpsResourceClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CheckProvisioningServiceNameAvailability check if a provisioning service name is available. This will validate if
    35  // the name is syntactically valid and if the name is usable
    36  // Parameters:
    37  // arguments - set the name parameter in the OperationInputs structure to the name of the provisioning service
    38  // to check.
    39  func (client IotDpsResourceClient) CheckProvisioningServiceNameAvailability(ctx context.Context, arguments OperationInputs) (result NameAvailabilityInfo, err error) {
    40  	if tracing.IsEnabled() {
    41  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.CheckProvisioningServiceNameAvailability")
    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: arguments,
    52  			Constraints: []validation.Constraint{{Target: "arguments.Name", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
    53  		return result, validation.NewError("iothub.IotDpsResourceClient", "CheckProvisioningServiceNameAvailability", err.Error())
    54  	}
    55  
    56  	req, err := client.CheckProvisioningServiceNameAvailabilityPreparer(ctx, arguments)
    57  	if err != nil {
    58  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "CheckProvisioningServiceNameAvailability", nil, "Failure preparing request")
    59  		return
    60  	}
    61  
    62  	resp, err := client.CheckProvisioningServiceNameAvailabilitySender(req)
    63  	if err != nil {
    64  		result.Response = autorest.Response{Response: resp}
    65  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "CheckProvisioningServiceNameAvailability", resp, "Failure sending request")
    66  		return
    67  	}
    68  
    69  	result, err = client.CheckProvisioningServiceNameAvailabilityResponder(resp)
    70  	if err != nil {
    71  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "CheckProvisioningServiceNameAvailability", resp, "Failure responding to request")
    72  		return
    73  	}
    74  
    75  	return
    76  }
    77  
    78  // CheckProvisioningServiceNameAvailabilityPreparer prepares the CheckProvisioningServiceNameAvailability request.
    79  func (client IotDpsResourceClient) CheckProvisioningServiceNameAvailabilityPreparer(ctx context.Context, arguments OperationInputs) (*http.Request, error) {
    80  	pathParameters := map[string]interface{}{
    81  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
    82  	}
    83  
    84  	const APIVersion = "2021-10-15"
    85  	queryParameters := map[string]interface{}{
    86  		"api-version": APIVersion,
    87  	}
    88  
    89  	preparer := autorest.CreatePreparer(
    90  		autorest.AsContentType("application/json; charset=utf-8"),
    91  		autorest.AsPost(),
    92  		autorest.WithBaseURL(client.BaseURI),
    93  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/checkProvisioningServiceNameAvailability", pathParameters),
    94  		autorest.WithJSON(arguments),
    95  		autorest.WithQueryParameters(queryParameters))
    96  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    97  }
    98  
    99  // CheckProvisioningServiceNameAvailabilitySender sends the CheckProvisioningServiceNameAvailability request. The method will close the
   100  // http.Response Body if it receives an error.
   101  func (client IotDpsResourceClient) CheckProvisioningServiceNameAvailabilitySender(req *http.Request) (*http.Response, error) {
   102  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   103  }
   104  
   105  // CheckProvisioningServiceNameAvailabilityResponder handles the response to the CheckProvisioningServiceNameAvailability request. The method always
   106  // closes the http.Response Body.
   107  func (client IotDpsResourceClient) CheckProvisioningServiceNameAvailabilityResponder(resp *http.Response) (result NameAvailabilityInfo, err error) {
   108  	err = autorest.Respond(
   109  		resp,
   110  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   111  		autorest.ByUnmarshallingJSON(&result),
   112  		autorest.ByClosing())
   113  	result.Response = autorest.Response{Response: resp}
   114  	return
   115  }
   116  
   117  // CreateOrUpdate create or update the metadata of the provisioning service. The usual pattern to modify a property is
   118  // to retrieve the provisioning service metadata and security metadata, and then combine them with the modified values
   119  // in a new body to update the provisioning service.
   120  // Parameters:
   121  // resourceGroupName - resource group identifier.
   122  // provisioningServiceName - name of provisioning service to create or update.
   123  // iotDpsDescription - description of the provisioning service to create or update.
   124  func (client IotDpsResourceClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, provisioningServiceName string, iotDpsDescription ProvisioningServiceDescription) (result IotDpsResourceCreateOrUpdateFuture, err error) {
   125  	if tracing.IsEnabled() {
   126  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.CreateOrUpdate")
   127  		defer func() {
   128  			sc := -1
   129  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   130  				sc = result.FutureAPI.Response().StatusCode
   131  			}
   132  			tracing.EndSpan(ctx, sc, err)
   133  		}()
   134  	}
   135  	if err := validation.Validate([]validation.Validation{
   136  		{TargetValue: iotDpsDescription,
   137  			Constraints: []validation.Constraint{{Target: "iotDpsDescription.Properties", Name: validation.Null, Rule: true, Chain: nil},
   138  				{Target: "iotDpsDescription.Sku", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   139  		return result, validation.NewError("iothub.IotDpsResourceClient", "CreateOrUpdate", err.Error())
   140  	}
   141  
   142  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, provisioningServiceName, iotDpsDescription)
   143  	if err != nil {
   144  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "CreateOrUpdate", nil, "Failure preparing request")
   145  		return
   146  	}
   147  
   148  	result, err = client.CreateOrUpdateSender(req)
   149  	if err != nil {
   150  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "CreateOrUpdate", result.Response(), "Failure sending request")
   151  		return
   152  	}
   153  
   154  	return
   155  }
   156  
   157  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   158  func (client IotDpsResourceClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, provisioningServiceName string, iotDpsDescription ProvisioningServiceDescription) (*http.Request, error) {
   159  	pathParameters := map[string]interface{}{
   160  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   161  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   162  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   163  	}
   164  
   165  	const APIVersion = "2021-10-15"
   166  	queryParameters := map[string]interface{}{
   167  		"api-version": APIVersion,
   168  	}
   169  
   170  	iotDpsDescription.SystemData = nil
   171  	preparer := autorest.CreatePreparer(
   172  		autorest.AsContentType("application/json; charset=utf-8"),
   173  		autorest.AsPut(),
   174  		autorest.WithBaseURL(client.BaseURI),
   175  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}", pathParameters),
   176  		autorest.WithJSON(iotDpsDescription),
   177  		autorest.WithQueryParameters(queryParameters))
   178  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   179  }
   180  
   181  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   182  // http.Response Body if it receives an error.
   183  func (client IotDpsResourceClient) CreateOrUpdateSender(req *http.Request) (future IotDpsResourceCreateOrUpdateFuture, err error) {
   184  	var resp *http.Response
   185  	future.FutureAPI = &azure.Future{}
   186  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   187  	if err != nil {
   188  		return
   189  	}
   190  	var azf azure.Future
   191  	azf, err = azure.NewFutureFromResponse(resp)
   192  	future.FutureAPI = &azf
   193  	future.Result = future.result
   194  	return
   195  }
   196  
   197  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   198  // closes the http.Response Body.
   199  func (client IotDpsResourceClient) CreateOrUpdateResponder(resp *http.Response) (result ProvisioningServiceDescription, err error) {
   200  	err = autorest.Respond(
   201  		resp,
   202  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   203  		autorest.ByUnmarshallingJSON(&result),
   204  		autorest.ByClosing())
   205  	result.Response = autorest.Response{Response: resp}
   206  	return
   207  }
   208  
   209  // CreateOrUpdatePrivateEndpointConnection create or update the status of a private endpoint connection with the
   210  // specified name
   211  // Parameters:
   212  // resourceGroupName - the name of the resource group that contains the provisioning service.
   213  // resourceName - the name of the provisioning service.
   214  // privateEndpointConnectionName - the name of the private endpoint connection
   215  // privateEndpointConnection - the private endpoint connection with updated properties
   216  func (client IotDpsResourceClient) CreateOrUpdatePrivateEndpointConnection(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, privateEndpointConnection PrivateEndpointConnection) (result IotDpsResourceCreateOrUpdatePrivateEndpointConnectionFuture, err error) {
   217  	if tracing.IsEnabled() {
   218  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.CreateOrUpdatePrivateEndpointConnection")
   219  		defer func() {
   220  			sc := -1
   221  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   222  				sc = result.FutureAPI.Response().StatusCode
   223  			}
   224  			tracing.EndSpan(ctx, sc, err)
   225  		}()
   226  	}
   227  	if err := validation.Validate([]validation.Validation{
   228  		{TargetValue: privateEndpointConnection,
   229  			Constraints: []validation.Constraint{{Target: "privateEndpointConnection.Properties", Name: validation.Null, Rule: true,
   230  				Chain: []validation.Constraint{{Target: "privateEndpointConnection.Properties.PrivateLinkServiceConnectionState", Name: validation.Null, Rule: true,
   231  					Chain: []validation.Constraint{{Target: "privateEndpointConnection.Properties.PrivateLinkServiceConnectionState.Description", Name: validation.Null, Rule: true, Chain: nil}}},
   232  				}}}}}); err != nil {
   233  		return result, validation.NewError("iothub.IotDpsResourceClient", "CreateOrUpdatePrivateEndpointConnection", err.Error())
   234  	}
   235  
   236  	req, err := client.CreateOrUpdatePrivateEndpointConnectionPreparer(ctx, resourceGroupName, resourceName, privateEndpointConnectionName, privateEndpointConnection)
   237  	if err != nil {
   238  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "CreateOrUpdatePrivateEndpointConnection", nil, "Failure preparing request")
   239  		return
   240  	}
   241  
   242  	result, err = client.CreateOrUpdatePrivateEndpointConnectionSender(req)
   243  	if err != nil {
   244  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "CreateOrUpdatePrivateEndpointConnection", result.Response(), "Failure sending request")
   245  		return
   246  	}
   247  
   248  	return
   249  }
   250  
   251  // CreateOrUpdatePrivateEndpointConnectionPreparer prepares the CreateOrUpdatePrivateEndpointConnection request.
   252  func (client IotDpsResourceClient) CreateOrUpdatePrivateEndpointConnectionPreparer(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, privateEndpointConnection PrivateEndpointConnection) (*http.Request, error) {
   253  	pathParameters := map[string]interface{}{
   254  		"privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName),
   255  		"resourceGroupName":             autorest.Encode("path", resourceGroupName),
   256  		"resourceName":                  autorest.Encode("path", resourceName),
   257  		"subscriptionId":                autorest.Encode("path", client.SubscriptionID),
   258  	}
   259  
   260  	const APIVersion = "2021-10-15"
   261  	queryParameters := map[string]interface{}{
   262  		"api-version": APIVersion,
   263  	}
   264  
   265  	privateEndpointConnection.ID = nil
   266  	privateEndpointConnection.Name = nil
   267  	privateEndpointConnection.Type = nil
   268  	privateEndpointConnection.SystemData = nil
   269  	preparer := autorest.CreatePreparer(
   270  		autorest.AsContentType("application/json; charset=utf-8"),
   271  		autorest.AsPut(),
   272  		autorest.WithBaseURL(client.BaseURI),
   273  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{resourceName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters),
   274  		autorest.WithJSON(privateEndpointConnection),
   275  		autorest.WithQueryParameters(queryParameters))
   276  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   277  }
   278  
   279  // CreateOrUpdatePrivateEndpointConnectionSender sends the CreateOrUpdatePrivateEndpointConnection request. The method will close the
   280  // http.Response Body if it receives an error.
   281  func (client IotDpsResourceClient) CreateOrUpdatePrivateEndpointConnectionSender(req *http.Request) (future IotDpsResourceCreateOrUpdatePrivateEndpointConnectionFuture, err error) {
   282  	var resp *http.Response
   283  	future.FutureAPI = &azure.Future{}
   284  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   285  	if err != nil {
   286  		return
   287  	}
   288  	var azf azure.Future
   289  	azf, err = azure.NewFutureFromResponse(resp)
   290  	future.FutureAPI = &azf
   291  	future.Result = future.result
   292  	return
   293  }
   294  
   295  // CreateOrUpdatePrivateEndpointConnectionResponder handles the response to the CreateOrUpdatePrivateEndpointConnection request. The method always
   296  // closes the http.Response Body.
   297  func (client IotDpsResourceClient) CreateOrUpdatePrivateEndpointConnectionResponder(resp *http.Response) (result PrivateEndpointConnection, err error) {
   298  	err = autorest.Respond(
   299  		resp,
   300  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   301  		autorest.ByUnmarshallingJSON(&result),
   302  		autorest.ByClosing())
   303  	result.Response = autorest.Response{Response: resp}
   304  	return
   305  }
   306  
   307  // Delete deletes the Provisioning Service.
   308  // Parameters:
   309  // provisioningServiceName - name of provisioning service to delete.
   310  // resourceGroupName - resource group identifier.
   311  func (client IotDpsResourceClient) Delete(ctx context.Context, provisioningServiceName string, resourceGroupName string) (result IotDpsResourceDeleteFuture, err error) {
   312  	if tracing.IsEnabled() {
   313  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.Delete")
   314  		defer func() {
   315  			sc := -1
   316  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   317  				sc = result.FutureAPI.Response().StatusCode
   318  			}
   319  			tracing.EndSpan(ctx, sc, err)
   320  		}()
   321  	}
   322  	req, err := client.DeletePreparer(ctx, provisioningServiceName, resourceGroupName)
   323  	if err != nil {
   324  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "Delete", nil, "Failure preparing request")
   325  		return
   326  	}
   327  
   328  	result, err = client.DeleteSender(req)
   329  	if err != nil {
   330  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "Delete", result.Response(), "Failure sending request")
   331  		return
   332  	}
   333  
   334  	return
   335  }
   336  
   337  // DeletePreparer prepares the Delete request.
   338  func (client IotDpsResourceClient) DeletePreparer(ctx context.Context, provisioningServiceName string, resourceGroupName string) (*http.Request, error) {
   339  	pathParameters := map[string]interface{}{
   340  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   341  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   342  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   343  	}
   344  
   345  	const APIVersion = "2021-10-15"
   346  	queryParameters := map[string]interface{}{
   347  		"api-version": APIVersion,
   348  	}
   349  
   350  	preparer := autorest.CreatePreparer(
   351  		autorest.AsDelete(),
   352  		autorest.WithBaseURL(client.BaseURI),
   353  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}", pathParameters),
   354  		autorest.WithQueryParameters(queryParameters))
   355  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   356  }
   357  
   358  // DeleteSender sends the Delete request. The method will close the
   359  // http.Response Body if it receives an error.
   360  func (client IotDpsResourceClient) DeleteSender(req *http.Request) (future IotDpsResourceDeleteFuture, err error) {
   361  	var resp *http.Response
   362  	future.FutureAPI = &azure.Future{}
   363  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   364  	if err != nil {
   365  		return
   366  	}
   367  	var azf azure.Future
   368  	azf, err = azure.NewFutureFromResponse(resp)
   369  	future.FutureAPI = &azf
   370  	future.Result = future.result
   371  	return
   372  }
   373  
   374  // DeleteResponder handles the response to the Delete request. The method always
   375  // closes the http.Response Body.
   376  func (client IotDpsResourceClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   377  	err = autorest.Respond(
   378  		resp,
   379  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent, http.StatusNotFound),
   380  		autorest.ByClosing())
   381  	result.Response = resp
   382  	return
   383  }
   384  
   385  // DeletePrivateEndpointConnection delete private endpoint connection with the specified name
   386  // Parameters:
   387  // resourceGroupName - the name of the resource group that contains the provisioning service.
   388  // resourceName - the name of the provisioning service.
   389  // privateEndpointConnectionName - the name of the private endpoint connection
   390  func (client IotDpsResourceClient) DeletePrivateEndpointConnection(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string) (result IotDpsResourceDeletePrivateEndpointConnectionFuture, err error) {
   391  	if tracing.IsEnabled() {
   392  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.DeletePrivateEndpointConnection")
   393  		defer func() {
   394  			sc := -1
   395  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   396  				sc = result.FutureAPI.Response().StatusCode
   397  			}
   398  			tracing.EndSpan(ctx, sc, err)
   399  		}()
   400  	}
   401  	req, err := client.DeletePrivateEndpointConnectionPreparer(ctx, resourceGroupName, resourceName, privateEndpointConnectionName)
   402  	if err != nil {
   403  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "DeletePrivateEndpointConnection", nil, "Failure preparing request")
   404  		return
   405  	}
   406  
   407  	result, err = client.DeletePrivateEndpointConnectionSender(req)
   408  	if err != nil {
   409  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "DeletePrivateEndpointConnection", result.Response(), "Failure sending request")
   410  		return
   411  	}
   412  
   413  	return
   414  }
   415  
   416  // DeletePrivateEndpointConnectionPreparer prepares the DeletePrivateEndpointConnection request.
   417  func (client IotDpsResourceClient) DeletePrivateEndpointConnectionPreparer(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string) (*http.Request, error) {
   418  	pathParameters := map[string]interface{}{
   419  		"privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName),
   420  		"resourceGroupName":             autorest.Encode("path", resourceGroupName),
   421  		"resourceName":                  autorest.Encode("path", resourceName),
   422  		"subscriptionId":                autorest.Encode("path", client.SubscriptionID),
   423  	}
   424  
   425  	const APIVersion = "2021-10-15"
   426  	queryParameters := map[string]interface{}{
   427  		"api-version": APIVersion,
   428  	}
   429  
   430  	preparer := autorest.CreatePreparer(
   431  		autorest.AsDelete(),
   432  		autorest.WithBaseURL(client.BaseURI),
   433  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{resourceName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters),
   434  		autorest.WithQueryParameters(queryParameters))
   435  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   436  }
   437  
   438  // DeletePrivateEndpointConnectionSender sends the DeletePrivateEndpointConnection request. The method will close the
   439  // http.Response Body if it receives an error.
   440  func (client IotDpsResourceClient) DeletePrivateEndpointConnectionSender(req *http.Request) (future IotDpsResourceDeletePrivateEndpointConnectionFuture, err error) {
   441  	var resp *http.Response
   442  	future.FutureAPI = &azure.Future{}
   443  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   444  	if err != nil {
   445  		return
   446  	}
   447  	var azf azure.Future
   448  	azf, err = azure.NewFutureFromResponse(resp)
   449  	future.FutureAPI = &azf
   450  	future.Result = future.result
   451  	return
   452  }
   453  
   454  // DeletePrivateEndpointConnectionResponder handles the response to the DeletePrivateEndpointConnection request. The method always
   455  // closes the http.Response Body.
   456  func (client IotDpsResourceClient) DeletePrivateEndpointConnectionResponder(resp *http.Response) (result PrivateEndpointConnection, err error) {
   457  	err = autorest.Respond(
   458  		resp,
   459  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   460  		autorest.ByUnmarshallingJSON(&result),
   461  		autorest.ByClosing())
   462  	result.Response = autorest.Response{Response: resp}
   463  	return
   464  }
   465  
   466  // Get get the metadata of the provisioning service without SAS keys.
   467  // Parameters:
   468  // provisioningServiceName - name of the provisioning service to retrieve.
   469  // resourceGroupName - resource group name.
   470  func (client IotDpsResourceClient) Get(ctx context.Context, provisioningServiceName string, resourceGroupName string) (result ProvisioningServiceDescription, err error) {
   471  	if tracing.IsEnabled() {
   472  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.Get")
   473  		defer func() {
   474  			sc := -1
   475  			if result.Response.Response != nil {
   476  				sc = result.Response.Response.StatusCode
   477  			}
   478  			tracing.EndSpan(ctx, sc, err)
   479  		}()
   480  	}
   481  	req, err := client.GetPreparer(ctx, provisioningServiceName, resourceGroupName)
   482  	if err != nil {
   483  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "Get", nil, "Failure preparing request")
   484  		return
   485  	}
   486  
   487  	resp, err := client.GetSender(req)
   488  	if err != nil {
   489  		result.Response = autorest.Response{Response: resp}
   490  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "Get", resp, "Failure sending request")
   491  		return
   492  	}
   493  
   494  	result, err = client.GetResponder(resp)
   495  	if err != nil {
   496  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "Get", resp, "Failure responding to request")
   497  		return
   498  	}
   499  
   500  	return
   501  }
   502  
   503  // GetPreparer prepares the Get request.
   504  func (client IotDpsResourceClient) GetPreparer(ctx context.Context, provisioningServiceName string, resourceGroupName string) (*http.Request, error) {
   505  	pathParameters := map[string]interface{}{
   506  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   507  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   508  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   509  	}
   510  
   511  	const APIVersion = "2021-10-15"
   512  	queryParameters := map[string]interface{}{
   513  		"api-version": APIVersion,
   514  	}
   515  
   516  	preparer := autorest.CreatePreparer(
   517  		autorest.AsGet(),
   518  		autorest.WithBaseURL(client.BaseURI),
   519  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}", pathParameters),
   520  		autorest.WithQueryParameters(queryParameters))
   521  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   522  }
   523  
   524  // GetSender sends the Get request. The method will close the
   525  // http.Response Body if it receives an error.
   526  func (client IotDpsResourceClient) GetSender(req *http.Request) (*http.Response, error) {
   527  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   528  }
   529  
   530  // GetResponder handles the response to the Get request. The method always
   531  // closes the http.Response Body.
   532  func (client IotDpsResourceClient) GetResponder(resp *http.Response) (result ProvisioningServiceDescription, err error) {
   533  	err = autorest.Respond(
   534  		resp,
   535  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   536  		autorest.ByUnmarshallingJSON(&result),
   537  		autorest.ByClosing())
   538  	result.Response = autorest.Response{Response: resp}
   539  	return
   540  }
   541  
   542  // GetOperationResult gets the status of a long running operation, such as create, update or delete a provisioning
   543  // service.
   544  // Parameters:
   545  // operationID - operation id corresponding to long running operation. Use this to poll for the status.
   546  // resourceGroupName - resource group identifier.
   547  // provisioningServiceName - name of provisioning service that the operation is running on.
   548  // asyncinfo - async header used to poll on the status of the operation, obtained while creating the long
   549  // running operation.
   550  func (client IotDpsResourceClient) GetOperationResult(ctx context.Context, operationID string, resourceGroupName string, provisioningServiceName string, asyncinfo string) (result AsyncOperationResult, err error) {
   551  	if tracing.IsEnabled() {
   552  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.GetOperationResult")
   553  		defer func() {
   554  			sc := -1
   555  			if result.Response.Response != nil {
   556  				sc = result.Response.Response.StatusCode
   557  			}
   558  			tracing.EndSpan(ctx, sc, err)
   559  		}()
   560  	}
   561  	req, err := client.GetOperationResultPreparer(ctx, operationID, resourceGroupName, provisioningServiceName, asyncinfo)
   562  	if err != nil {
   563  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetOperationResult", nil, "Failure preparing request")
   564  		return
   565  	}
   566  
   567  	resp, err := client.GetOperationResultSender(req)
   568  	if err != nil {
   569  		result.Response = autorest.Response{Response: resp}
   570  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetOperationResult", resp, "Failure sending request")
   571  		return
   572  	}
   573  
   574  	result, err = client.GetOperationResultResponder(resp)
   575  	if err != nil {
   576  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetOperationResult", resp, "Failure responding to request")
   577  		return
   578  	}
   579  
   580  	return
   581  }
   582  
   583  // GetOperationResultPreparer prepares the GetOperationResult request.
   584  func (client IotDpsResourceClient) GetOperationResultPreparer(ctx context.Context, operationID string, resourceGroupName string, provisioningServiceName string, asyncinfo string) (*http.Request, error) {
   585  	pathParameters := map[string]interface{}{
   586  		"operationId":             autorest.Encode("path", operationID),
   587  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   588  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   589  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   590  	}
   591  
   592  	const APIVersion = "2021-10-15"
   593  	queryParameters := map[string]interface{}{
   594  		"api-version": APIVersion,
   595  		"asyncinfo":   autorest.Encode("query", asyncinfo),
   596  	}
   597  
   598  	preparer := autorest.CreatePreparer(
   599  		autorest.AsGet(),
   600  		autorest.WithBaseURL(client.BaseURI),
   601  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/operationresults/{operationId}", pathParameters),
   602  		autorest.WithQueryParameters(queryParameters))
   603  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   604  }
   605  
   606  // GetOperationResultSender sends the GetOperationResult request. The method will close the
   607  // http.Response Body if it receives an error.
   608  func (client IotDpsResourceClient) GetOperationResultSender(req *http.Request) (*http.Response, error) {
   609  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   610  }
   611  
   612  // GetOperationResultResponder handles the response to the GetOperationResult request. The method always
   613  // closes the http.Response Body.
   614  func (client IotDpsResourceClient) GetOperationResultResponder(resp *http.Response) (result AsyncOperationResult, err error) {
   615  	err = autorest.Respond(
   616  		resp,
   617  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   618  		autorest.ByUnmarshallingJSON(&result),
   619  		autorest.ByClosing())
   620  	result.Response = autorest.Response{Response: resp}
   621  	return
   622  }
   623  
   624  // GetPrivateEndpointConnection get private endpoint connection properties
   625  // Parameters:
   626  // resourceGroupName - the name of the resource group that contains the provisioning service.
   627  // resourceName - the name of the provisioning service.
   628  // privateEndpointConnectionName - the name of the private endpoint connection
   629  func (client IotDpsResourceClient) GetPrivateEndpointConnection(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string) (result PrivateEndpointConnection, err error) {
   630  	if tracing.IsEnabled() {
   631  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.GetPrivateEndpointConnection")
   632  		defer func() {
   633  			sc := -1
   634  			if result.Response.Response != nil {
   635  				sc = result.Response.Response.StatusCode
   636  			}
   637  			tracing.EndSpan(ctx, sc, err)
   638  		}()
   639  	}
   640  	req, err := client.GetPrivateEndpointConnectionPreparer(ctx, resourceGroupName, resourceName, privateEndpointConnectionName)
   641  	if err != nil {
   642  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetPrivateEndpointConnection", nil, "Failure preparing request")
   643  		return
   644  	}
   645  
   646  	resp, err := client.GetPrivateEndpointConnectionSender(req)
   647  	if err != nil {
   648  		result.Response = autorest.Response{Response: resp}
   649  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetPrivateEndpointConnection", resp, "Failure sending request")
   650  		return
   651  	}
   652  
   653  	result, err = client.GetPrivateEndpointConnectionResponder(resp)
   654  	if err != nil {
   655  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetPrivateEndpointConnection", resp, "Failure responding to request")
   656  		return
   657  	}
   658  
   659  	return
   660  }
   661  
   662  // GetPrivateEndpointConnectionPreparer prepares the GetPrivateEndpointConnection request.
   663  func (client IotDpsResourceClient) GetPrivateEndpointConnectionPreparer(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string) (*http.Request, error) {
   664  	pathParameters := map[string]interface{}{
   665  		"privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName),
   666  		"resourceGroupName":             autorest.Encode("path", resourceGroupName),
   667  		"resourceName":                  autorest.Encode("path", resourceName),
   668  		"subscriptionId":                autorest.Encode("path", client.SubscriptionID),
   669  	}
   670  
   671  	const APIVersion = "2021-10-15"
   672  	queryParameters := map[string]interface{}{
   673  		"api-version": APIVersion,
   674  	}
   675  
   676  	preparer := autorest.CreatePreparer(
   677  		autorest.AsGet(),
   678  		autorest.WithBaseURL(client.BaseURI),
   679  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{resourceName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters),
   680  		autorest.WithQueryParameters(queryParameters))
   681  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   682  }
   683  
   684  // GetPrivateEndpointConnectionSender sends the GetPrivateEndpointConnection request. The method will close the
   685  // http.Response Body if it receives an error.
   686  func (client IotDpsResourceClient) GetPrivateEndpointConnectionSender(req *http.Request) (*http.Response, error) {
   687  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   688  }
   689  
   690  // GetPrivateEndpointConnectionResponder handles the response to the GetPrivateEndpointConnection request. The method always
   691  // closes the http.Response Body.
   692  func (client IotDpsResourceClient) GetPrivateEndpointConnectionResponder(resp *http.Response) (result PrivateEndpointConnection, err error) {
   693  	err = autorest.Respond(
   694  		resp,
   695  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   696  		autorest.ByUnmarshallingJSON(&result),
   697  		autorest.ByClosing())
   698  	result.Response = autorest.Response{Response: resp}
   699  	return
   700  }
   701  
   702  // GetPrivateLinkResources get the specified private link resource for the given provisioning service
   703  // Parameters:
   704  // resourceGroupName - the name of the resource group that contains the provisioning service.
   705  // resourceName - the name of the provisioning service.
   706  // groupID - the name of the private link resource
   707  func (client IotDpsResourceClient) GetPrivateLinkResources(ctx context.Context, resourceGroupName string, resourceName string, groupID string) (result GroupIDInformation, err error) {
   708  	if tracing.IsEnabled() {
   709  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.GetPrivateLinkResources")
   710  		defer func() {
   711  			sc := -1
   712  			if result.Response.Response != nil {
   713  				sc = result.Response.Response.StatusCode
   714  			}
   715  			tracing.EndSpan(ctx, sc, err)
   716  		}()
   717  	}
   718  	req, err := client.GetPrivateLinkResourcesPreparer(ctx, resourceGroupName, resourceName, groupID)
   719  	if err != nil {
   720  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetPrivateLinkResources", nil, "Failure preparing request")
   721  		return
   722  	}
   723  
   724  	resp, err := client.GetPrivateLinkResourcesSender(req)
   725  	if err != nil {
   726  		result.Response = autorest.Response{Response: resp}
   727  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetPrivateLinkResources", resp, "Failure sending request")
   728  		return
   729  	}
   730  
   731  	result, err = client.GetPrivateLinkResourcesResponder(resp)
   732  	if err != nil {
   733  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "GetPrivateLinkResources", resp, "Failure responding to request")
   734  		return
   735  	}
   736  
   737  	return
   738  }
   739  
   740  // GetPrivateLinkResourcesPreparer prepares the GetPrivateLinkResources request.
   741  func (client IotDpsResourceClient) GetPrivateLinkResourcesPreparer(ctx context.Context, resourceGroupName string, resourceName string, groupID string) (*http.Request, error) {
   742  	pathParameters := map[string]interface{}{
   743  		"groupId":           autorest.Encode("path", groupID),
   744  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   745  		"resourceName":      autorest.Encode("path", resourceName),
   746  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   747  	}
   748  
   749  	const APIVersion = "2021-10-15"
   750  	queryParameters := map[string]interface{}{
   751  		"api-version": APIVersion,
   752  	}
   753  
   754  	preparer := autorest.CreatePreparer(
   755  		autorest.AsGet(),
   756  		autorest.WithBaseURL(client.BaseURI),
   757  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{resourceName}/privateLinkResources/{groupId}", pathParameters),
   758  		autorest.WithQueryParameters(queryParameters))
   759  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   760  }
   761  
   762  // GetPrivateLinkResourcesSender sends the GetPrivateLinkResources request. The method will close the
   763  // http.Response Body if it receives an error.
   764  func (client IotDpsResourceClient) GetPrivateLinkResourcesSender(req *http.Request) (*http.Response, error) {
   765  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   766  }
   767  
   768  // GetPrivateLinkResourcesResponder handles the response to the GetPrivateLinkResources request. The method always
   769  // closes the http.Response Body.
   770  func (client IotDpsResourceClient) GetPrivateLinkResourcesResponder(resp *http.Response) (result GroupIDInformation, err error) {
   771  	err = autorest.Respond(
   772  		resp,
   773  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   774  		autorest.ByUnmarshallingJSON(&result),
   775  		autorest.ByClosing())
   776  	result.Response = autorest.Response{Response: resp}
   777  	return
   778  }
   779  
   780  // ListByResourceGroup get a list of all provisioning services in the given resource group.
   781  // Parameters:
   782  // resourceGroupName - resource group identifier.
   783  func (client IotDpsResourceClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ProvisioningServiceDescriptionListResultPage, err error) {
   784  	if tracing.IsEnabled() {
   785  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListByResourceGroup")
   786  		defer func() {
   787  			sc := -1
   788  			if result.psdlr.Response.Response != nil {
   789  				sc = result.psdlr.Response.Response.StatusCode
   790  			}
   791  			tracing.EndSpan(ctx, sc, err)
   792  		}()
   793  	}
   794  	result.fn = client.listByResourceGroupNextResults
   795  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
   796  	if err != nil {
   797  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListByResourceGroup", nil, "Failure preparing request")
   798  		return
   799  	}
   800  
   801  	resp, err := client.ListByResourceGroupSender(req)
   802  	if err != nil {
   803  		result.psdlr.Response = autorest.Response{Response: resp}
   804  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListByResourceGroup", resp, "Failure sending request")
   805  		return
   806  	}
   807  
   808  	result.psdlr, err = client.ListByResourceGroupResponder(resp)
   809  	if err != nil {
   810  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListByResourceGroup", resp, "Failure responding to request")
   811  		return
   812  	}
   813  	if result.psdlr.hasNextLink() && result.psdlr.IsEmpty() {
   814  		err = result.NextWithContext(ctx)
   815  		return
   816  	}
   817  
   818  	return
   819  }
   820  
   821  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   822  func (client IotDpsResourceClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
   823  	pathParameters := map[string]interface{}{
   824  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   825  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   826  	}
   827  
   828  	const APIVersion = "2021-10-15"
   829  	queryParameters := map[string]interface{}{
   830  		"api-version": APIVersion,
   831  	}
   832  
   833  	preparer := autorest.CreatePreparer(
   834  		autorest.AsGet(),
   835  		autorest.WithBaseURL(client.BaseURI),
   836  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices", pathParameters),
   837  		autorest.WithQueryParameters(queryParameters))
   838  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   839  }
   840  
   841  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   842  // http.Response Body if it receives an error.
   843  func (client IotDpsResourceClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   844  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   845  }
   846  
   847  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   848  // closes the http.Response Body.
   849  func (client IotDpsResourceClient) ListByResourceGroupResponder(resp *http.Response) (result ProvisioningServiceDescriptionListResult, err error) {
   850  	err = autorest.Respond(
   851  		resp,
   852  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   853  		autorest.ByUnmarshallingJSON(&result),
   854  		autorest.ByClosing())
   855  	result.Response = autorest.Response{Response: resp}
   856  	return
   857  }
   858  
   859  // listByResourceGroupNextResults retrieves the next set of results, if any.
   860  func (client IotDpsResourceClient) listByResourceGroupNextResults(ctx context.Context, lastResults ProvisioningServiceDescriptionListResult) (result ProvisioningServiceDescriptionListResult, err error) {
   861  	req, err := lastResults.provisioningServiceDescriptionListResultPreparer(ctx)
   862  	if err != nil {
   863  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
   864  	}
   865  	if req == nil {
   866  		return
   867  	}
   868  	resp, err := client.ListByResourceGroupSender(req)
   869  	if err != nil {
   870  		result.Response = autorest.Response{Response: resp}
   871  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
   872  	}
   873  	result, err = client.ListByResourceGroupResponder(resp)
   874  	if err != nil {
   875  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
   876  	}
   877  	return
   878  }
   879  
   880  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
   881  func (client IotDpsResourceClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ProvisioningServiceDescriptionListResultIterator, err error) {
   882  	if tracing.IsEnabled() {
   883  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListByResourceGroup")
   884  		defer func() {
   885  			sc := -1
   886  			if result.Response().Response.Response != nil {
   887  				sc = result.page.Response().Response.Response.StatusCode
   888  			}
   889  			tracing.EndSpan(ctx, sc, err)
   890  		}()
   891  	}
   892  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
   893  	return
   894  }
   895  
   896  // ListBySubscription list all the provisioning services for a given subscription id.
   897  func (client IotDpsResourceClient) ListBySubscription(ctx context.Context) (result ProvisioningServiceDescriptionListResultPage, err error) {
   898  	if tracing.IsEnabled() {
   899  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListBySubscription")
   900  		defer func() {
   901  			sc := -1
   902  			if result.psdlr.Response.Response != nil {
   903  				sc = result.psdlr.Response.Response.StatusCode
   904  			}
   905  			tracing.EndSpan(ctx, sc, err)
   906  		}()
   907  	}
   908  	result.fn = client.listBySubscriptionNextResults
   909  	req, err := client.ListBySubscriptionPreparer(ctx)
   910  	if err != nil {
   911  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListBySubscription", nil, "Failure preparing request")
   912  		return
   913  	}
   914  
   915  	resp, err := client.ListBySubscriptionSender(req)
   916  	if err != nil {
   917  		result.psdlr.Response = autorest.Response{Response: resp}
   918  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListBySubscription", resp, "Failure sending request")
   919  		return
   920  	}
   921  
   922  	result.psdlr, err = client.ListBySubscriptionResponder(resp)
   923  	if err != nil {
   924  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListBySubscription", resp, "Failure responding to request")
   925  		return
   926  	}
   927  	if result.psdlr.hasNextLink() && result.psdlr.IsEmpty() {
   928  		err = result.NextWithContext(ctx)
   929  		return
   930  	}
   931  
   932  	return
   933  }
   934  
   935  // ListBySubscriptionPreparer prepares the ListBySubscription request.
   936  func (client IotDpsResourceClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) {
   937  	pathParameters := map[string]interface{}{
   938  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   939  	}
   940  
   941  	const APIVersion = "2021-10-15"
   942  	queryParameters := map[string]interface{}{
   943  		"api-version": APIVersion,
   944  	}
   945  
   946  	preparer := autorest.CreatePreparer(
   947  		autorest.AsGet(),
   948  		autorest.WithBaseURL(client.BaseURI),
   949  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/provisioningServices", pathParameters),
   950  		autorest.WithQueryParameters(queryParameters))
   951  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   952  }
   953  
   954  // ListBySubscriptionSender sends the ListBySubscription request. The method will close the
   955  // http.Response Body if it receives an error.
   956  func (client IotDpsResourceClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
   957  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   958  }
   959  
   960  // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
   961  // closes the http.Response Body.
   962  func (client IotDpsResourceClient) ListBySubscriptionResponder(resp *http.Response) (result ProvisioningServiceDescriptionListResult, err error) {
   963  	err = autorest.Respond(
   964  		resp,
   965  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   966  		autorest.ByUnmarshallingJSON(&result),
   967  		autorest.ByClosing())
   968  	result.Response = autorest.Response{Response: resp}
   969  	return
   970  }
   971  
   972  // listBySubscriptionNextResults retrieves the next set of results, if any.
   973  func (client IotDpsResourceClient) listBySubscriptionNextResults(ctx context.Context, lastResults ProvisioningServiceDescriptionListResult) (result ProvisioningServiceDescriptionListResult, err error) {
   974  	req, err := lastResults.provisioningServiceDescriptionListResultPreparer(ctx)
   975  	if err != nil {
   976  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
   977  	}
   978  	if req == nil {
   979  		return
   980  	}
   981  	resp, err := client.ListBySubscriptionSender(req)
   982  	if err != nil {
   983  		result.Response = autorest.Response{Response: resp}
   984  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
   985  	}
   986  	result, err = client.ListBySubscriptionResponder(resp)
   987  	if err != nil {
   988  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
   989  	}
   990  	return
   991  }
   992  
   993  // ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
   994  func (client IotDpsResourceClient) ListBySubscriptionComplete(ctx context.Context) (result ProvisioningServiceDescriptionListResultIterator, err error) {
   995  	if tracing.IsEnabled() {
   996  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListBySubscription")
   997  		defer func() {
   998  			sc := -1
   999  			if result.Response().Response.Response != nil {
  1000  				sc = result.page.Response().Response.Response.StatusCode
  1001  			}
  1002  			tracing.EndSpan(ctx, sc, err)
  1003  		}()
  1004  	}
  1005  	result.page, err = client.ListBySubscription(ctx)
  1006  	return
  1007  }
  1008  
  1009  // ListKeys list the primary and secondary keys for a provisioning service.
  1010  // Parameters:
  1011  // provisioningServiceName - the provisioning service name to get the shared access keys for.
  1012  // resourceGroupName - resource group name
  1013  func (client IotDpsResourceClient) ListKeys(ctx context.Context, provisioningServiceName string, resourceGroupName string) (result SharedAccessSignatureAuthorizationRuleListResultPage, err error) {
  1014  	if tracing.IsEnabled() {
  1015  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListKeys")
  1016  		defer func() {
  1017  			sc := -1
  1018  			if result.sasarlr.Response.Response != nil {
  1019  				sc = result.sasarlr.Response.Response.StatusCode
  1020  			}
  1021  			tracing.EndSpan(ctx, sc, err)
  1022  		}()
  1023  	}
  1024  	result.fn = client.listKeysNextResults
  1025  	req, err := client.ListKeysPreparer(ctx, provisioningServiceName, resourceGroupName)
  1026  	if err != nil {
  1027  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListKeys", nil, "Failure preparing request")
  1028  		return
  1029  	}
  1030  
  1031  	resp, err := client.ListKeysSender(req)
  1032  	if err != nil {
  1033  		result.sasarlr.Response = autorest.Response{Response: resp}
  1034  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListKeys", resp, "Failure sending request")
  1035  		return
  1036  	}
  1037  
  1038  	result.sasarlr, err = client.ListKeysResponder(resp)
  1039  	if err != nil {
  1040  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListKeys", resp, "Failure responding to request")
  1041  		return
  1042  	}
  1043  	if result.sasarlr.hasNextLink() && result.sasarlr.IsEmpty() {
  1044  		err = result.NextWithContext(ctx)
  1045  		return
  1046  	}
  1047  
  1048  	return
  1049  }
  1050  
  1051  // ListKeysPreparer prepares the ListKeys request.
  1052  func (client IotDpsResourceClient) ListKeysPreparer(ctx context.Context, provisioningServiceName string, resourceGroupName string) (*http.Request, error) {
  1053  	pathParameters := map[string]interface{}{
  1054  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
  1055  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
  1056  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
  1057  	}
  1058  
  1059  	const APIVersion = "2021-10-15"
  1060  	queryParameters := map[string]interface{}{
  1061  		"api-version": APIVersion,
  1062  	}
  1063  
  1064  	preparer := autorest.CreatePreparer(
  1065  		autorest.AsPost(),
  1066  		autorest.WithBaseURL(client.BaseURI),
  1067  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/listkeys", pathParameters),
  1068  		autorest.WithQueryParameters(queryParameters))
  1069  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1070  }
  1071  
  1072  // ListKeysSender sends the ListKeys request. The method will close the
  1073  // http.Response Body if it receives an error.
  1074  func (client IotDpsResourceClient) ListKeysSender(req *http.Request) (*http.Response, error) {
  1075  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1076  }
  1077  
  1078  // ListKeysResponder handles the response to the ListKeys request. The method always
  1079  // closes the http.Response Body.
  1080  func (client IotDpsResourceClient) ListKeysResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRuleListResult, err error) {
  1081  	err = autorest.Respond(
  1082  		resp,
  1083  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1084  		autorest.ByUnmarshallingJSON(&result),
  1085  		autorest.ByClosing())
  1086  	result.Response = autorest.Response{Response: resp}
  1087  	return
  1088  }
  1089  
  1090  // listKeysNextResults retrieves the next set of results, if any.
  1091  func (client IotDpsResourceClient) listKeysNextResults(ctx context.Context, lastResults SharedAccessSignatureAuthorizationRuleListResult) (result SharedAccessSignatureAuthorizationRuleListResult, err error) {
  1092  	req, err := lastResults.sharedAccessSignatureAuthorizationRuleListResultPreparer(ctx)
  1093  	if err != nil {
  1094  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listKeysNextResults", nil, "Failure preparing next results request")
  1095  	}
  1096  	if req == nil {
  1097  		return
  1098  	}
  1099  	resp, err := client.ListKeysSender(req)
  1100  	if err != nil {
  1101  		result.Response = autorest.Response{Response: resp}
  1102  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listKeysNextResults", resp, "Failure sending next results request")
  1103  	}
  1104  	result, err = client.ListKeysResponder(resp)
  1105  	if err != nil {
  1106  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listKeysNextResults", resp, "Failure responding to next results request")
  1107  	}
  1108  	return
  1109  }
  1110  
  1111  // ListKeysComplete enumerates all values, automatically crossing page boundaries as required.
  1112  func (client IotDpsResourceClient) ListKeysComplete(ctx context.Context, provisioningServiceName string, resourceGroupName string) (result SharedAccessSignatureAuthorizationRuleListResultIterator, err error) {
  1113  	if tracing.IsEnabled() {
  1114  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListKeys")
  1115  		defer func() {
  1116  			sc := -1
  1117  			if result.Response().Response.Response != nil {
  1118  				sc = result.page.Response().Response.Response.StatusCode
  1119  			}
  1120  			tracing.EndSpan(ctx, sc, err)
  1121  		}()
  1122  	}
  1123  	result.page, err = client.ListKeys(ctx, provisioningServiceName, resourceGroupName)
  1124  	return
  1125  }
  1126  
  1127  // ListKeysForKeyName list primary and secondary keys for a specific key name
  1128  // Parameters:
  1129  // provisioningServiceName - name of the provisioning service.
  1130  // keyName - logical key name to get key-values for.
  1131  // resourceGroupName - the name of the resource group that contains the provisioning service.
  1132  func (client IotDpsResourceClient) ListKeysForKeyName(ctx context.Context, provisioningServiceName string, keyName string, resourceGroupName string) (result SharedAccessSignatureAuthorizationRuleAccessRightsDescription, err error) {
  1133  	if tracing.IsEnabled() {
  1134  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListKeysForKeyName")
  1135  		defer func() {
  1136  			sc := -1
  1137  			if result.Response.Response != nil {
  1138  				sc = result.Response.Response.StatusCode
  1139  			}
  1140  			tracing.EndSpan(ctx, sc, err)
  1141  		}()
  1142  	}
  1143  	req, err := client.ListKeysForKeyNamePreparer(ctx, provisioningServiceName, keyName, resourceGroupName)
  1144  	if err != nil {
  1145  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListKeysForKeyName", nil, "Failure preparing request")
  1146  		return
  1147  	}
  1148  
  1149  	resp, err := client.ListKeysForKeyNameSender(req)
  1150  	if err != nil {
  1151  		result.Response = autorest.Response{Response: resp}
  1152  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListKeysForKeyName", resp, "Failure sending request")
  1153  		return
  1154  	}
  1155  
  1156  	result, err = client.ListKeysForKeyNameResponder(resp)
  1157  	if err != nil {
  1158  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListKeysForKeyName", resp, "Failure responding to request")
  1159  		return
  1160  	}
  1161  
  1162  	return
  1163  }
  1164  
  1165  // ListKeysForKeyNamePreparer prepares the ListKeysForKeyName request.
  1166  func (client IotDpsResourceClient) ListKeysForKeyNamePreparer(ctx context.Context, provisioningServiceName string, keyName string, resourceGroupName string) (*http.Request, error) {
  1167  	pathParameters := map[string]interface{}{
  1168  		"keyName":                 autorest.Encode("path", keyName),
  1169  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
  1170  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
  1171  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
  1172  	}
  1173  
  1174  	const APIVersion = "2021-10-15"
  1175  	queryParameters := map[string]interface{}{
  1176  		"api-version": APIVersion,
  1177  	}
  1178  
  1179  	preparer := autorest.CreatePreparer(
  1180  		autorest.AsPost(),
  1181  		autorest.WithBaseURL(client.BaseURI),
  1182  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/keys/{keyName}/listkeys", pathParameters),
  1183  		autorest.WithQueryParameters(queryParameters))
  1184  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1185  }
  1186  
  1187  // ListKeysForKeyNameSender sends the ListKeysForKeyName request. The method will close the
  1188  // http.Response Body if it receives an error.
  1189  func (client IotDpsResourceClient) ListKeysForKeyNameSender(req *http.Request) (*http.Response, error) {
  1190  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1191  }
  1192  
  1193  // ListKeysForKeyNameResponder handles the response to the ListKeysForKeyName request. The method always
  1194  // closes the http.Response Body.
  1195  func (client IotDpsResourceClient) ListKeysForKeyNameResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRuleAccessRightsDescription, err error) {
  1196  	err = autorest.Respond(
  1197  		resp,
  1198  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1199  		autorest.ByUnmarshallingJSON(&result),
  1200  		autorest.ByClosing())
  1201  	result.Response = autorest.Response{Response: resp}
  1202  	return
  1203  }
  1204  
  1205  // ListPrivateEndpointConnections list private endpoint connection properties
  1206  // Parameters:
  1207  // resourceGroupName - the name of the resource group that contains the provisioning service.
  1208  // resourceName - the name of the provisioning service.
  1209  func (client IotDpsResourceClient) ListPrivateEndpointConnections(ctx context.Context, resourceGroupName string, resourceName string) (result ListPrivateEndpointConnection, err error) {
  1210  	if tracing.IsEnabled() {
  1211  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListPrivateEndpointConnections")
  1212  		defer func() {
  1213  			sc := -1
  1214  			if result.Response.Response != nil {
  1215  				sc = result.Response.Response.StatusCode
  1216  			}
  1217  			tracing.EndSpan(ctx, sc, err)
  1218  		}()
  1219  	}
  1220  	req, err := client.ListPrivateEndpointConnectionsPreparer(ctx, resourceGroupName, resourceName)
  1221  	if err != nil {
  1222  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListPrivateEndpointConnections", nil, "Failure preparing request")
  1223  		return
  1224  	}
  1225  
  1226  	resp, err := client.ListPrivateEndpointConnectionsSender(req)
  1227  	if err != nil {
  1228  		result.Response = autorest.Response{Response: resp}
  1229  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListPrivateEndpointConnections", resp, "Failure sending request")
  1230  		return
  1231  	}
  1232  
  1233  	result, err = client.ListPrivateEndpointConnectionsResponder(resp)
  1234  	if err != nil {
  1235  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListPrivateEndpointConnections", resp, "Failure responding to request")
  1236  		return
  1237  	}
  1238  
  1239  	return
  1240  }
  1241  
  1242  // ListPrivateEndpointConnectionsPreparer prepares the ListPrivateEndpointConnections request.
  1243  func (client IotDpsResourceClient) ListPrivateEndpointConnectionsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1244  	pathParameters := map[string]interface{}{
  1245  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1246  		"resourceName":      autorest.Encode("path", resourceName),
  1247  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1248  	}
  1249  
  1250  	const APIVersion = "2021-10-15"
  1251  	queryParameters := map[string]interface{}{
  1252  		"api-version": APIVersion,
  1253  	}
  1254  
  1255  	preparer := autorest.CreatePreparer(
  1256  		autorest.AsGet(),
  1257  		autorest.WithBaseURL(client.BaseURI),
  1258  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{resourceName}/privateEndpointConnections", pathParameters),
  1259  		autorest.WithQueryParameters(queryParameters))
  1260  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1261  }
  1262  
  1263  // ListPrivateEndpointConnectionsSender sends the ListPrivateEndpointConnections request. The method will close the
  1264  // http.Response Body if it receives an error.
  1265  func (client IotDpsResourceClient) ListPrivateEndpointConnectionsSender(req *http.Request) (*http.Response, error) {
  1266  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1267  }
  1268  
  1269  // ListPrivateEndpointConnectionsResponder handles the response to the ListPrivateEndpointConnections request. The method always
  1270  // closes the http.Response Body.
  1271  func (client IotDpsResourceClient) ListPrivateEndpointConnectionsResponder(resp *http.Response) (result ListPrivateEndpointConnection, err error) {
  1272  	err = autorest.Respond(
  1273  		resp,
  1274  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1275  		autorest.ByUnmarshallingJSON(&result.Value),
  1276  		autorest.ByClosing())
  1277  	result.Response = autorest.Response{Response: resp}
  1278  	return
  1279  }
  1280  
  1281  // ListPrivateLinkResources list private link resources for the given provisioning service
  1282  // Parameters:
  1283  // resourceGroupName - the name of the resource group that contains the provisioning service.
  1284  // resourceName - the name of the provisioning service.
  1285  func (client IotDpsResourceClient) ListPrivateLinkResources(ctx context.Context, resourceGroupName string, resourceName string) (result PrivateLinkResources, err error) {
  1286  	if tracing.IsEnabled() {
  1287  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListPrivateLinkResources")
  1288  		defer func() {
  1289  			sc := -1
  1290  			if result.Response.Response != nil {
  1291  				sc = result.Response.Response.StatusCode
  1292  			}
  1293  			tracing.EndSpan(ctx, sc, err)
  1294  		}()
  1295  	}
  1296  	req, err := client.ListPrivateLinkResourcesPreparer(ctx, resourceGroupName, resourceName)
  1297  	if err != nil {
  1298  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListPrivateLinkResources", nil, "Failure preparing request")
  1299  		return
  1300  	}
  1301  
  1302  	resp, err := client.ListPrivateLinkResourcesSender(req)
  1303  	if err != nil {
  1304  		result.Response = autorest.Response{Response: resp}
  1305  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListPrivateLinkResources", resp, "Failure sending request")
  1306  		return
  1307  	}
  1308  
  1309  	result, err = client.ListPrivateLinkResourcesResponder(resp)
  1310  	if err != nil {
  1311  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListPrivateLinkResources", resp, "Failure responding to request")
  1312  		return
  1313  	}
  1314  
  1315  	return
  1316  }
  1317  
  1318  // ListPrivateLinkResourcesPreparer prepares the ListPrivateLinkResources request.
  1319  func (client IotDpsResourceClient) ListPrivateLinkResourcesPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1320  	pathParameters := map[string]interface{}{
  1321  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1322  		"resourceName":      autorest.Encode("path", resourceName),
  1323  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1324  	}
  1325  
  1326  	const APIVersion = "2021-10-15"
  1327  	queryParameters := map[string]interface{}{
  1328  		"api-version": APIVersion,
  1329  	}
  1330  
  1331  	preparer := autorest.CreatePreparer(
  1332  		autorest.AsGet(),
  1333  		autorest.WithBaseURL(client.BaseURI),
  1334  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{resourceName}/privateLinkResources", pathParameters),
  1335  		autorest.WithQueryParameters(queryParameters))
  1336  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1337  }
  1338  
  1339  // ListPrivateLinkResourcesSender sends the ListPrivateLinkResources request. The method will close the
  1340  // http.Response Body if it receives an error.
  1341  func (client IotDpsResourceClient) ListPrivateLinkResourcesSender(req *http.Request) (*http.Response, error) {
  1342  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1343  }
  1344  
  1345  // ListPrivateLinkResourcesResponder handles the response to the ListPrivateLinkResources request. The method always
  1346  // closes the http.Response Body.
  1347  func (client IotDpsResourceClient) ListPrivateLinkResourcesResponder(resp *http.Response) (result PrivateLinkResources, err error) {
  1348  	err = autorest.Respond(
  1349  		resp,
  1350  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1351  		autorest.ByUnmarshallingJSON(&result),
  1352  		autorest.ByClosing())
  1353  	result.Response = autorest.Response{Response: resp}
  1354  	return
  1355  }
  1356  
  1357  // ListValidSkus gets the list of valid SKUs and tiers for a provisioning service.
  1358  // Parameters:
  1359  // provisioningServiceName - name of provisioning service.
  1360  // resourceGroupName - name of resource group.
  1361  func (client IotDpsResourceClient) ListValidSkus(ctx context.Context, provisioningServiceName string, resourceGroupName string) (result IotDpsSkuDefinitionListResultPage, err error) {
  1362  	if tracing.IsEnabled() {
  1363  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListValidSkus")
  1364  		defer func() {
  1365  			sc := -1
  1366  			if result.idsdlr.Response.Response != nil {
  1367  				sc = result.idsdlr.Response.Response.StatusCode
  1368  			}
  1369  			tracing.EndSpan(ctx, sc, err)
  1370  		}()
  1371  	}
  1372  	result.fn = client.listValidSkusNextResults
  1373  	req, err := client.ListValidSkusPreparer(ctx, provisioningServiceName, resourceGroupName)
  1374  	if err != nil {
  1375  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListValidSkus", nil, "Failure preparing request")
  1376  		return
  1377  	}
  1378  
  1379  	resp, err := client.ListValidSkusSender(req)
  1380  	if err != nil {
  1381  		result.idsdlr.Response = autorest.Response{Response: resp}
  1382  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListValidSkus", resp, "Failure sending request")
  1383  		return
  1384  	}
  1385  
  1386  	result.idsdlr, err = client.ListValidSkusResponder(resp)
  1387  	if err != nil {
  1388  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "ListValidSkus", resp, "Failure responding to request")
  1389  		return
  1390  	}
  1391  	if result.idsdlr.hasNextLink() && result.idsdlr.IsEmpty() {
  1392  		err = result.NextWithContext(ctx)
  1393  		return
  1394  	}
  1395  
  1396  	return
  1397  }
  1398  
  1399  // ListValidSkusPreparer prepares the ListValidSkus request.
  1400  func (client IotDpsResourceClient) ListValidSkusPreparer(ctx context.Context, provisioningServiceName string, resourceGroupName string) (*http.Request, error) {
  1401  	pathParameters := map[string]interface{}{
  1402  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
  1403  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
  1404  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
  1405  	}
  1406  
  1407  	const APIVersion = "2021-10-15"
  1408  	queryParameters := map[string]interface{}{
  1409  		"api-version": APIVersion,
  1410  	}
  1411  
  1412  	preparer := autorest.CreatePreparer(
  1413  		autorest.AsGet(),
  1414  		autorest.WithBaseURL(client.BaseURI),
  1415  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/skus", pathParameters),
  1416  		autorest.WithQueryParameters(queryParameters))
  1417  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1418  }
  1419  
  1420  // ListValidSkusSender sends the ListValidSkus request. The method will close the
  1421  // http.Response Body if it receives an error.
  1422  func (client IotDpsResourceClient) ListValidSkusSender(req *http.Request) (*http.Response, error) {
  1423  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1424  }
  1425  
  1426  // ListValidSkusResponder handles the response to the ListValidSkus request. The method always
  1427  // closes the http.Response Body.
  1428  func (client IotDpsResourceClient) ListValidSkusResponder(resp *http.Response) (result IotDpsSkuDefinitionListResult, err error) {
  1429  	err = autorest.Respond(
  1430  		resp,
  1431  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1432  		autorest.ByUnmarshallingJSON(&result),
  1433  		autorest.ByClosing())
  1434  	result.Response = autorest.Response{Response: resp}
  1435  	return
  1436  }
  1437  
  1438  // listValidSkusNextResults retrieves the next set of results, if any.
  1439  func (client IotDpsResourceClient) listValidSkusNextResults(ctx context.Context, lastResults IotDpsSkuDefinitionListResult) (result IotDpsSkuDefinitionListResult, err error) {
  1440  	req, err := lastResults.iotDpsSkuDefinitionListResultPreparer(ctx)
  1441  	if err != nil {
  1442  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listValidSkusNextResults", nil, "Failure preparing next results request")
  1443  	}
  1444  	if req == nil {
  1445  		return
  1446  	}
  1447  	resp, err := client.ListValidSkusSender(req)
  1448  	if err != nil {
  1449  		result.Response = autorest.Response{Response: resp}
  1450  		return result, autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listValidSkusNextResults", resp, "Failure sending next results request")
  1451  	}
  1452  	result, err = client.ListValidSkusResponder(resp)
  1453  	if err != nil {
  1454  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "listValidSkusNextResults", resp, "Failure responding to next results request")
  1455  	}
  1456  	return
  1457  }
  1458  
  1459  // ListValidSkusComplete enumerates all values, automatically crossing page boundaries as required.
  1460  func (client IotDpsResourceClient) ListValidSkusComplete(ctx context.Context, provisioningServiceName string, resourceGroupName string) (result IotDpsSkuDefinitionListResultIterator, err error) {
  1461  	if tracing.IsEnabled() {
  1462  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.ListValidSkus")
  1463  		defer func() {
  1464  			sc := -1
  1465  			if result.Response().Response.Response != nil {
  1466  				sc = result.page.Response().Response.Response.StatusCode
  1467  			}
  1468  			tracing.EndSpan(ctx, sc, err)
  1469  		}()
  1470  	}
  1471  	result.page, err = client.ListValidSkus(ctx, provisioningServiceName, resourceGroupName)
  1472  	return
  1473  }
  1474  
  1475  // Update update an existing provisioning service's tags. to update other fields use the CreateOrUpdate method
  1476  // Parameters:
  1477  // resourceGroupName - resource group identifier.
  1478  // provisioningServiceName - name of provisioning service to create or update.
  1479  // provisioningServiceTags - updated tag information to set into the provisioning service instance.
  1480  func (client IotDpsResourceClient) Update(ctx context.Context, resourceGroupName string, provisioningServiceName string, provisioningServiceTags TagsResource) (result IotDpsResourceUpdateFuture, err error) {
  1481  	if tracing.IsEnabled() {
  1482  		ctx = tracing.StartSpan(ctx, fqdn+"/IotDpsResourceClient.Update")
  1483  		defer func() {
  1484  			sc := -1
  1485  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1486  				sc = result.FutureAPI.Response().StatusCode
  1487  			}
  1488  			tracing.EndSpan(ctx, sc, err)
  1489  		}()
  1490  	}
  1491  	req, err := client.UpdatePreparer(ctx, resourceGroupName, provisioningServiceName, provisioningServiceTags)
  1492  	if err != nil {
  1493  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "Update", nil, "Failure preparing request")
  1494  		return
  1495  	}
  1496  
  1497  	result, err = client.UpdateSender(req)
  1498  	if err != nil {
  1499  		err = autorest.NewErrorWithError(err, "iothub.IotDpsResourceClient", "Update", result.Response(), "Failure sending request")
  1500  		return
  1501  	}
  1502  
  1503  	return
  1504  }
  1505  
  1506  // UpdatePreparer prepares the Update request.
  1507  func (client IotDpsResourceClient) UpdatePreparer(ctx context.Context, resourceGroupName string, provisioningServiceName string, provisioningServiceTags TagsResource) (*http.Request, error) {
  1508  	pathParameters := map[string]interface{}{
  1509  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
  1510  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
  1511  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
  1512  	}
  1513  
  1514  	const APIVersion = "2021-10-15"
  1515  	queryParameters := map[string]interface{}{
  1516  		"api-version": APIVersion,
  1517  	}
  1518  
  1519  	preparer := autorest.CreatePreparer(
  1520  		autorest.AsContentType("application/json; charset=utf-8"),
  1521  		autorest.AsPatch(),
  1522  		autorest.WithBaseURL(client.BaseURI),
  1523  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}", pathParameters),
  1524  		autorest.WithJSON(provisioningServiceTags),
  1525  		autorest.WithQueryParameters(queryParameters))
  1526  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1527  }
  1528  
  1529  // UpdateSender sends the Update request. The method will close the
  1530  // http.Response Body if it receives an error.
  1531  func (client IotDpsResourceClient) UpdateSender(req *http.Request) (future IotDpsResourceUpdateFuture, err error) {
  1532  	var resp *http.Response
  1533  	future.FutureAPI = &azure.Future{}
  1534  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1535  	if err != nil {
  1536  		return
  1537  	}
  1538  	var azf azure.Future
  1539  	azf, err = azure.NewFutureFromResponse(resp)
  1540  	future.FutureAPI = &azf
  1541  	future.Result = future.result
  1542  	return
  1543  }
  1544  
  1545  // UpdateResponder handles the response to the Update request. The method always
  1546  // closes the http.Response Body.
  1547  func (client IotDpsResourceClient) UpdateResponder(resp *http.Response) (result ProvisioningServiceDescription, err error) {
  1548  	err = autorest.Respond(
  1549  		resp,
  1550  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1551  		autorest.ByUnmarshallingJSON(&result),
  1552  		autorest.ByClosing())
  1553  	result.Response = autorest.Response{Response: resp}
  1554  	return
  1555  }
  1556  

View as plain text