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

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

View as plain text