dpscertificate.go

Documentation: github.com/Azure/azure-sdk-for-go/services/provisioningservices/mgmt/2022-02-05/iothub

     1  package iothub
     2  
     3  // Copyright (c) Microsoft Corporation. All rights reserved.
     4  // Licensed under the MIT License. See License.txt in the project root for license information.
     5  //
     6  // Code generated by Microsoft (R) AutoRest Code Generator.
     7  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
     8  
     9  import (
    10  	"context"
    11  	"github.com/Azure/go-autorest/autorest"
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	"github.com/Azure/go-autorest/autorest/date"
    14  	"github.com/Azure/go-autorest/autorest/validation"
    15  	"github.com/Azure/go-autorest/tracing"
    16  	"net/http"
    17  )
    18  
    19  // DpsCertificateClient is the API for using the Azure IoT Hub Device Provisioning Service features.
    20  type DpsCertificateClient struct {
    21  	BaseClient
    22  }
    23  
    24  // NewDpsCertificateClient creates an instance of the DpsCertificateClient client.
    25  func NewDpsCertificateClient(subscriptionID string) DpsCertificateClient {
    26  	return NewDpsCertificateClientWithBaseURI(DefaultBaseURI, subscriptionID)
    27  }
    28  
    29  // NewDpsCertificateClientWithBaseURI creates an instance of the DpsCertificateClient client using a custom endpoint.
    30  // Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    31  func NewDpsCertificateClientWithBaseURI(baseURI string, subscriptionID string) DpsCertificateClient {
    32  	return DpsCertificateClient{NewWithBaseURI(baseURI, subscriptionID)}
    33  }
    34  
    35  // CreateOrUpdate add new certificate or update an existing certificate.
    36  // Parameters:
    37  // resourceGroupName - resource group identifier.
    38  // provisioningServiceName - the name of the provisioning service.
    39  // certificateName - the name of the certificate create or update.
    40  // certificateDescription - the certificate body.
    41  // ifMatch - eTag of the certificate. This is required to update an existing certificate, and ignored while
    42  // creating a brand new certificate.
    43  func (client DpsCertificateClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, provisioningServiceName string, certificateName string, certificateDescription CertificateResponse, ifMatch string) (result CertificateResponse, err error) {
    44  	if tracing.IsEnabled() {
    45  		ctx = tracing.StartSpan(ctx, fqdn+"/DpsCertificateClient.CreateOrUpdate")
    46  		defer func() {
    47  			sc := -1
    48  			if result.Response.Response != nil {
    49  				sc = result.Response.Response.StatusCode
    50  			}
    51  			tracing.EndSpan(ctx, sc, err)
    52  		}()
    53  	}
    54  	if err := validation.Validate([]validation.Validation{
    55  		{TargetValue: certificateName,
    56  			Constraints: []validation.Constraint{{Target: "certificateName", Name: validation.MaxLength, Rule: 256, Chain: nil}}}}); err != nil {
    57  		return result, validation.NewError("iothub.DpsCertificateClient", "CreateOrUpdate", err.Error())
    58  	}
    59  
    60  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, provisioningServiceName, certificateName, certificateDescription, ifMatch)
    61  	if err != nil {
    62  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "CreateOrUpdate", nil, "Failure preparing request")
    63  		return
    64  	}
    65  
    66  	resp, err := client.CreateOrUpdateSender(req)
    67  	if err != nil {
    68  		result.Response = autorest.Response{Response: resp}
    69  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "CreateOrUpdate", resp, "Failure sending request")
    70  		return
    71  	}
    72  
    73  	result, err = client.CreateOrUpdateResponder(resp)
    74  	if err != nil {
    75  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "CreateOrUpdate", resp, "Failure responding to request")
    76  		return
    77  	}
    78  
    79  	return
    80  }
    81  
    82  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    83  func (client DpsCertificateClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, provisioningServiceName string, certificateName string, certificateDescription CertificateResponse, ifMatch string) (*http.Request, error) {
    84  	pathParameters := map[string]interface{}{
    85  		"certificateName":         autorest.Encode("path", certificateName),
    86  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
    87  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
    88  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
    89  	}
    90  
    91  	const APIVersion = "2022-02-05"
    92  	queryParameters := map[string]interface{}{
    93  		"api-version": APIVersion,
    94  	}
    95  
    96  	certificateDescription.ID = nil
    97  	certificateDescription.Name = nil
    98  	certificateDescription.Etag = nil
    99  	certificateDescription.Type = nil
   100  	certificateDescription.SystemData = nil
   101  	preparer := autorest.CreatePreparer(
   102  		autorest.AsContentType("application/json; charset=utf-8"),
   103  		autorest.AsPut(),
   104  		autorest.WithBaseURL(client.BaseURI),
   105  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/certificates/{certificateName}", pathParameters),
   106  		autorest.WithJSON(certificateDescription),
   107  		autorest.WithQueryParameters(queryParameters))
   108  	if len(ifMatch) > 0 {
   109  		preparer = autorest.DecoratePreparer(preparer,
   110  			autorest.WithHeader("If-Match", autorest.String(ifMatch)))
   111  	}
   112  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   113  }
   114  
   115  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   116  // http.Response Body if it receives an error.
   117  func (client DpsCertificateClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
   118  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   119  }
   120  
   121  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   122  // closes the http.Response Body.
   123  func (client DpsCertificateClient) CreateOrUpdateResponder(resp *http.Response) (result CertificateResponse, err error) {
   124  	err = autorest.Respond(
   125  		resp,
   126  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   127  		autorest.ByUnmarshallingJSON(&result),
   128  		autorest.ByClosing())
   129  	result.Response = autorest.Response{Response: resp}
   130  	return
   131  }
   132  
   133  // Delete deletes the specified certificate associated with the Provisioning Service
   134  // Parameters:
   135  // resourceGroupName - resource group identifier.
   136  // ifMatch - eTag of the certificate
   137  // provisioningServiceName - the name of the provisioning service.
   138  // certificateName - this is a mandatory field, and is the logical name of the certificate that the
   139  // provisioning service will access by.
   140  // certificatename - this is optional, and it is the Common Name of the certificate.
   141  // certificaterawBytes - raw data within the certificate.
   142  // certificateisVerified - indicates if certificate has been verified by owner of the private key.
   143  // certificatepurpose - a description that mentions the purpose of the certificate.
   144  // certificatecreated - time the certificate is created.
   145  // certificatelastUpdated - time the certificate is last updated.
   146  // certificatehasPrivateKey - indicates if the certificate contains a private key.
   147  // certificatenonce - random number generated to indicate Proof of Possession.
   148  func (client DpsCertificateClient) Delete(ctx context.Context, resourceGroupName string, ifMatch string, provisioningServiceName string, certificateName string, certificatename string, certificaterawBytes []byte, certificateisVerified *bool, certificatepurpose CertificatePurpose, certificatecreated *date.Time, certificatelastUpdated *date.Time, certificatehasPrivateKey *bool, certificatenonce string) (result autorest.Response, err error) {
   149  	if tracing.IsEnabled() {
   150  		ctx = tracing.StartSpan(ctx, fqdn+"/DpsCertificateClient.Delete")
   151  		defer func() {
   152  			sc := -1
   153  			if result.Response != nil {
   154  				sc = result.Response.StatusCode
   155  			}
   156  			tracing.EndSpan(ctx, sc, err)
   157  		}()
   158  	}
   159  	req, err := client.DeletePreparer(ctx, resourceGroupName, ifMatch, provisioningServiceName, certificateName, certificatename, certificaterawBytes, certificateisVerified, certificatepurpose, certificatecreated, certificatelastUpdated, certificatehasPrivateKey, certificatenonce)
   160  	if err != nil {
   161  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "Delete", nil, "Failure preparing request")
   162  		return
   163  	}
   164  
   165  	resp, err := client.DeleteSender(req)
   166  	if err != nil {
   167  		result.Response = resp
   168  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "Delete", resp, "Failure sending request")
   169  		return
   170  	}
   171  
   172  	result, err = client.DeleteResponder(resp)
   173  	if err != nil {
   174  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "Delete", resp, "Failure responding to request")
   175  		return
   176  	}
   177  
   178  	return
   179  }
   180  
   181  // DeletePreparer prepares the Delete request.
   182  func (client DpsCertificateClient) DeletePreparer(ctx context.Context, resourceGroupName string, ifMatch string, provisioningServiceName string, certificateName string, certificatename string, certificaterawBytes []byte, certificateisVerified *bool, certificatepurpose CertificatePurpose, certificatecreated *date.Time, certificatelastUpdated *date.Time, certificatehasPrivateKey *bool, certificatenonce string) (*http.Request, error) {
   183  	pathParameters := map[string]interface{}{
   184  		"certificateName":         autorest.Encode("path", certificateName),
   185  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   186  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   187  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   188  	}
   189  
   190  	const APIVersion = "2022-02-05"
   191  	queryParameters := map[string]interface{}{
   192  		"api-version": APIVersion,
   193  	}
   194  	if len(certificatename) > 0 {
   195  		queryParameters["certificate.name"] = autorest.Encode("query", certificatename)
   196  	}
   197  	if certificaterawBytes != nil && len(certificaterawBytes) > 0 {
   198  		queryParameters["certificate.rawBytes"] = autorest.Encode("query", certificaterawBytes)
   199  	}
   200  	if certificateisVerified != nil {
   201  		queryParameters["certificate.isVerified"] = autorest.Encode("query", *certificateisVerified)
   202  	}
   203  	if len(string(certificatepurpose)) > 0 {
   204  		queryParameters["certificate.purpose"] = autorest.Encode("query", certificatepurpose)
   205  	}
   206  	if certificatecreated != nil {
   207  		queryParameters["certificate.created"] = autorest.Encode("query", *certificatecreated)
   208  	}
   209  	if certificatelastUpdated != nil {
   210  		queryParameters["certificate.lastUpdated"] = autorest.Encode("query", *certificatelastUpdated)
   211  	}
   212  	if certificatehasPrivateKey != nil {
   213  		queryParameters["certificate.hasPrivateKey"] = autorest.Encode("query", *certificatehasPrivateKey)
   214  	}
   215  	if len(certificatenonce) > 0 {
   216  		queryParameters["certificate.nonce"] = autorest.Encode("query", certificatenonce)
   217  	}
   218  
   219  	preparer := autorest.CreatePreparer(
   220  		autorest.AsDelete(),
   221  		autorest.WithBaseURL(client.BaseURI),
   222  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/certificates/{certificateName}", pathParameters),
   223  		autorest.WithQueryParameters(queryParameters),
   224  		autorest.WithHeader("If-Match", autorest.String(ifMatch)))
   225  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   226  }
   227  
   228  // DeleteSender sends the Delete request. The method will close the
   229  // http.Response Body if it receives an error.
   230  func (client DpsCertificateClient) DeleteSender(req *http.Request) (*http.Response, error) {
   231  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   232  }
   233  
   234  // DeleteResponder handles the response to the Delete request. The method always
   235  // closes the http.Response Body.
   236  func (client DpsCertificateClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   237  	err = autorest.Respond(
   238  		resp,
   239  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   240  		autorest.ByClosing())
   241  	result.Response = resp
   242  	return
   243  }
   244  
   245  // GenerateVerificationCode generate verification code for Proof of Possession.
   246  // Parameters:
   247  // certificateName - the mandatory logical name of the certificate, that the provisioning service uses to
   248  // access.
   249  // ifMatch - eTag of the certificate. This is required to update an existing certificate, and ignored while
   250  // creating a brand new certificate.
   251  // resourceGroupName - name of resource group.
   252  // provisioningServiceName - name of provisioning service.
   253  // certificatename - common Name for the certificate.
   254  // certificaterawBytes - raw data of certificate.
   255  // certificateisVerified - indicates if the certificate has been verified by owner of the private key.
   256  // certificatepurpose - description mentioning the purpose of the certificate.
   257  // certificatecreated - certificate creation time.
   258  // certificatelastUpdated - certificate last updated time.
   259  // certificatehasPrivateKey - indicates if the certificate contains private key.
   260  // certificatenonce - random number generated to indicate Proof of Possession.
   261  func (client DpsCertificateClient) GenerateVerificationCode(ctx context.Context, certificateName string, ifMatch string, resourceGroupName string, provisioningServiceName string, certificatename string, certificaterawBytes []byte, certificateisVerified *bool, certificatepurpose CertificatePurpose, certificatecreated *date.Time, certificatelastUpdated *date.Time, certificatehasPrivateKey *bool, certificatenonce string) (result VerificationCodeResponse, err error) {
   262  	if tracing.IsEnabled() {
   263  		ctx = tracing.StartSpan(ctx, fqdn+"/DpsCertificateClient.GenerateVerificationCode")
   264  		defer func() {
   265  			sc := -1
   266  			if result.Response.Response != nil {
   267  				sc = result.Response.Response.StatusCode
   268  			}
   269  			tracing.EndSpan(ctx, sc, err)
   270  		}()
   271  	}
   272  	req, err := client.GenerateVerificationCodePreparer(ctx, certificateName, ifMatch, resourceGroupName, provisioningServiceName, certificatename, certificaterawBytes, certificateisVerified, certificatepurpose, certificatecreated, certificatelastUpdated, certificatehasPrivateKey, certificatenonce)
   273  	if err != nil {
   274  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "GenerateVerificationCode", nil, "Failure preparing request")
   275  		return
   276  	}
   277  
   278  	resp, err := client.GenerateVerificationCodeSender(req)
   279  	if err != nil {
   280  		result.Response = autorest.Response{Response: resp}
   281  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "GenerateVerificationCode", resp, "Failure sending request")
   282  		return
   283  	}
   284  
   285  	result, err = client.GenerateVerificationCodeResponder(resp)
   286  	if err != nil {
   287  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "GenerateVerificationCode", resp, "Failure responding to request")
   288  		return
   289  	}
   290  
   291  	return
   292  }
   293  
   294  // GenerateVerificationCodePreparer prepares the GenerateVerificationCode request.
   295  func (client DpsCertificateClient) GenerateVerificationCodePreparer(ctx context.Context, certificateName string, ifMatch string, resourceGroupName string, provisioningServiceName string, certificatename string, certificaterawBytes []byte, certificateisVerified *bool, certificatepurpose CertificatePurpose, certificatecreated *date.Time, certificatelastUpdated *date.Time, certificatehasPrivateKey *bool, certificatenonce string) (*http.Request, error) {
   296  	pathParameters := map[string]interface{}{
   297  		"certificateName":         autorest.Encode("path", certificateName),
   298  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   299  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   300  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   301  	}
   302  
   303  	const APIVersion = "2022-02-05"
   304  	queryParameters := map[string]interface{}{
   305  		"api-version": APIVersion,
   306  	}
   307  	if len(certificatename) > 0 {
   308  		queryParameters["certificate.name"] = autorest.Encode("query", certificatename)
   309  	}
   310  	if certificaterawBytes != nil && len(certificaterawBytes) > 0 {
   311  		queryParameters["certificate.rawBytes"] = autorest.Encode("query", certificaterawBytes)
   312  	}
   313  	if certificateisVerified != nil {
   314  		queryParameters["certificate.isVerified"] = autorest.Encode("query", *certificateisVerified)
   315  	}
   316  	if len(string(certificatepurpose)) > 0 {
   317  		queryParameters["certificate.purpose"] = autorest.Encode("query", certificatepurpose)
   318  	}
   319  	if certificatecreated != nil {
   320  		queryParameters["certificate.created"] = autorest.Encode("query", *certificatecreated)
   321  	}
   322  	if certificatelastUpdated != nil {
   323  		queryParameters["certificate.lastUpdated"] = autorest.Encode("query", *certificatelastUpdated)
   324  	}
   325  	if certificatehasPrivateKey != nil {
   326  		queryParameters["certificate.hasPrivateKey"] = autorest.Encode("query", *certificatehasPrivateKey)
   327  	}
   328  	if len(certificatenonce) > 0 {
   329  		queryParameters["certificate.nonce"] = autorest.Encode("query", certificatenonce)
   330  	}
   331  
   332  	preparer := autorest.CreatePreparer(
   333  		autorest.AsPost(),
   334  		autorest.WithBaseURL(client.BaseURI),
   335  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/certificates/{certificateName}/generateVerificationCode", pathParameters),
   336  		autorest.WithQueryParameters(queryParameters),
   337  		autorest.WithHeader("If-Match", autorest.String(ifMatch)))
   338  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   339  }
   340  
   341  // GenerateVerificationCodeSender sends the GenerateVerificationCode request. The method will close the
   342  // http.Response Body if it receives an error.
   343  func (client DpsCertificateClient) GenerateVerificationCodeSender(req *http.Request) (*http.Response, error) {
   344  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   345  }
   346  
   347  // GenerateVerificationCodeResponder handles the response to the GenerateVerificationCode request. The method always
   348  // closes the http.Response Body.
   349  func (client DpsCertificateClient) GenerateVerificationCodeResponder(resp *http.Response) (result VerificationCodeResponse, err error) {
   350  	err = autorest.Respond(
   351  		resp,
   352  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   353  		autorest.ByUnmarshallingJSON(&result),
   354  		autorest.ByClosing())
   355  	result.Response = autorest.Response{Response: resp}
   356  	return
   357  }
   358  
   359  // Get get the certificate from the provisioning service.
   360  // Parameters:
   361  // certificateName - name of the certificate to retrieve.
   362  // resourceGroupName - resource group identifier.
   363  // provisioningServiceName - name of the provisioning service the certificate is associated with.
   364  // ifMatch - eTag of the certificate.
   365  func (client DpsCertificateClient) Get(ctx context.Context, certificateName string, resourceGroupName string, provisioningServiceName string, ifMatch string) (result CertificateResponse, err error) {
   366  	if tracing.IsEnabled() {
   367  		ctx = tracing.StartSpan(ctx, fqdn+"/DpsCertificateClient.Get")
   368  		defer func() {
   369  			sc := -1
   370  			if result.Response.Response != nil {
   371  				sc = result.Response.Response.StatusCode
   372  			}
   373  			tracing.EndSpan(ctx, sc, err)
   374  		}()
   375  	}
   376  	req, err := client.GetPreparer(ctx, certificateName, resourceGroupName, provisioningServiceName, ifMatch)
   377  	if err != nil {
   378  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "Get", nil, "Failure preparing request")
   379  		return
   380  	}
   381  
   382  	resp, err := client.GetSender(req)
   383  	if err != nil {
   384  		result.Response = autorest.Response{Response: resp}
   385  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "Get", resp, "Failure sending request")
   386  		return
   387  	}
   388  
   389  	result, err = client.GetResponder(resp)
   390  	if err != nil {
   391  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "Get", resp, "Failure responding to request")
   392  		return
   393  	}
   394  
   395  	return
   396  }
   397  
   398  // GetPreparer prepares the Get request.
   399  func (client DpsCertificateClient) GetPreparer(ctx context.Context, certificateName string, resourceGroupName string, provisioningServiceName string, ifMatch string) (*http.Request, error) {
   400  	pathParameters := map[string]interface{}{
   401  		"certificateName":         autorest.Encode("path", certificateName),
   402  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   403  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   404  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   405  	}
   406  
   407  	const APIVersion = "2022-02-05"
   408  	queryParameters := map[string]interface{}{
   409  		"api-version": APIVersion,
   410  	}
   411  
   412  	preparer := autorest.CreatePreparer(
   413  		autorest.AsGet(),
   414  		autorest.WithBaseURL(client.BaseURI),
   415  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/certificates/{certificateName}", pathParameters),
   416  		autorest.WithQueryParameters(queryParameters))
   417  	if len(ifMatch) > 0 {
   418  		preparer = autorest.DecoratePreparer(preparer,
   419  			autorest.WithHeader("If-Match", autorest.String(ifMatch)))
   420  	}
   421  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   422  }
   423  
   424  // GetSender sends the Get request. The method will close the
   425  // http.Response Body if it receives an error.
   426  func (client DpsCertificateClient) GetSender(req *http.Request) (*http.Response, error) {
   427  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   428  }
   429  
   430  // GetResponder handles the response to the Get request. The method always
   431  // closes the http.Response Body.
   432  func (client DpsCertificateClient) GetResponder(resp *http.Response) (result CertificateResponse, err error) {
   433  	err = autorest.Respond(
   434  		resp,
   435  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   436  		autorest.ByUnmarshallingJSON(&result),
   437  		autorest.ByClosing())
   438  	result.Response = autorest.Response{Response: resp}
   439  	return
   440  }
   441  
   442  // List get all the certificates tied to the provisioning service.
   443  // Parameters:
   444  // resourceGroupName - name of resource group.
   445  // provisioningServiceName - name of provisioning service to retrieve certificates for.
   446  func (client DpsCertificateClient) List(ctx context.Context, resourceGroupName string, provisioningServiceName string) (result CertificateListDescription, err error) {
   447  	if tracing.IsEnabled() {
   448  		ctx = tracing.StartSpan(ctx, fqdn+"/DpsCertificateClient.List")
   449  		defer func() {
   450  			sc := -1
   451  			if result.Response.Response != nil {
   452  				sc = result.Response.Response.StatusCode
   453  			}
   454  			tracing.EndSpan(ctx, sc, err)
   455  		}()
   456  	}
   457  	req, err := client.ListPreparer(ctx, resourceGroupName, provisioningServiceName)
   458  	if err != nil {
   459  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "List", nil, "Failure preparing request")
   460  		return
   461  	}
   462  
   463  	resp, err := client.ListSender(req)
   464  	if err != nil {
   465  		result.Response = autorest.Response{Response: resp}
   466  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "List", resp, "Failure sending request")
   467  		return
   468  	}
   469  
   470  	result, err = client.ListResponder(resp)
   471  	if err != nil {
   472  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "List", resp, "Failure responding to request")
   473  		return
   474  	}
   475  
   476  	return
   477  }
   478  
   479  // ListPreparer prepares the List request.
   480  func (client DpsCertificateClient) ListPreparer(ctx context.Context, resourceGroupName string, provisioningServiceName string) (*http.Request, error) {
   481  	pathParameters := map[string]interface{}{
   482  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   483  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   484  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   485  	}
   486  
   487  	const APIVersion = "2022-02-05"
   488  	queryParameters := map[string]interface{}{
   489  		"api-version": APIVersion,
   490  	}
   491  
   492  	preparer := autorest.CreatePreparer(
   493  		autorest.AsGet(),
   494  		autorest.WithBaseURL(client.BaseURI),
   495  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/certificates", pathParameters),
   496  		autorest.WithQueryParameters(queryParameters))
   497  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   498  }
   499  
   500  // ListSender sends the List request. The method will close the
   501  // http.Response Body if it receives an error.
   502  func (client DpsCertificateClient) ListSender(req *http.Request) (*http.Response, error) {
   503  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   504  }
   505  
   506  // ListResponder handles the response to the List request. The method always
   507  // closes the http.Response Body.
   508  func (client DpsCertificateClient) ListResponder(resp *http.Response) (result CertificateListDescription, err error) {
   509  	err = autorest.Respond(
   510  		resp,
   511  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   512  		autorest.ByUnmarshallingJSON(&result),
   513  		autorest.ByClosing())
   514  	result.Response = autorest.Response{Response: resp}
   515  	return
   516  }
   517  
   518  // VerifyCertificate verifies the certificate's private key possession by providing the leaf cert issued by the
   519  // verifying pre uploaded certificate.
   520  // Parameters:
   521  // certificateName - the mandatory logical name of the certificate, that the provisioning service uses to
   522  // access.
   523  // ifMatch - eTag of the certificate.
   524  // request - the name of the certificate
   525  // resourceGroupName - resource group name.
   526  // provisioningServiceName - provisioning service name.
   527  // certificatename - common Name for the certificate.
   528  // certificaterawBytes - raw data of certificate.
   529  // certificateisVerified - indicates if the certificate has been verified by owner of the private key.
   530  // certificatepurpose - describe the purpose of the certificate.
   531  // certificatecreated - certificate creation time.
   532  // certificatelastUpdated - certificate last updated time.
   533  // certificatehasPrivateKey - indicates if the certificate contains private key.
   534  // certificatenonce - random number generated to indicate Proof of Possession.
   535  func (client DpsCertificateClient) VerifyCertificate(ctx context.Context, certificateName string, ifMatch string, request VerificationCodeRequest, resourceGroupName string, provisioningServiceName string, certificatename string, certificaterawBytes []byte, certificateisVerified *bool, certificatepurpose CertificatePurpose, certificatecreated *date.Time, certificatelastUpdated *date.Time, certificatehasPrivateKey *bool, certificatenonce string) (result CertificateResponse, err error) {
   536  	if tracing.IsEnabled() {
   537  		ctx = tracing.StartSpan(ctx, fqdn+"/DpsCertificateClient.VerifyCertificate")
   538  		defer func() {
   539  			sc := -1
   540  			if result.Response.Response != nil {
   541  				sc = result.Response.Response.StatusCode
   542  			}
   543  			tracing.EndSpan(ctx, sc, err)
   544  		}()
   545  	}
   546  	req, err := client.VerifyCertificatePreparer(ctx, certificateName, ifMatch, request, resourceGroupName, provisioningServiceName, certificatename, certificaterawBytes, certificateisVerified, certificatepurpose, certificatecreated, certificatelastUpdated, certificatehasPrivateKey, certificatenonce)
   547  	if err != nil {
   548  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "VerifyCertificate", nil, "Failure preparing request")
   549  		return
   550  	}
   551  
   552  	resp, err := client.VerifyCertificateSender(req)
   553  	if err != nil {
   554  		result.Response = autorest.Response{Response: resp}
   555  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "VerifyCertificate", resp, "Failure sending request")
   556  		return
   557  	}
   558  
   559  	result, err = client.VerifyCertificateResponder(resp)
   560  	if err != nil {
   561  		err = autorest.NewErrorWithError(err, "iothub.DpsCertificateClient", "VerifyCertificate", resp, "Failure responding to request")
   562  		return
   563  	}
   564  
   565  	return
   566  }
   567  
   568  // VerifyCertificatePreparer prepares the VerifyCertificate request.
   569  func (client DpsCertificateClient) VerifyCertificatePreparer(ctx context.Context, certificateName string, ifMatch string, request VerificationCodeRequest, resourceGroupName string, provisioningServiceName string, certificatename string, certificaterawBytes []byte, certificateisVerified *bool, certificatepurpose CertificatePurpose, certificatecreated *date.Time, certificatelastUpdated *date.Time, certificatehasPrivateKey *bool, certificatenonce string) (*http.Request, error) {
   570  	pathParameters := map[string]interface{}{
   571  		"certificateName":         autorest.Encode("path", certificateName),
   572  		"provisioningServiceName": autorest.Encode("path", provisioningServiceName),
   573  		"resourceGroupName":       autorest.Encode("path", resourceGroupName),
   574  		"subscriptionId":          autorest.Encode("path", client.SubscriptionID),
   575  	}
   576  
   577  	const APIVersion = "2022-02-05"
   578  	queryParameters := map[string]interface{}{
   579  		"api-version": APIVersion,
   580  	}
   581  	if len(certificatename) > 0 {
   582  		queryParameters["certificate.name"] = autorest.Encode("query", certificatename)
   583  	}
   584  	if certificaterawBytes != nil && len(certificaterawBytes) > 0 {
   585  		queryParameters["certificate.rawBytes"] = autorest.Encode("query", certificaterawBytes)
   586  	}
   587  	if certificateisVerified != nil {
   588  		queryParameters["certificate.isVerified"] = autorest.Encode("query", *certificateisVerified)
   589  	}
   590  	if len(string(certificatepurpose)) > 0 {
   591  		queryParameters["certificate.purpose"] = autorest.Encode("query", certificatepurpose)
   592  	}
   593  	if certificatecreated != nil {
   594  		queryParameters["certificate.created"] = autorest.Encode("query", *certificatecreated)
   595  	}
   596  	if certificatelastUpdated != nil {
   597  		queryParameters["certificate.lastUpdated"] = autorest.Encode("query", *certificatelastUpdated)
   598  	}
   599  	if certificatehasPrivateKey != nil {
   600  		queryParameters["certificate.hasPrivateKey"] = autorest.Encode("query", *certificatehasPrivateKey)
   601  	}
   602  	if len(certificatenonce) > 0 {
   603  		queryParameters["certificate.nonce"] = autorest.Encode("query", certificatenonce)
   604  	}
   605  
   606  	preparer := autorest.CreatePreparer(
   607  		autorest.AsContentType("application/json; charset=utf-8"),
   608  		autorest.AsPost(),
   609  		autorest.WithBaseURL(client.BaseURI),
   610  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Devices/provisioningServices/{provisioningServiceName}/certificates/{certificateName}/verify", pathParameters),
   611  		autorest.WithJSON(request),
   612  		autorest.WithQueryParameters(queryParameters),
   613  		autorest.WithHeader("If-Match", autorest.String(ifMatch)))
   614  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   615  }
   616  
   617  // VerifyCertificateSender sends the VerifyCertificate request. The method will close the
   618  // http.Response Body if it receives an error.
   619  func (client DpsCertificateClient) VerifyCertificateSender(req *http.Request) (*http.Response, error) {
   620  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   621  }
   622  
   623  // VerifyCertificateResponder handles the response to the VerifyCertificate request. The method always
   624  // closes the http.Response Body.
   625  func (client DpsCertificateClient) VerifyCertificateResponder(resp *http.Response) (result CertificateResponse, err error) {
   626  	err = autorest.Respond(
   627  		resp,
   628  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   629  		autorest.ByUnmarshallingJSON(&result),
   630  		autorest.ByClosing())
   631  	result.Response = autorest.Response{Response: resp}
   632  	return
   633  }
   634
View as plain text