Source file src/github.com/Azure/azure-sdk-for-go/services/iothub/mgmt/2017-01-19/devices/iothubresource.go

Documentation: github.com/Azure/azure-sdk-for-go/services/iothub/mgmt/2017-01-19/devices

     1  package devices
     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  // IotHubResourceClient is the use this API to manage the IoT hubs in your Azure subscription.
    19  type IotHubResourceClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewIotHubResourceClient creates an instance of the IotHubResourceClient client.
    24  func NewIotHubResourceClient(subscriptionID string) IotHubResourceClient {
    25  	return NewIotHubResourceClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewIotHubResourceClientWithBaseURI creates an instance of the IotHubResourceClient 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 NewIotHubResourceClientWithBaseURI(baseURI string, subscriptionID string) IotHubResourceClient {
    31  	return IotHubResourceClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CheckNameAvailability check if an IoT hub name is available.
    35  // Parameters:
    36  // operationInputs - set the name parameter in the OperationInputs structure to the name of the IoT hub to
    37  // check.
    38  func (client IotHubResourceClient) CheckNameAvailability(ctx context.Context, operationInputs OperationInputs) (result IotHubNameAvailabilityInfo, err error) {
    39  	if tracing.IsEnabled() {
    40  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CheckNameAvailability")
    41  		defer func() {
    42  			sc := -1
    43  			if result.Response.Response != nil {
    44  				sc = result.Response.Response.StatusCode
    45  			}
    46  			tracing.EndSpan(ctx, sc, err)
    47  		}()
    48  	}
    49  	if err := validation.Validate([]validation.Validation{
    50  		{TargetValue: operationInputs,
    51  			Constraints: []validation.Constraint{{Target: "operationInputs.Name", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
    52  		return result, validation.NewError("devices.IotHubResourceClient", "CheckNameAvailability", err.Error())
    53  	}
    54  
    55  	req, err := client.CheckNameAvailabilityPreparer(ctx, operationInputs)
    56  	if err != nil {
    57  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", nil, "Failure preparing request")
    58  		return
    59  	}
    60  
    61  	resp, err := client.CheckNameAvailabilitySender(req)
    62  	if err != nil {
    63  		result.Response = autorest.Response{Response: resp}
    64  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", resp, "Failure sending request")
    65  		return
    66  	}
    67  
    68  	result, err = client.CheckNameAvailabilityResponder(resp)
    69  	if err != nil {
    70  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CheckNameAvailability", resp, "Failure responding to request")
    71  		return
    72  	}
    73  
    74  	return
    75  }
    76  
    77  // CheckNameAvailabilityPreparer prepares the CheckNameAvailability request.
    78  func (client IotHubResourceClient) CheckNameAvailabilityPreparer(ctx context.Context, operationInputs OperationInputs) (*http.Request, error) {
    79  	pathParameters := map[string]interface{}{
    80  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
    81  	}
    82  
    83  	const APIVersion = "2017-01-19"
    84  	queryParameters := map[string]interface{}{
    85  		"api-version": APIVersion,
    86  	}
    87  
    88  	preparer := autorest.CreatePreparer(
    89  		autorest.AsContentType("application/json; charset=utf-8"),
    90  		autorest.AsPost(),
    91  		autorest.WithBaseURL(client.BaseURI),
    92  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/checkNameAvailability", pathParameters),
    93  		autorest.WithJSON(operationInputs),
    94  		autorest.WithQueryParameters(queryParameters))
    95  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    96  }
    97  
    98  // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the
    99  // http.Response Body if it receives an error.
   100  func (client IotHubResourceClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) {
   101  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   102  }
   103  
   104  // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always
   105  // closes the http.Response Body.
   106  func (client IotHubResourceClient) CheckNameAvailabilityResponder(resp *http.Response) (result IotHubNameAvailabilityInfo, err error) {
   107  	err = autorest.Respond(
   108  		resp,
   109  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   110  		autorest.ByUnmarshallingJSON(&result),
   111  		autorest.ByClosing())
   112  	result.Response = autorest.Response{Response: resp}
   113  	return
   114  }
   115  
   116  // CreateEventHubConsumerGroup add a consumer group to an Event Hub-compatible endpoint in an IoT hub.
   117  // Parameters:
   118  // resourceGroupName - the name of the resource group that contains the IoT hub.
   119  // resourceName - the name of the IoT hub.
   120  // eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub.
   121  // name - the name of the consumer group to add.
   122  func (client IotHubResourceClient) CreateEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result EventHubConsumerGroupInfo, err error) {
   123  	if tracing.IsEnabled() {
   124  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CreateEventHubConsumerGroup")
   125  		defer func() {
   126  			sc := -1
   127  			if result.Response.Response != nil {
   128  				sc = result.Response.Response.StatusCode
   129  			}
   130  			tracing.EndSpan(ctx, sc, err)
   131  		}()
   132  	}
   133  	req, err := client.CreateEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name)
   134  	if err != nil {
   135  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", nil, "Failure preparing request")
   136  		return
   137  	}
   138  
   139  	resp, err := client.CreateEventHubConsumerGroupSender(req)
   140  	if err != nil {
   141  		result.Response = autorest.Response{Response: resp}
   142  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", resp, "Failure sending request")
   143  		return
   144  	}
   145  
   146  	result, err = client.CreateEventHubConsumerGroupResponder(resp)
   147  	if err != nil {
   148  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateEventHubConsumerGroup", resp, "Failure responding to request")
   149  		return
   150  	}
   151  
   152  	return
   153  }
   154  
   155  // CreateEventHubConsumerGroupPreparer prepares the CreateEventHubConsumerGroup request.
   156  func (client IotHubResourceClient) CreateEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) {
   157  	pathParameters := map[string]interface{}{
   158  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
   159  		"name":                 autorest.Encode("path", name),
   160  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   161  		"resourceName":         autorest.Encode("path", resourceName),
   162  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   163  	}
   164  
   165  	const APIVersion = "2017-01-19"
   166  	queryParameters := map[string]interface{}{
   167  		"api-version": APIVersion,
   168  	}
   169  
   170  	preparer := autorest.CreatePreparer(
   171  		autorest.AsPut(),
   172  		autorest.WithBaseURL(client.BaseURI),
   173  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters),
   174  		autorest.WithQueryParameters(queryParameters))
   175  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   176  }
   177  
   178  // CreateEventHubConsumerGroupSender sends the CreateEventHubConsumerGroup request. The method will close the
   179  // http.Response Body if it receives an error.
   180  func (client IotHubResourceClient) CreateEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) {
   181  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   182  }
   183  
   184  // CreateEventHubConsumerGroupResponder handles the response to the CreateEventHubConsumerGroup request. The method always
   185  // closes the http.Response Body.
   186  func (client IotHubResourceClient) CreateEventHubConsumerGroupResponder(resp *http.Response) (result EventHubConsumerGroupInfo, err error) {
   187  	err = autorest.Respond(
   188  		resp,
   189  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   190  		autorest.ByUnmarshallingJSON(&result),
   191  		autorest.ByClosing())
   192  	result.Response = autorest.Response{Response: resp}
   193  	return
   194  }
   195  
   196  // CreateOrUpdate create or update the metadata of an Iot hub. The usual pattern to modify a property is to retrieve
   197  // the IoT hub metadata and security metadata, and then combine them with the modified values in a new body to update
   198  // the IoT hub.
   199  // Parameters:
   200  // resourceGroupName - the name of the resource group that contains the IoT hub.
   201  // resourceName - the name of the IoT hub to create or update.
   202  // iotHubDescription - the IoT hub metadata and security metadata.
   203  func (client IotHubResourceClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription) (result IotHubResourceCreateOrUpdateFuture, err error) {
   204  	if tracing.IsEnabled() {
   205  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.CreateOrUpdate")
   206  		defer func() {
   207  			sc := -1
   208  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   209  				sc = result.FutureAPI.Response().StatusCode
   210  			}
   211  			tracing.EndSpan(ctx, sc, err)
   212  		}()
   213  	}
   214  	if err := validation.Validate([]validation.Validation{
   215  		{TargetValue: iotHubDescription,
   216  			Constraints: []validation.Constraint{{Target: "iotHubDescription.Subscriptionid", Name: validation.Null, Rule: true, Chain: nil},
   217  				{Target: "iotHubDescription.Resourcegroup", Name: validation.Null, Rule: true, Chain: nil},
   218  				{Target: "iotHubDescription.Properties", Name: validation.Null, Rule: false,
   219  					Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing", Name: validation.Null, Rule: false,
   220  						Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute", Name: validation.Null, Rule: false,
   221  							Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute.Source", Name: validation.Null, Rule: true, Chain: nil},
   222  								{Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.Null, Rule: true,
   223  									Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.MaxItems, Rule: 1, Chain: nil},
   224  										{Target: "iotHubDescription.Properties.Routing.FallbackRoute.EndpointNames", Name: validation.MinItems, Rule: 1, Chain: nil},
   225  									}},
   226  								{Target: "iotHubDescription.Properties.Routing.FallbackRoute.IsEnabled", Name: validation.Null, Rule: true, Chain: nil},
   227  							}},
   228  						}},
   229  						{Target: "iotHubDescription.Properties.CloudToDevice", Name: validation.Null, Rule: false,
   230  							Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.Null, Rule: false,
   231  								Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
   232  									{Target: "iotHubDescription.Properties.CloudToDevice.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   233  								}},
   234  								{Target: "iotHubDescription.Properties.CloudToDevice.Feedback", Name: validation.Null, Rule: false,
   235  									Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.Null, Rule: false,
   236  										Chain: []validation.Constraint{{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
   237  											{Target: "iotHubDescription.Properties.CloudToDevice.Feedback.MaxDeliveryCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   238  										}},
   239  									}},
   240  							}},
   241  					}},
   242  				{Target: "iotHubDescription.Sku", Name: validation.Null, Rule: true,
   243  					Chain: []validation.Constraint{{Target: "iotHubDescription.Sku.Capacity", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
   244  		return result, validation.NewError("devices.IotHubResourceClient", "CreateOrUpdate", err.Error())
   245  	}
   246  
   247  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, iotHubDescription)
   248  	if err != nil {
   249  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", nil, "Failure preparing request")
   250  		return
   251  	}
   252  
   253  	result, err = client.CreateOrUpdateSender(req)
   254  	if err != nil {
   255  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "CreateOrUpdate", result.Response(), "Failure sending request")
   256  		return
   257  	}
   258  
   259  	return
   260  }
   261  
   262  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   263  func (client IotHubResourceClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, iotHubDescription IotHubDescription) (*http.Request, error) {
   264  	pathParameters := map[string]interface{}{
   265  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   266  		"resourceName":      autorest.Encode("path", resourceName),
   267  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   268  	}
   269  
   270  	const APIVersion = "2017-01-19"
   271  	queryParameters := map[string]interface{}{
   272  		"api-version": APIVersion,
   273  	}
   274  
   275  	preparer := autorest.CreatePreparer(
   276  		autorest.AsContentType("application/json; charset=utf-8"),
   277  		autorest.AsPut(),
   278  		autorest.WithBaseURL(client.BaseURI),
   279  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters),
   280  		autorest.WithJSON(iotHubDescription),
   281  		autorest.WithQueryParameters(queryParameters))
   282  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   283  }
   284  
   285  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   286  // http.Response Body if it receives an error.
   287  func (client IotHubResourceClient) CreateOrUpdateSender(req *http.Request) (future IotHubResourceCreateOrUpdateFuture, err error) {
   288  	var resp *http.Response
   289  	future.FutureAPI = &azure.Future{}
   290  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   291  	if err != nil {
   292  		return
   293  	}
   294  	var azf azure.Future
   295  	azf, err = azure.NewFutureFromResponse(resp)
   296  	future.FutureAPI = &azf
   297  	future.Result = future.result
   298  	return
   299  }
   300  
   301  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   302  // closes the http.Response Body.
   303  func (client IotHubResourceClient) CreateOrUpdateResponder(resp *http.Response) (result IotHubDescription, err error) {
   304  	err = autorest.Respond(
   305  		resp,
   306  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   307  		autorest.ByUnmarshallingJSON(&result),
   308  		autorest.ByClosing())
   309  	result.Response = autorest.Response{Response: resp}
   310  	return
   311  }
   312  
   313  // Delete delete an IoT hub.
   314  // Parameters:
   315  // resourceGroupName - the name of the resource group that contains the IoT hub.
   316  // resourceName - the name of the IoT hub to delete.
   317  func (client IotHubResourceClient) Delete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubResourceDeleteFuture, err error) {
   318  	if tracing.IsEnabled() {
   319  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Delete")
   320  		defer func() {
   321  			sc := -1
   322  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   323  				sc = result.FutureAPI.Response().StatusCode
   324  			}
   325  			tracing.EndSpan(ctx, sc, err)
   326  		}()
   327  	}
   328  	req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName)
   329  	if err != nil {
   330  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", nil, "Failure preparing request")
   331  		return
   332  	}
   333  
   334  	result, err = client.DeleteSender(req)
   335  	if err != nil {
   336  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Delete", result.Response(), "Failure sending request")
   337  		return
   338  	}
   339  
   340  	return
   341  }
   342  
   343  // DeletePreparer prepares the Delete request.
   344  func (client IotHubResourceClient) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   345  	pathParameters := map[string]interface{}{
   346  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   347  		"resourceName":      autorest.Encode("path", resourceName),
   348  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   349  	}
   350  
   351  	const APIVersion = "2017-01-19"
   352  	queryParameters := map[string]interface{}{
   353  		"api-version": APIVersion,
   354  	}
   355  
   356  	preparer := autorest.CreatePreparer(
   357  		autorest.AsDelete(),
   358  		autorest.WithBaseURL(client.BaseURI),
   359  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters),
   360  		autorest.WithQueryParameters(queryParameters))
   361  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   362  }
   363  
   364  // DeleteSender sends the Delete request. The method will close the
   365  // http.Response Body if it receives an error.
   366  func (client IotHubResourceClient) DeleteSender(req *http.Request) (future IotHubResourceDeleteFuture, err error) {
   367  	var resp *http.Response
   368  	future.FutureAPI = &azure.Future{}
   369  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   370  	if err != nil {
   371  		return
   372  	}
   373  	var azf azure.Future
   374  	azf, err = azure.NewFutureFromResponse(resp)
   375  	future.FutureAPI = &azf
   376  	future.Result = future.result
   377  	return
   378  }
   379  
   380  // DeleteResponder handles the response to the Delete request. The method always
   381  // closes the http.Response Body.
   382  func (client IotHubResourceClient) DeleteResponder(resp *http.Response) (result SetObject, err error) {
   383  	err = autorest.Respond(
   384  		resp,
   385  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent, http.StatusNotFound),
   386  		autorest.ByUnmarshallingJSON(&result.Value),
   387  		autorest.ByClosing())
   388  	result.Response = autorest.Response{Response: resp}
   389  	return
   390  }
   391  
   392  // DeleteEventHubConsumerGroup delete a consumer group from an Event Hub-compatible endpoint in an IoT hub.
   393  // Parameters:
   394  // resourceGroupName - the name of the resource group that contains the IoT hub.
   395  // resourceName - the name of the IoT hub.
   396  // eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub.
   397  // name - the name of the consumer group to delete.
   398  func (client IotHubResourceClient) DeleteEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result autorest.Response, err error) {
   399  	if tracing.IsEnabled() {
   400  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.DeleteEventHubConsumerGroup")
   401  		defer func() {
   402  			sc := -1
   403  			if result.Response != nil {
   404  				sc = result.Response.StatusCode
   405  			}
   406  			tracing.EndSpan(ctx, sc, err)
   407  		}()
   408  	}
   409  	req, err := client.DeleteEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name)
   410  	if err != nil {
   411  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", nil, "Failure preparing request")
   412  		return
   413  	}
   414  
   415  	resp, err := client.DeleteEventHubConsumerGroupSender(req)
   416  	if err != nil {
   417  		result.Response = resp
   418  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure sending request")
   419  		return
   420  	}
   421  
   422  	result, err = client.DeleteEventHubConsumerGroupResponder(resp)
   423  	if err != nil {
   424  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "DeleteEventHubConsumerGroup", resp, "Failure responding to request")
   425  		return
   426  	}
   427  
   428  	return
   429  }
   430  
   431  // DeleteEventHubConsumerGroupPreparer prepares the DeleteEventHubConsumerGroup request.
   432  func (client IotHubResourceClient) DeleteEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) {
   433  	pathParameters := map[string]interface{}{
   434  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
   435  		"name":                 autorest.Encode("path", name),
   436  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   437  		"resourceName":         autorest.Encode("path", resourceName),
   438  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   439  	}
   440  
   441  	const APIVersion = "2017-01-19"
   442  	queryParameters := map[string]interface{}{
   443  		"api-version": APIVersion,
   444  	}
   445  
   446  	preparer := autorest.CreatePreparer(
   447  		autorest.AsDelete(),
   448  		autorest.WithBaseURL(client.BaseURI),
   449  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters),
   450  		autorest.WithQueryParameters(queryParameters))
   451  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   452  }
   453  
   454  // DeleteEventHubConsumerGroupSender sends the DeleteEventHubConsumerGroup request. The method will close the
   455  // http.Response Body if it receives an error.
   456  func (client IotHubResourceClient) DeleteEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) {
   457  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   458  }
   459  
   460  // DeleteEventHubConsumerGroupResponder handles the response to the DeleteEventHubConsumerGroup request. The method always
   461  // closes the http.Response Body.
   462  func (client IotHubResourceClient) DeleteEventHubConsumerGroupResponder(resp *http.Response) (result autorest.Response, err error) {
   463  	err = autorest.Respond(
   464  		resp,
   465  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   466  		autorest.ByClosing())
   467  	result.Response = resp
   468  	return
   469  }
   470  
   471  // ExportDevices exports all the device identities in the IoT hub identity registry to an Azure Storage blob container.
   472  // For more information, see:
   473  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities.
   474  // Parameters:
   475  // resourceGroupName - the name of the resource group that contains the IoT hub.
   476  // resourceName - the name of the IoT hub.
   477  // exportDevicesParameters - the parameters that specify the export devices operation.
   478  func (client IotHubResourceClient) ExportDevices(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (result JobResponse, err error) {
   479  	if tracing.IsEnabled() {
   480  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ExportDevices")
   481  		defer func() {
   482  			sc := -1
   483  			if result.Response.Response != nil {
   484  				sc = result.Response.Response.StatusCode
   485  			}
   486  			tracing.EndSpan(ctx, sc, err)
   487  		}()
   488  	}
   489  	if err := validation.Validate([]validation.Validation{
   490  		{TargetValue: exportDevicesParameters,
   491  			Constraints: []validation.Constraint{{Target: "exportDevicesParameters.ExportBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil},
   492  				{Target: "exportDevicesParameters.ExcludeKeys", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   493  		return result, validation.NewError("devices.IotHubResourceClient", "ExportDevices", err.Error())
   494  	}
   495  
   496  	req, err := client.ExportDevicesPreparer(ctx, resourceGroupName, resourceName, exportDevicesParameters)
   497  	if err != nil {
   498  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", nil, "Failure preparing request")
   499  		return
   500  	}
   501  
   502  	resp, err := client.ExportDevicesSender(req)
   503  	if err != nil {
   504  		result.Response = autorest.Response{Response: resp}
   505  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure sending request")
   506  		return
   507  	}
   508  
   509  	result, err = client.ExportDevicesResponder(resp)
   510  	if err != nil {
   511  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ExportDevices", resp, "Failure responding to request")
   512  		return
   513  	}
   514  
   515  	return
   516  }
   517  
   518  // ExportDevicesPreparer prepares the ExportDevices request.
   519  func (client IotHubResourceClient) ExportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, exportDevicesParameters ExportDevicesRequest) (*http.Request, error) {
   520  	pathParameters := map[string]interface{}{
   521  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   522  		"resourceName":      autorest.Encode("path", resourceName),
   523  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   524  	}
   525  
   526  	const APIVersion = "2017-01-19"
   527  	queryParameters := map[string]interface{}{
   528  		"api-version": APIVersion,
   529  	}
   530  
   531  	preparer := autorest.CreatePreparer(
   532  		autorest.AsContentType("application/json; charset=utf-8"),
   533  		autorest.AsPost(),
   534  		autorest.WithBaseURL(client.BaseURI),
   535  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/exportDevices", pathParameters),
   536  		autorest.WithJSON(exportDevicesParameters),
   537  		autorest.WithQueryParameters(queryParameters))
   538  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   539  }
   540  
   541  // ExportDevicesSender sends the ExportDevices request. The method will close the
   542  // http.Response Body if it receives an error.
   543  func (client IotHubResourceClient) ExportDevicesSender(req *http.Request) (*http.Response, error) {
   544  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   545  }
   546  
   547  // ExportDevicesResponder handles the response to the ExportDevices request. The method always
   548  // closes the http.Response Body.
   549  func (client IotHubResourceClient) ExportDevicesResponder(resp *http.Response) (result JobResponse, err error) {
   550  	err = autorest.Respond(
   551  		resp,
   552  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   553  		autorest.ByUnmarshallingJSON(&result),
   554  		autorest.ByClosing())
   555  	result.Response = autorest.Response{Response: resp}
   556  	return
   557  }
   558  
   559  // Get get the non-security related metadata of an IoT hub.
   560  // Parameters:
   561  // resourceGroupName - the name of the resource group that contains the IoT hub.
   562  // resourceName - the name of the IoT hub.
   563  func (client IotHubResourceClient) Get(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubDescription, err error) {
   564  	if tracing.IsEnabled() {
   565  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.Get")
   566  		defer func() {
   567  			sc := -1
   568  			if result.Response.Response != nil {
   569  				sc = result.Response.Response.StatusCode
   570  			}
   571  			tracing.EndSpan(ctx, sc, err)
   572  		}()
   573  	}
   574  	req, err := client.GetPreparer(ctx, resourceGroupName, resourceName)
   575  	if err != nil {
   576  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", nil, "Failure preparing request")
   577  		return
   578  	}
   579  
   580  	resp, err := client.GetSender(req)
   581  	if err != nil {
   582  		result.Response = autorest.Response{Response: resp}
   583  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure sending request")
   584  		return
   585  	}
   586  
   587  	result, err = client.GetResponder(resp)
   588  	if err != nil {
   589  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "Get", resp, "Failure responding to request")
   590  		return
   591  	}
   592  
   593  	return
   594  }
   595  
   596  // GetPreparer prepares the Get request.
   597  func (client IotHubResourceClient) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   598  	pathParameters := map[string]interface{}{
   599  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   600  		"resourceName":      autorest.Encode("path", resourceName),
   601  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   602  	}
   603  
   604  	const APIVersion = "2017-01-19"
   605  	queryParameters := map[string]interface{}{
   606  		"api-version": APIVersion,
   607  	}
   608  
   609  	preparer := autorest.CreatePreparer(
   610  		autorest.AsGet(),
   611  		autorest.WithBaseURL(client.BaseURI),
   612  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}", pathParameters),
   613  		autorest.WithQueryParameters(queryParameters))
   614  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   615  }
   616  
   617  // GetSender sends the Get request. The method will close the
   618  // http.Response Body if it receives an error.
   619  func (client IotHubResourceClient) GetSender(req *http.Request) (*http.Response, error) {
   620  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   621  }
   622  
   623  // GetResponder handles the response to the Get request. The method always
   624  // closes the http.Response Body.
   625  func (client IotHubResourceClient) GetResponder(resp *http.Response) (result IotHubDescription, err error) {
   626  	err = autorest.Respond(
   627  		resp,
   628  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   629  		autorest.ByUnmarshallingJSON(&result),
   630  		autorest.ByClosing())
   631  	result.Response = autorest.Response{Response: resp}
   632  	return
   633  }
   634  
   635  // GetEventHubConsumerGroup get a consumer group from the Event Hub-compatible device-to-cloud endpoint for an IoT hub.
   636  // Parameters:
   637  // resourceGroupName - the name of the resource group that contains the IoT hub.
   638  // resourceName - the name of the IoT hub.
   639  // eventHubEndpointName - the name of the Event Hub-compatible endpoint in the IoT hub.
   640  // name - the name of the consumer group to retrieve.
   641  func (client IotHubResourceClient) GetEventHubConsumerGroup(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (result EventHubConsumerGroupInfo, err error) {
   642  	if tracing.IsEnabled() {
   643  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetEventHubConsumerGroup")
   644  		defer func() {
   645  			sc := -1
   646  			if result.Response.Response != nil {
   647  				sc = result.Response.Response.StatusCode
   648  			}
   649  			tracing.EndSpan(ctx, sc, err)
   650  		}()
   651  	}
   652  	req, err := client.GetEventHubConsumerGroupPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName, name)
   653  	if err != nil {
   654  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", nil, "Failure preparing request")
   655  		return
   656  	}
   657  
   658  	resp, err := client.GetEventHubConsumerGroupSender(req)
   659  	if err != nil {
   660  		result.Response = autorest.Response{Response: resp}
   661  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure sending request")
   662  		return
   663  	}
   664  
   665  	result, err = client.GetEventHubConsumerGroupResponder(resp)
   666  	if err != nil {
   667  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetEventHubConsumerGroup", resp, "Failure responding to request")
   668  		return
   669  	}
   670  
   671  	return
   672  }
   673  
   674  // GetEventHubConsumerGroupPreparer prepares the GetEventHubConsumerGroup request.
   675  func (client IotHubResourceClient) GetEventHubConsumerGroupPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string, name string) (*http.Request, error) {
   676  	pathParameters := map[string]interface{}{
   677  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
   678  		"name":                 autorest.Encode("path", name),
   679  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   680  		"resourceName":         autorest.Encode("path", resourceName),
   681  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   682  	}
   683  
   684  	const APIVersion = "2017-01-19"
   685  	queryParameters := map[string]interface{}{
   686  		"api-version": APIVersion,
   687  	}
   688  
   689  	preparer := autorest.CreatePreparer(
   690  		autorest.AsGet(),
   691  		autorest.WithBaseURL(client.BaseURI),
   692  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups/{name}", pathParameters),
   693  		autorest.WithQueryParameters(queryParameters))
   694  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   695  }
   696  
   697  // GetEventHubConsumerGroupSender sends the GetEventHubConsumerGroup request. The method will close the
   698  // http.Response Body if it receives an error.
   699  func (client IotHubResourceClient) GetEventHubConsumerGroupSender(req *http.Request) (*http.Response, error) {
   700  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   701  }
   702  
   703  // GetEventHubConsumerGroupResponder handles the response to the GetEventHubConsumerGroup request. The method always
   704  // closes the http.Response Body.
   705  func (client IotHubResourceClient) GetEventHubConsumerGroupResponder(resp *http.Response) (result EventHubConsumerGroupInfo, err error) {
   706  	err = autorest.Respond(
   707  		resp,
   708  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   709  		autorest.ByUnmarshallingJSON(&result),
   710  		autorest.ByClosing())
   711  	result.Response = autorest.Response{Response: resp}
   712  	return
   713  }
   714  
   715  // GetJob get the details of a job from an IoT hub. For more information, see:
   716  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry.
   717  // Parameters:
   718  // resourceGroupName - the name of the resource group that contains the IoT hub.
   719  // resourceName - the name of the IoT hub.
   720  // jobID - the job identifier.
   721  func (client IotHubResourceClient) GetJob(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (result JobResponse, err error) {
   722  	if tracing.IsEnabled() {
   723  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetJob")
   724  		defer func() {
   725  			sc := -1
   726  			if result.Response.Response != nil {
   727  				sc = result.Response.Response.StatusCode
   728  			}
   729  			tracing.EndSpan(ctx, sc, err)
   730  		}()
   731  	}
   732  	req, err := client.GetJobPreparer(ctx, resourceGroupName, resourceName, jobID)
   733  	if err != nil {
   734  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", nil, "Failure preparing request")
   735  		return
   736  	}
   737  
   738  	resp, err := client.GetJobSender(req)
   739  	if err != nil {
   740  		result.Response = autorest.Response{Response: resp}
   741  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure sending request")
   742  		return
   743  	}
   744  
   745  	result, err = client.GetJobResponder(resp)
   746  	if err != nil {
   747  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetJob", resp, "Failure responding to request")
   748  		return
   749  	}
   750  
   751  	return
   752  }
   753  
   754  // GetJobPreparer prepares the GetJob request.
   755  func (client IotHubResourceClient) GetJobPreparer(ctx context.Context, resourceGroupName string, resourceName string, jobID string) (*http.Request, error) {
   756  	pathParameters := map[string]interface{}{
   757  		"jobId":             autorest.Encode("path", jobID),
   758  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   759  		"resourceName":      autorest.Encode("path", resourceName),
   760  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   761  	}
   762  
   763  	const APIVersion = "2017-01-19"
   764  	queryParameters := map[string]interface{}{
   765  		"api-version": APIVersion,
   766  	}
   767  
   768  	preparer := autorest.CreatePreparer(
   769  		autorest.AsGet(),
   770  		autorest.WithBaseURL(client.BaseURI),
   771  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs/{jobId}", pathParameters),
   772  		autorest.WithQueryParameters(queryParameters))
   773  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   774  }
   775  
   776  // GetJobSender sends the GetJob request. The method will close the
   777  // http.Response Body if it receives an error.
   778  func (client IotHubResourceClient) GetJobSender(req *http.Request) (*http.Response, error) {
   779  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   780  }
   781  
   782  // GetJobResponder handles the response to the GetJob request. The method always
   783  // closes the http.Response Body.
   784  func (client IotHubResourceClient) GetJobResponder(resp *http.Response) (result JobResponse, err error) {
   785  	err = autorest.Respond(
   786  		resp,
   787  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   788  		autorest.ByUnmarshallingJSON(&result),
   789  		autorest.ByClosing())
   790  	result.Response = autorest.Response{Response: resp}
   791  	return
   792  }
   793  
   794  // GetKeysForKeyName get a shared access policy by name from an IoT hub. For more information, see:
   795  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security.
   796  // Parameters:
   797  // resourceGroupName - the name of the resource group that contains the IoT hub.
   798  // resourceName - the name of the IoT hub.
   799  // keyName - the name of the shared access policy.
   800  func (client IotHubResourceClient) GetKeysForKeyName(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (result SharedAccessSignatureAuthorizationRule, err error) {
   801  	if tracing.IsEnabled() {
   802  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetKeysForKeyName")
   803  		defer func() {
   804  			sc := -1
   805  			if result.Response.Response != nil {
   806  				sc = result.Response.Response.StatusCode
   807  			}
   808  			tracing.EndSpan(ctx, sc, err)
   809  		}()
   810  	}
   811  	req, err := client.GetKeysForKeyNamePreparer(ctx, resourceGroupName, resourceName, keyName)
   812  	if err != nil {
   813  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", nil, "Failure preparing request")
   814  		return
   815  	}
   816  
   817  	resp, err := client.GetKeysForKeyNameSender(req)
   818  	if err != nil {
   819  		result.Response = autorest.Response{Response: resp}
   820  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure sending request")
   821  		return
   822  	}
   823  
   824  	result, err = client.GetKeysForKeyNameResponder(resp)
   825  	if err != nil {
   826  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetKeysForKeyName", resp, "Failure responding to request")
   827  		return
   828  	}
   829  
   830  	return
   831  }
   832  
   833  // GetKeysForKeyNamePreparer prepares the GetKeysForKeyName request.
   834  func (client IotHubResourceClient) GetKeysForKeyNamePreparer(ctx context.Context, resourceGroupName string, resourceName string, keyName string) (*http.Request, error) {
   835  	pathParameters := map[string]interface{}{
   836  		"keyName":           autorest.Encode("path", keyName),
   837  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   838  		"resourceName":      autorest.Encode("path", resourceName),
   839  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   840  	}
   841  
   842  	const APIVersion = "2017-01-19"
   843  	queryParameters := map[string]interface{}{
   844  		"api-version": APIVersion,
   845  	}
   846  
   847  	preparer := autorest.CreatePreparer(
   848  		autorest.AsPost(),
   849  		autorest.WithBaseURL(client.BaseURI),
   850  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubKeys/{keyName}/listkeys", pathParameters),
   851  		autorest.WithQueryParameters(queryParameters))
   852  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   853  }
   854  
   855  // GetKeysForKeyNameSender sends the GetKeysForKeyName request. The method will close the
   856  // http.Response Body if it receives an error.
   857  func (client IotHubResourceClient) GetKeysForKeyNameSender(req *http.Request) (*http.Response, error) {
   858  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   859  }
   860  
   861  // GetKeysForKeyNameResponder handles the response to the GetKeysForKeyName request. The method always
   862  // closes the http.Response Body.
   863  func (client IotHubResourceClient) GetKeysForKeyNameResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRule, err error) {
   864  	err = autorest.Respond(
   865  		resp,
   866  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   867  		autorest.ByUnmarshallingJSON(&result),
   868  		autorest.ByClosing())
   869  	result.Response = autorest.Response{Response: resp}
   870  	return
   871  }
   872  
   873  // GetQuotaMetrics get the quota metrics for an IoT hub.
   874  // Parameters:
   875  // resourceGroupName - the name of the resource group that contains the IoT hub.
   876  // resourceName - the name of the IoT hub.
   877  func (client IotHubResourceClient) GetQuotaMetrics(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultPage, err error) {
   878  	if tracing.IsEnabled() {
   879  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics")
   880  		defer func() {
   881  			sc := -1
   882  			if result.ihqmilr.Response.Response != nil {
   883  				sc = result.ihqmilr.Response.Response.StatusCode
   884  			}
   885  			tracing.EndSpan(ctx, sc, err)
   886  		}()
   887  	}
   888  	result.fn = client.getQuotaMetricsNextResults
   889  	req, err := client.GetQuotaMetricsPreparer(ctx, resourceGroupName, resourceName)
   890  	if err != nil {
   891  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", nil, "Failure preparing request")
   892  		return
   893  	}
   894  
   895  	resp, err := client.GetQuotaMetricsSender(req)
   896  	if err != nil {
   897  		result.ihqmilr.Response = autorest.Response{Response: resp}
   898  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure sending request")
   899  		return
   900  	}
   901  
   902  	result.ihqmilr, err = client.GetQuotaMetricsResponder(resp)
   903  	if err != nil {
   904  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetQuotaMetrics", resp, "Failure responding to request")
   905  		return
   906  	}
   907  	if result.ihqmilr.hasNextLink() && result.ihqmilr.IsEmpty() {
   908  		err = result.NextWithContext(ctx)
   909  		return
   910  	}
   911  
   912  	return
   913  }
   914  
   915  // GetQuotaMetricsPreparer prepares the GetQuotaMetrics request.
   916  func (client IotHubResourceClient) GetQuotaMetricsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   917  	pathParameters := map[string]interface{}{
   918  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   919  		"resourceName":      autorest.Encode("path", resourceName),
   920  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   921  	}
   922  
   923  	const APIVersion = "2017-01-19"
   924  	queryParameters := map[string]interface{}{
   925  		"api-version": APIVersion,
   926  	}
   927  
   928  	preparer := autorest.CreatePreparer(
   929  		autorest.AsGet(),
   930  		autorest.WithBaseURL(client.BaseURI),
   931  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/quotaMetrics", pathParameters),
   932  		autorest.WithQueryParameters(queryParameters))
   933  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   934  }
   935  
   936  // GetQuotaMetricsSender sends the GetQuotaMetrics request. The method will close the
   937  // http.Response Body if it receives an error.
   938  func (client IotHubResourceClient) GetQuotaMetricsSender(req *http.Request) (*http.Response, error) {
   939  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   940  }
   941  
   942  // GetQuotaMetricsResponder handles the response to the GetQuotaMetrics request. The method always
   943  // closes the http.Response Body.
   944  func (client IotHubResourceClient) GetQuotaMetricsResponder(resp *http.Response) (result IotHubQuotaMetricInfoListResult, err error) {
   945  	err = autorest.Respond(
   946  		resp,
   947  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   948  		autorest.ByUnmarshallingJSON(&result),
   949  		autorest.ByClosing())
   950  	result.Response = autorest.Response{Response: resp}
   951  	return
   952  }
   953  
   954  // getQuotaMetricsNextResults retrieves the next set of results, if any.
   955  func (client IotHubResourceClient) getQuotaMetricsNextResults(ctx context.Context, lastResults IotHubQuotaMetricInfoListResult) (result IotHubQuotaMetricInfoListResult, err error) {
   956  	req, err := lastResults.iotHubQuotaMetricInfoListResultPreparer(ctx)
   957  	if err != nil {
   958  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", nil, "Failure preparing next results request")
   959  	}
   960  	if req == nil {
   961  		return
   962  	}
   963  	resp, err := client.GetQuotaMetricsSender(req)
   964  	if err != nil {
   965  		result.Response = autorest.Response{Response: resp}
   966  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure sending next results request")
   967  	}
   968  	result, err = client.GetQuotaMetricsResponder(resp)
   969  	if err != nil {
   970  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getQuotaMetricsNextResults", resp, "Failure responding to next results request")
   971  	}
   972  	return
   973  }
   974  
   975  // GetQuotaMetricsComplete enumerates all values, automatically crossing page boundaries as required.
   976  func (client IotHubResourceClient) GetQuotaMetricsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubQuotaMetricInfoListResultIterator, err error) {
   977  	if tracing.IsEnabled() {
   978  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetQuotaMetrics")
   979  		defer func() {
   980  			sc := -1
   981  			if result.Response().Response.Response != nil {
   982  				sc = result.page.Response().Response.Response.StatusCode
   983  			}
   984  			tracing.EndSpan(ctx, sc, err)
   985  		}()
   986  	}
   987  	result.page, err = client.GetQuotaMetrics(ctx, resourceGroupName, resourceName)
   988  	return
   989  }
   990  
   991  // GetStats get the statistics from an IoT hub.
   992  // Parameters:
   993  // resourceGroupName - the name of the resource group that contains the IoT hub.
   994  // resourceName - the name of the IoT hub.
   995  func (client IotHubResourceClient) GetStats(ctx context.Context, resourceGroupName string, resourceName string) (result RegistryStatistics, err error) {
   996  	if tracing.IsEnabled() {
   997  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetStats")
   998  		defer func() {
   999  			sc := -1
  1000  			if result.Response.Response != nil {
  1001  				sc = result.Response.Response.StatusCode
  1002  			}
  1003  			tracing.EndSpan(ctx, sc, err)
  1004  		}()
  1005  	}
  1006  	req, err := client.GetStatsPreparer(ctx, resourceGroupName, resourceName)
  1007  	if err != nil {
  1008  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", nil, "Failure preparing request")
  1009  		return
  1010  	}
  1011  
  1012  	resp, err := client.GetStatsSender(req)
  1013  	if err != nil {
  1014  		result.Response = autorest.Response{Response: resp}
  1015  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure sending request")
  1016  		return
  1017  	}
  1018  
  1019  	result, err = client.GetStatsResponder(resp)
  1020  	if err != nil {
  1021  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetStats", resp, "Failure responding to request")
  1022  		return
  1023  	}
  1024  
  1025  	return
  1026  }
  1027  
  1028  // GetStatsPreparer prepares the GetStats request.
  1029  func (client IotHubResourceClient) GetStatsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1030  	pathParameters := map[string]interface{}{
  1031  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1032  		"resourceName":      autorest.Encode("path", resourceName),
  1033  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1034  	}
  1035  
  1036  	const APIVersion = "2017-01-19"
  1037  	queryParameters := map[string]interface{}{
  1038  		"api-version": APIVersion,
  1039  	}
  1040  
  1041  	preparer := autorest.CreatePreparer(
  1042  		autorest.AsGet(),
  1043  		autorest.WithBaseURL(client.BaseURI),
  1044  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/IotHubStats", pathParameters),
  1045  		autorest.WithQueryParameters(queryParameters))
  1046  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1047  }
  1048  
  1049  // GetStatsSender sends the GetStats request. The method will close the
  1050  // http.Response Body if it receives an error.
  1051  func (client IotHubResourceClient) GetStatsSender(req *http.Request) (*http.Response, error) {
  1052  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1053  }
  1054  
  1055  // GetStatsResponder handles the response to the GetStats request. The method always
  1056  // closes the http.Response Body.
  1057  func (client IotHubResourceClient) GetStatsResponder(resp *http.Response) (result RegistryStatistics, err error) {
  1058  	err = autorest.Respond(
  1059  		resp,
  1060  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1061  		autorest.ByUnmarshallingJSON(&result),
  1062  		autorest.ByClosing())
  1063  	result.Response = autorest.Response{Response: resp}
  1064  	return
  1065  }
  1066  
  1067  // GetValidSkus get the list of valid SKUs for an IoT hub.
  1068  // Parameters:
  1069  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1070  // resourceName - the name of the IoT hub.
  1071  func (client IotHubResourceClient) GetValidSkus(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultPage, err error) {
  1072  	if tracing.IsEnabled() {
  1073  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus")
  1074  		defer func() {
  1075  			sc := -1
  1076  			if result.ihsdlr.Response.Response != nil {
  1077  				sc = result.ihsdlr.Response.Response.StatusCode
  1078  			}
  1079  			tracing.EndSpan(ctx, sc, err)
  1080  		}()
  1081  	}
  1082  	result.fn = client.getValidSkusNextResults
  1083  	req, err := client.GetValidSkusPreparer(ctx, resourceGroupName, resourceName)
  1084  	if err != nil {
  1085  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", nil, "Failure preparing request")
  1086  		return
  1087  	}
  1088  
  1089  	resp, err := client.GetValidSkusSender(req)
  1090  	if err != nil {
  1091  		result.ihsdlr.Response = autorest.Response{Response: resp}
  1092  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure sending request")
  1093  		return
  1094  	}
  1095  
  1096  	result.ihsdlr, err = client.GetValidSkusResponder(resp)
  1097  	if err != nil {
  1098  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "GetValidSkus", resp, "Failure responding to request")
  1099  		return
  1100  	}
  1101  	if result.ihsdlr.hasNextLink() && result.ihsdlr.IsEmpty() {
  1102  		err = result.NextWithContext(ctx)
  1103  		return
  1104  	}
  1105  
  1106  	return
  1107  }
  1108  
  1109  // GetValidSkusPreparer prepares the GetValidSkus request.
  1110  func (client IotHubResourceClient) GetValidSkusPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1111  	pathParameters := map[string]interface{}{
  1112  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1113  		"resourceName":      autorest.Encode("path", resourceName),
  1114  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1115  	}
  1116  
  1117  	const APIVersion = "2017-01-19"
  1118  	queryParameters := map[string]interface{}{
  1119  		"api-version": APIVersion,
  1120  	}
  1121  
  1122  	preparer := autorest.CreatePreparer(
  1123  		autorest.AsGet(),
  1124  		autorest.WithBaseURL(client.BaseURI),
  1125  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/skus", pathParameters),
  1126  		autorest.WithQueryParameters(queryParameters))
  1127  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1128  }
  1129  
  1130  // GetValidSkusSender sends the GetValidSkus request. The method will close the
  1131  // http.Response Body if it receives an error.
  1132  func (client IotHubResourceClient) GetValidSkusSender(req *http.Request) (*http.Response, error) {
  1133  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1134  }
  1135  
  1136  // GetValidSkusResponder handles the response to the GetValidSkus request. The method always
  1137  // closes the http.Response Body.
  1138  func (client IotHubResourceClient) GetValidSkusResponder(resp *http.Response) (result IotHubSkuDescriptionListResult, err error) {
  1139  	err = autorest.Respond(
  1140  		resp,
  1141  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1142  		autorest.ByUnmarshallingJSON(&result),
  1143  		autorest.ByClosing())
  1144  	result.Response = autorest.Response{Response: resp}
  1145  	return
  1146  }
  1147  
  1148  // getValidSkusNextResults retrieves the next set of results, if any.
  1149  func (client IotHubResourceClient) getValidSkusNextResults(ctx context.Context, lastResults IotHubSkuDescriptionListResult) (result IotHubSkuDescriptionListResult, err error) {
  1150  	req, err := lastResults.iotHubSkuDescriptionListResultPreparer(ctx)
  1151  	if err != nil {
  1152  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", nil, "Failure preparing next results request")
  1153  	}
  1154  	if req == nil {
  1155  		return
  1156  	}
  1157  	resp, err := client.GetValidSkusSender(req)
  1158  	if err != nil {
  1159  		result.Response = autorest.Response{Response: resp}
  1160  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure sending next results request")
  1161  	}
  1162  	result, err = client.GetValidSkusResponder(resp)
  1163  	if err != nil {
  1164  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "getValidSkusNextResults", resp, "Failure responding to next results request")
  1165  	}
  1166  	return
  1167  }
  1168  
  1169  // GetValidSkusComplete enumerates all values, automatically crossing page boundaries as required.
  1170  func (client IotHubResourceClient) GetValidSkusComplete(ctx context.Context, resourceGroupName string, resourceName string) (result IotHubSkuDescriptionListResultIterator, err error) {
  1171  	if tracing.IsEnabled() {
  1172  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.GetValidSkus")
  1173  		defer func() {
  1174  			sc := -1
  1175  			if result.Response().Response.Response != nil {
  1176  				sc = result.page.Response().Response.Response.StatusCode
  1177  			}
  1178  			tracing.EndSpan(ctx, sc, err)
  1179  		}()
  1180  	}
  1181  	result.page, err = client.GetValidSkus(ctx, resourceGroupName, resourceName)
  1182  	return
  1183  }
  1184  
  1185  // ImportDevices import, update, or delete device identities in the IoT hub identity registry from a blob. For more
  1186  // information, see:
  1187  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry#import-and-export-device-identities.
  1188  // Parameters:
  1189  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1190  // resourceName - the name of the IoT hub.
  1191  // importDevicesParameters - the parameters that specify the import devices operation.
  1192  func (client IotHubResourceClient) ImportDevices(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (result JobResponse, err error) {
  1193  	if tracing.IsEnabled() {
  1194  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ImportDevices")
  1195  		defer func() {
  1196  			sc := -1
  1197  			if result.Response.Response != nil {
  1198  				sc = result.Response.Response.StatusCode
  1199  			}
  1200  			tracing.EndSpan(ctx, sc, err)
  1201  		}()
  1202  	}
  1203  	if err := validation.Validate([]validation.Validation{
  1204  		{TargetValue: importDevicesParameters,
  1205  			Constraints: []validation.Constraint{{Target: "importDevicesParameters.InputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil},
  1206  				{Target: "importDevicesParameters.OutputBlobContainerURI", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1207  		return result, validation.NewError("devices.IotHubResourceClient", "ImportDevices", err.Error())
  1208  	}
  1209  
  1210  	req, err := client.ImportDevicesPreparer(ctx, resourceGroupName, resourceName, importDevicesParameters)
  1211  	if err != nil {
  1212  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", nil, "Failure preparing request")
  1213  		return
  1214  	}
  1215  
  1216  	resp, err := client.ImportDevicesSender(req)
  1217  	if err != nil {
  1218  		result.Response = autorest.Response{Response: resp}
  1219  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure sending request")
  1220  		return
  1221  	}
  1222  
  1223  	result, err = client.ImportDevicesResponder(resp)
  1224  	if err != nil {
  1225  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ImportDevices", resp, "Failure responding to request")
  1226  		return
  1227  	}
  1228  
  1229  	return
  1230  }
  1231  
  1232  // ImportDevicesPreparer prepares the ImportDevices request.
  1233  func (client IotHubResourceClient) ImportDevicesPreparer(ctx context.Context, resourceGroupName string, resourceName string, importDevicesParameters ImportDevicesRequest) (*http.Request, error) {
  1234  	pathParameters := map[string]interface{}{
  1235  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1236  		"resourceName":      autorest.Encode("path", resourceName),
  1237  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1238  	}
  1239  
  1240  	const APIVersion = "2017-01-19"
  1241  	queryParameters := map[string]interface{}{
  1242  		"api-version": APIVersion,
  1243  	}
  1244  
  1245  	preparer := autorest.CreatePreparer(
  1246  		autorest.AsContentType("application/json; charset=utf-8"),
  1247  		autorest.AsPost(),
  1248  		autorest.WithBaseURL(client.BaseURI),
  1249  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/importDevices", pathParameters),
  1250  		autorest.WithJSON(importDevicesParameters),
  1251  		autorest.WithQueryParameters(queryParameters))
  1252  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1253  }
  1254  
  1255  // ImportDevicesSender sends the ImportDevices request. The method will close the
  1256  // http.Response Body if it receives an error.
  1257  func (client IotHubResourceClient) ImportDevicesSender(req *http.Request) (*http.Response, error) {
  1258  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1259  }
  1260  
  1261  // ImportDevicesResponder handles the response to the ImportDevices request. The method always
  1262  // closes the http.Response Body.
  1263  func (client IotHubResourceClient) ImportDevicesResponder(resp *http.Response) (result JobResponse, err error) {
  1264  	err = autorest.Respond(
  1265  		resp,
  1266  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1267  		autorest.ByUnmarshallingJSON(&result),
  1268  		autorest.ByClosing())
  1269  	result.Response = autorest.Response{Response: resp}
  1270  	return
  1271  }
  1272  
  1273  // ListByResourceGroup get all the IoT hubs in a resource group.
  1274  // Parameters:
  1275  // resourceGroupName - the name of the resource group that contains the IoT hubs.
  1276  func (client IotHubResourceClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultPage, err error) {
  1277  	if tracing.IsEnabled() {
  1278  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup")
  1279  		defer func() {
  1280  			sc := -1
  1281  			if result.ihdlr.Response.Response != nil {
  1282  				sc = result.ihdlr.Response.Response.StatusCode
  1283  			}
  1284  			tracing.EndSpan(ctx, sc, err)
  1285  		}()
  1286  	}
  1287  	result.fn = client.listByResourceGroupNextResults
  1288  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
  1289  	if err != nil {
  1290  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", nil, "Failure preparing request")
  1291  		return
  1292  	}
  1293  
  1294  	resp, err := client.ListByResourceGroupSender(req)
  1295  	if err != nil {
  1296  		result.ihdlr.Response = autorest.Response{Response: resp}
  1297  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure sending request")
  1298  		return
  1299  	}
  1300  
  1301  	result.ihdlr, err = client.ListByResourceGroupResponder(resp)
  1302  	if err != nil {
  1303  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListByResourceGroup", resp, "Failure responding to request")
  1304  		return
  1305  	}
  1306  	if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() {
  1307  		err = result.NextWithContext(ctx)
  1308  		return
  1309  	}
  1310  
  1311  	return
  1312  }
  1313  
  1314  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
  1315  func (client IotHubResourceClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
  1316  	pathParameters := map[string]interface{}{
  1317  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1318  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1319  	}
  1320  
  1321  	const APIVersion = "2017-01-19"
  1322  	queryParameters := map[string]interface{}{
  1323  		"api-version": APIVersion,
  1324  	}
  1325  
  1326  	preparer := autorest.CreatePreparer(
  1327  		autorest.AsGet(),
  1328  		autorest.WithBaseURL(client.BaseURI),
  1329  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs", pathParameters),
  1330  		autorest.WithQueryParameters(queryParameters))
  1331  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1332  }
  1333  
  1334  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
  1335  // http.Response Body if it receives an error.
  1336  func (client IotHubResourceClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
  1337  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1338  }
  1339  
  1340  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
  1341  // closes the http.Response Body.
  1342  func (client IotHubResourceClient) ListByResourceGroupResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) {
  1343  	err = autorest.Respond(
  1344  		resp,
  1345  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1346  		autorest.ByUnmarshallingJSON(&result),
  1347  		autorest.ByClosing())
  1348  	result.Response = autorest.Response{Response: resp}
  1349  	return
  1350  }
  1351  
  1352  // listByResourceGroupNextResults retrieves the next set of results, if any.
  1353  func (client IotHubResourceClient) listByResourceGroupNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) {
  1354  	req, err := lastResults.iotHubDescriptionListResultPreparer(ctx)
  1355  	if err != nil {
  1356  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
  1357  	}
  1358  	if req == nil {
  1359  		return
  1360  	}
  1361  	resp, err := client.ListByResourceGroupSender(req)
  1362  	if err != nil {
  1363  		result.Response = autorest.Response{Response: resp}
  1364  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
  1365  	}
  1366  	result, err = client.ListByResourceGroupResponder(resp)
  1367  	if err != nil {
  1368  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
  1369  	}
  1370  	return
  1371  }
  1372  
  1373  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
  1374  func (client IotHubResourceClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result IotHubDescriptionListResultIterator, err error) {
  1375  	if tracing.IsEnabled() {
  1376  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListByResourceGroup")
  1377  		defer func() {
  1378  			sc := -1
  1379  			if result.Response().Response.Response != nil {
  1380  				sc = result.page.Response().Response.Response.StatusCode
  1381  			}
  1382  			tracing.EndSpan(ctx, sc, err)
  1383  		}()
  1384  	}
  1385  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
  1386  	return
  1387  }
  1388  
  1389  // ListBySubscription get all the IoT hubs in a subscription.
  1390  func (client IotHubResourceClient) ListBySubscription(ctx context.Context) (result IotHubDescriptionListResultPage, err error) {
  1391  	if tracing.IsEnabled() {
  1392  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription")
  1393  		defer func() {
  1394  			sc := -1
  1395  			if result.ihdlr.Response.Response != nil {
  1396  				sc = result.ihdlr.Response.Response.StatusCode
  1397  			}
  1398  			tracing.EndSpan(ctx, sc, err)
  1399  		}()
  1400  	}
  1401  	result.fn = client.listBySubscriptionNextResults
  1402  	req, err := client.ListBySubscriptionPreparer(ctx)
  1403  	if err != nil {
  1404  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", nil, "Failure preparing request")
  1405  		return
  1406  	}
  1407  
  1408  	resp, err := client.ListBySubscriptionSender(req)
  1409  	if err != nil {
  1410  		result.ihdlr.Response = autorest.Response{Response: resp}
  1411  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure sending request")
  1412  		return
  1413  	}
  1414  
  1415  	result.ihdlr, err = client.ListBySubscriptionResponder(resp)
  1416  	if err != nil {
  1417  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListBySubscription", resp, "Failure responding to request")
  1418  		return
  1419  	}
  1420  	if result.ihdlr.hasNextLink() && result.ihdlr.IsEmpty() {
  1421  		err = result.NextWithContext(ctx)
  1422  		return
  1423  	}
  1424  
  1425  	return
  1426  }
  1427  
  1428  // ListBySubscriptionPreparer prepares the ListBySubscription request.
  1429  func (client IotHubResourceClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) {
  1430  	pathParameters := map[string]interface{}{
  1431  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
  1432  	}
  1433  
  1434  	const APIVersion = "2017-01-19"
  1435  	queryParameters := map[string]interface{}{
  1436  		"api-version": APIVersion,
  1437  	}
  1438  
  1439  	preparer := autorest.CreatePreparer(
  1440  		autorest.AsGet(),
  1441  		autorest.WithBaseURL(client.BaseURI),
  1442  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Devices/IotHubs", pathParameters),
  1443  		autorest.WithQueryParameters(queryParameters))
  1444  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1445  }
  1446  
  1447  // ListBySubscriptionSender sends the ListBySubscription request. The method will close the
  1448  // http.Response Body if it receives an error.
  1449  func (client IotHubResourceClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
  1450  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1451  }
  1452  
  1453  // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
  1454  // closes the http.Response Body.
  1455  func (client IotHubResourceClient) ListBySubscriptionResponder(resp *http.Response) (result IotHubDescriptionListResult, err error) {
  1456  	err = autorest.Respond(
  1457  		resp,
  1458  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1459  		autorest.ByUnmarshallingJSON(&result),
  1460  		autorest.ByClosing())
  1461  	result.Response = autorest.Response{Response: resp}
  1462  	return
  1463  }
  1464  
  1465  // listBySubscriptionNextResults retrieves the next set of results, if any.
  1466  func (client IotHubResourceClient) listBySubscriptionNextResults(ctx context.Context, lastResults IotHubDescriptionListResult) (result IotHubDescriptionListResult, err error) {
  1467  	req, err := lastResults.iotHubDescriptionListResultPreparer(ctx)
  1468  	if err != nil {
  1469  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
  1470  	}
  1471  	if req == nil {
  1472  		return
  1473  	}
  1474  	resp, err := client.ListBySubscriptionSender(req)
  1475  	if err != nil {
  1476  		result.Response = autorest.Response{Response: resp}
  1477  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
  1478  	}
  1479  	result, err = client.ListBySubscriptionResponder(resp)
  1480  	if err != nil {
  1481  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
  1482  	}
  1483  	return
  1484  }
  1485  
  1486  // ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
  1487  func (client IotHubResourceClient) ListBySubscriptionComplete(ctx context.Context) (result IotHubDescriptionListResultIterator, err error) {
  1488  	if tracing.IsEnabled() {
  1489  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListBySubscription")
  1490  		defer func() {
  1491  			sc := -1
  1492  			if result.Response().Response.Response != nil {
  1493  				sc = result.page.Response().Response.Response.StatusCode
  1494  			}
  1495  			tracing.EndSpan(ctx, sc, err)
  1496  		}()
  1497  	}
  1498  	result.page, err = client.ListBySubscription(ctx)
  1499  	return
  1500  }
  1501  
  1502  // ListEventHubConsumerGroups get a list of the consumer groups in the Event Hub-compatible device-to-cloud endpoint in
  1503  // an IoT hub.
  1504  // Parameters:
  1505  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1506  // resourceName - the name of the IoT hub.
  1507  // eventHubEndpointName - the name of the Event Hub-compatible endpoint.
  1508  func (client IotHubResourceClient) ListEventHubConsumerGroups(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultPage, err error) {
  1509  	if tracing.IsEnabled() {
  1510  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups")
  1511  		defer func() {
  1512  			sc := -1
  1513  			if result.ehcglr.Response.Response != nil {
  1514  				sc = result.ehcglr.Response.Response.StatusCode
  1515  			}
  1516  			tracing.EndSpan(ctx, sc, err)
  1517  		}()
  1518  	}
  1519  	result.fn = client.listEventHubConsumerGroupsNextResults
  1520  	req, err := client.ListEventHubConsumerGroupsPreparer(ctx, resourceGroupName, resourceName, eventHubEndpointName)
  1521  	if err != nil {
  1522  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", nil, "Failure preparing request")
  1523  		return
  1524  	}
  1525  
  1526  	resp, err := client.ListEventHubConsumerGroupsSender(req)
  1527  	if err != nil {
  1528  		result.ehcglr.Response = autorest.Response{Response: resp}
  1529  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure sending request")
  1530  		return
  1531  	}
  1532  
  1533  	result.ehcglr, err = client.ListEventHubConsumerGroupsResponder(resp)
  1534  	if err != nil {
  1535  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListEventHubConsumerGroups", resp, "Failure responding to request")
  1536  		return
  1537  	}
  1538  	if result.ehcglr.hasNextLink() && result.ehcglr.IsEmpty() {
  1539  		err = result.NextWithContext(ctx)
  1540  		return
  1541  	}
  1542  
  1543  	return
  1544  }
  1545  
  1546  // ListEventHubConsumerGroupsPreparer prepares the ListEventHubConsumerGroups request.
  1547  func (client IotHubResourceClient) ListEventHubConsumerGroupsPreparer(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (*http.Request, error) {
  1548  	pathParameters := map[string]interface{}{
  1549  		"eventHubEndpointName": autorest.Encode("path", eventHubEndpointName),
  1550  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
  1551  		"resourceName":         autorest.Encode("path", resourceName),
  1552  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
  1553  	}
  1554  
  1555  	const APIVersion = "2017-01-19"
  1556  	queryParameters := map[string]interface{}{
  1557  		"api-version": APIVersion,
  1558  	}
  1559  
  1560  	preparer := autorest.CreatePreparer(
  1561  		autorest.AsGet(),
  1562  		autorest.WithBaseURL(client.BaseURI),
  1563  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/eventHubEndpoints/{eventHubEndpointName}/ConsumerGroups", pathParameters),
  1564  		autorest.WithQueryParameters(queryParameters))
  1565  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1566  }
  1567  
  1568  // ListEventHubConsumerGroupsSender sends the ListEventHubConsumerGroups request. The method will close the
  1569  // http.Response Body if it receives an error.
  1570  func (client IotHubResourceClient) ListEventHubConsumerGroupsSender(req *http.Request) (*http.Response, error) {
  1571  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1572  }
  1573  
  1574  // ListEventHubConsumerGroupsResponder handles the response to the ListEventHubConsumerGroups request. The method always
  1575  // closes the http.Response Body.
  1576  func (client IotHubResourceClient) ListEventHubConsumerGroupsResponder(resp *http.Response) (result EventHubConsumerGroupsListResult, err error) {
  1577  	err = autorest.Respond(
  1578  		resp,
  1579  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1580  		autorest.ByUnmarshallingJSON(&result),
  1581  		autorest.ByClosing())
  1582  	result.Response = autorest.Response{Response: resp}
  1583  	return
  1584  }
  1585  
  1586  // listEventHubConsumerGroupsNextResults retrieves the next set of results, if any.
  1587  func (client IotHubResourceClient) listEventHubConsumerGroupsNextResults(ctx context.Context, lastResults EventHubConsumerGroupsListResult) (result EventHubConsumerGroupsListResult, err error) {
  1588  	req, err := lastResults.eventHubConsumerGroupsListResultPreparer(ctx)
  1589  	if err != nil {
  1590  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", nil, "Failure preparing next results request")
  1591  	}
  1592  	if req == nil {
  1593  		return
  1594  	}
  1595  	resp, err := client.ListEventHubConsumerGroupsSender(req)
  1596  	if err != nil {
  1597  		result.Response = autorest.Response{Response: resp}
  1598  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure sending next results request")
  1599  	}
  1600  	result, err = client.ListEventHubConsumerGroupsResponder(resp)
  1601  	if err != nil {
  1602  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listEventHubConsumerGroupsNextResults", resp, "Failure responding to next results request")
  1603  	}
  1604  	return
  1605  }
  1606  
  1607  // ListEventHubConsumerGroupsComplete enumerates all values, automatically crossing page boundaries as required.
  1608  func (client IotHubResourceClient) ListEventHubConsumerGroupsComplete(ctx context.Context, resourceGroupName string, resourceName string, eventHubEndpointName string) (result EventHubConsumerGroupsListResultIterator, err error) {
  1609  	if tracing.IsEnabled() {
  1610  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListEventHubConsumerGroups")
  1611  		defer func() {
  1612  			sc := -1
  1613  			if result.Response().Response.Response != nil {
  1614  				sc = result.page.Response().Response.Response.StatusCode
  1615  			}
  1616  			tracing.EndSpan(ctx, sc, err)
  1617  		}()
  1618  	}
  1619  	result.page, err = client.ListEventHubConsumerGroups(ctx, resourceGroupName, resourceName, eventHubEndpointName)
  1620  	return
  1621  }
  1622  
  1623  // ListJobs get a list of all the jobs in an IoT hub. For more information, see:
  1624  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-identity-registry.
  1625  // Parameters:
  1626  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1627  // resourceName - the name of the IoT hub.
  1628  func (client IotHubResourceClient) ListJobs(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultPage, err error) {
  1629  	if tracing.IsEnabled() {
  1630  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs")
  1631  		defer func() {
  1632  			sc := -1
  1633  			if result.jrlr.Response.Response != nil {
  1634  				sc = result.jrlr.Response.Response.StatusCode
  1635  			}
  1636  			tracing.EndSpan(ctx, sc, err)
  1637  		}()
  1638  	}
  1639  	result.fn = client.listJobsNextResults
  1640  	req, err := client.ListJobsPreparer(ctx, resourceGroupName, resourceName)
  1641  	if err != nil {
  1642  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", nil, "Failure preparing request")
  1643  		return
  1644  	}
  1645  
  1646  	resp, err := client.ListJobsSender(req)
  1647  	if err != nil {
  1648  		result.jrlr.Response = autorest.Response{Response: resp}
  1649  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure sending request")
  1650  		return
  1651  	}
  1652  
  1653  	result.jrlr, err = client.ListJobsResponder(resp)
  1654  	if err != nil {
  1655  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListJobs", resp, "Failure responding to request")
  1656  		return
  1657  	}
  1658  	if result.jrlr.hasNextLink() && result.jrlr.IsEmpty() {
  1659  		err = result.NextWithContext(ctx)
  1660  		return
  1661  	}
  1662  
  1663  	return
  1664  }
  1665  
  1666  // ListJobsPreparer prepares the ListJobs request.
  1667  func (client IotHubResourceClient) ListJobsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1668  	pathParameters := map[string]interface{}{
  1669  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1670  		"resourceName":      autorest.Encode("path", resourceName),
  1671  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1672  	}
  1673  
  1674  	const APIVersion = "2017-01-19"
  1675  	queryParameters := map[string]interface{}{
  1676  		"api-version": APIVersion,
  1677  	}
  1678  
  1679  	preparer := autorest.CreatePreparer(
  1680  		autorest.AsGet(),
  1681  		autorest.WithBaseURL(client.BaseURI),
  1682  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/jobs", pathParameters),
  1683  		autorest.WithQueryParameters(queryParameters))
  1684  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1685  }
  1686  
  1687  // ListJobsSender sends the ListJobs request. The method will close the
  1688  // http.Response Body if it receives an error.
  1689  func (client IotHubResourceClient) ListJobsSender(req *http.Request) (*http.Response, error) {
  1690  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1691  }
  1692  
  1693  // ListJobsResponder handles the response to the ListJobs request. The method always
  1694  // closes the http.Response Body.
  1695  func (client IotHubResourceClient) ListJobsResponder(resp *http.Response) (result JobResponseListResult, err error) {
  1696  	err = autorest.Respond(
  1697  		resp,
  1698  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1699  		autorest.ByUnmarshallingJSON(&result),
  1700  		autorest.ByClosing())
  1701  	result.Response = autorest.Response{Response: resp}
  1702  	return
  1703  }
  1704  
  1705  // listJobsNextResults retrieves the next set of results, if any.
  1706  func (client IotHubResourceClient) listJobsNextResults(ctx context.Context, lastResults JobResponseListResult) (result JobResponseListResult, err error) {
  1707  	req, err := lastResults.jobResponseListResultPreparer(ctx)
  1708  	if err != nil {
  1709  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", nil, "Failure preparing next results request")
  1710  	}
  1711  	if req == nil {
  1712  		return
  1713  	}
  1714  	resp, err := client.ListJobsSender(req)
  1715  	if err != nil {
  1716  		result.Response = autorest.Response{Response: resp}
  1717  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure sending next results request")
  1718  	}
  1719  	result, err = client.ListJobsResponder(resp)
  1720  	if err != nil {
  1721  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listJobsNextResults", resp, "Failure responding to next results request")
  1722  	}
  1723  	return
  1724  }
  1725  
  1726  // ListJobsComplete enumerates all values, automatically crossing page boundaries as required.
  1727  func (client IotHubResourceClient) ListJobsComplete(ctx context.Context, resourceGroupName string, resourceName string) (result JobResponseListResultIterator, err error) {
  1728  	if tracing.IsEnabled() {
  1729  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListJobs")
  1730  		defer func() {
  1731  			sc := -1
  1732  			if result.Response().Response.Response != nil {
  1733  				sc = result.page.Response().Response.Response.StatusCode
  1734  			}
  1735  			tracing.EndSpan(ctx, sc, err)
  1736  		}()
  1737  	}
  1738  	result.page, err = client.ListJobs(ctx, resourceGroupName, resourceName)
  1739  	return
  1740  }
  1741  
  1742  // ListKeys get the security metadata for an IoT hub. For more information, see:
  1743  // https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-security.
  1744  // Parameters:
  1745  // resourceGroupName - the name of the resource group that contains the IoT hub.
  1746  // resourceName - the name of the IoT hub.
  1747  func (client IotHubResourceClient) ListKeys(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultPage, err error) {
  1748  	if tracing.IsEnabled() {
  1749  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys")
  1750  		defer func() {
  1751  			sc := -1
  1752  			if result.sasarlr.Response.Response != nil {
  1753  				sc = result.sasarlr.Response.Response.StatusCode
  1754  			}
  1755  			tracing.EndSpan(ctx, sc, err)
  1756  		}()
  1757  	}
  1758  	result.fn = client.listKeysNextResults
  1759  	req, err := client.ListKeysPreparer(ctx, resourceGroupName, resourceName)
  1760  	if err != nil {
  1761  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", nil, "Failure preparing request")
  1762  		return
  1763  	}
  1764  
  1765  	resp, err := client.ListKeysSender(req)
  1766  	if err != nil {
  1767  		result.sasarlr.Response = autorest.Response{Response: resp}
  1768  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure sending request")
  1769  		return
  1770  	}
  1771  
  1772  	result.sasarlr, err = client.ListKeysResponder(resp)
  1773  	if err != nil {
  1774  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "ListKeys", resp, "Failure responding to request")
  1775  		return
  1776  	}
  1777  	if result.sasarlr.hasNextLink() && result.sasarlr.IsEmpty() {
  1778  		err = result.NextWithContext(ctx)
  1779  		return
  1780  	}
  1781  
  1782  	return
  1783  }
  1784  
  1785  // ListKeysPreparer prepares the ListKeys request.
  1786  func (client IotHubResourceClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1787  	pathParameters := map[string]interface{}{
  1788  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1789  		"resourceName":      autorest.Encode("path", resourceName),
  1790  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1791  	}
  1792  
  1793  	const APIVersion = "2017-01-19"
  1794  	queryParameters := map[string]interface{}{
  1795  		"api-version": APIVersion,
  1796  	}
  1797  
  1798  	preparer := autorest.CreatePreparer(
  1799  		autorest.AsPost(),
  1800  		autorest.WithBaseURL(client.BaseURI),
  1801  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/IotHubs/{resourceName}/listkeys", pathParameters),
  1802  		autorest.WithQueryParameters(queryParameters))
  1803  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1804  }
  1805  
  1806  // ListKeysSender sends the ListKeys request. The method will close the
  1807  // http.Response Body if it receives an error.
  1808  func (client IotHubResourceClient) ListKeysSender(req *http.Request) (*http.Response, error) {
  1809  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1810  }
  1811  
  1812  // ListKeysResponder handles the response to the ListKeys request. The method always
  1813  // closes the http.Response Body.
  1814  func (client IotHubResourceClient) ListKeysResponder(resp *http.Response) (result SharedAccessSignatureAuthorizationRuleListResult, err error) {
  1815  	err = autorest.Respond(
  1816  		resp,
  1817  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1818  		autorest.ByUnmarshallingJSON(&result),
  1819  		autorest.ByClosing())
  1820  	result.Response = autorest.Response{Response: resp}
  1821  	return
  1822  }
  1823  
  1824  // listKeysNextResults retrieves the next set of results, if any.
  1825  func (client IotHubResourceClient) listKeysNextResults(ctx context.Context, lastResults SharedAccessSignatureAuthorizationRuleListResult) (result SharedAccessSignatureAuthorizationRuleListResult, err error) {
  1826  	req, err := lastResults.sharedAccessSignatureAuthorizationRuleListResultPreparer(ctx)
  1827  	if err != nil {
  1828  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", nil, "Failure preparing next results request")
  1829  	}
  1830  	if req == nil {
  1831  		return
  1832  	}
  1833  	resp, err := client.ListKeysSender(req)
  1834  	if err != nil {
  1835  		result.Response = autorest.Response{Response: resp}
  1836  		return result, autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure sending next results request")
  1837  	}
  1838  	result, err = client.ListKeysResponder(resp)
  1839  	if err != nil {
  1840  		err = autorest.NewErrorWithError(err, "devices.IotHubResourceClient", "listKeysNextResults", resp, "Failure responding to next results request")
  1841  	}
  1842  	return
  1843  }
  1844  
  1845  // ListKeysComplete enumerates all values, automatically crossing page boundaries as required.
  1846  func (client IotHubResourceClient) ListKeysComplete(ctx context.Context, resourceGroupName string, resourceName string) (result SharedAccessSignatureAuthorizationRuleListResultIterator, err error) {
  1847  	if tracing.IsEnabled() {
  1848  		ctx = tracing.StartSpan(ctx, fqdn+"/IotHubResourceClient.ListKeys")
  1849  		defer func() {
  1850  			sc := -1
  1851  			if result.Response().Response.Response != nil {
  1852  				sc = result.page.Response().Response.Response.StatusCode
  1853  			}
  1854  			tracing.EndSpan(ctx, sc, err)
  1855  		}()
  1856  	}
  1857  	result.page, err = client.ListKeys(ctx, resourceGroupName, resourceName)
  1858  	return
  1859  }
  1860  

View as plain text