contentkeypolicies.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/mediaservices/mgmt/2019-05-01-preview/media

     1  package media
     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  // ContentKeyPoliciesClient is the client for the ContentKeyPolicies methods of the Media service.
    19  type ContentKeyPoliciesClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewContentKeyPoliciesClient creates an instance of the ContentKeyPoliciesClient client.
    24  func NewContentKeyPoliciesClient(subscriptionID string) ContentKeyPoliciesClient {
    25  	return NewContentKeyPoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewContentKeyPoliciesClientWithBaseURI creates an instance of the ContentKeyPoliciesClient client using a custom
    29  // endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
    30  // stack).
    31  func NewContentKeyPoliciesClientWithBaseURI(baseURI string, subscriptionID string) ContentKeyPoliciesClient {
    32  	return ContentKeyPoliciesClient{NewWithBaseURI(baseURI, subscriptionID)}
    33  }
    34  
    35  // CreateOrUpdate create or update a Content Key Policy in the Media Services account
    36  // Parameters:
    37  // resourceGroupName - the name of the resource group within the Azure subscription.
    38  // accountName - the Media Services account name.
    39  // contentKeyPolicyName - the Content Key Policy name.
    40  // parameters - the request parameters
    41  func (client ContentKeyPoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string, parameters ContentKeyPolicy) (result ContentKeyPolicy, err error) {
    42  	if tracing.IsEnabled() {
    43  		ctx = tracing.StartSpan(ctx, fqdn+"/ContentKeyPoliciesClient.CreateOrUpdate")
    44  		defer func() {
    45  			sc := -1
    46  			if result.Response.Response != nil {
    47  				sc = result.Response.Response.StatusCode
    48  			}
    49  			tracing.EndSpan(ctx, sc, err)
    50  		}()
    51  	}
    52  	if err := validation.Validate([]validation.Validation{
    53  		{TargetValue: parameters,
    54  			Constraints: []validation.Constraint{{Target: "parameters.ContentKeyPolicyProperties", Name: validation.Null, Rule: false,
    55  				Chain: []validation.Constraint{{Target: "parameters.ContentKeyPolicyProperties.Options", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
    56  		return result, validation.NewError("media.ContentKeyPoliciesClient", "CreateOrUpdate", err.Error())
    57  	}
    58  
    59  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, contentKeyPolicyName, parameters)
    60  	if err != nil {
    61  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "CreateOrUpdate", nil, "Failure preparing request")
    62  		return
    63  	}
    64  
    65  	resp, err := client.CreateOrUpdateSender(req)
    66  	if err != nil {
    67  		result.Response = autorest.Response{Response: resp}
    68  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "CreateOrUpdate", resp, "Failure sending request")
    69  		return
    70  	}
    71  
    72  	result, err = client.CreateOrUpdateResponder(resp)
    73  	if err != nil {
    74  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "CreateOrUpdate", resp, "Failure responding to request")
    75  		return
    76  	}
    77  
    78  	return
    79  }
    80  
    81  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    82  func (client ContentKeyPoliciesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string, parameters ContentKeyPolicy) (*http.Request, error) {
    83  	pathParameters := map[string]interface{}{
    84  		"accountName":          autorest.Encode("path", accountName),
    85  		"contentKeyPolicyName": autorest.Encode("path", contentKeyPolicyName),
    86  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
    87  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
    88  	}
    89  
    90  	const APIVersion = "2018-07-01"
    91  	queryParameters := map[string]interface{}{
    92  		"api-version": APIVersion,
    93  	}
    94  
    95  	preparer := autorest.CreatePreparer(
    96  		autorest.AsContentType("application/json; charset=utf-8"),
    97  		autorest.AsPut(),
    98  		autorest.WithBaseURL(client.BaseURI),
    99  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/contentKeyPolicies/{contentKeyPolicyName}", pathParameters),
   100  		autorest.WithJSON(parameters),
   101  		autorest.WithQueryParameters(queryParameters))
   102  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   103  }
   104  
   105  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   106  // http.Response Body if it receives an error.
   107  func (client ContentKeyPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
   108  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   109  }
   110  
   111  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   112  // closes the http.Response Body.
   113  func (client ContentKeyPoliciesClient) CreateOrUpdateResponder(resp *http.Response) (result ContentKeyPolicy, err error) {
   114  	err = autorest.Respond(
   115  		resp,
   116  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   117  		autorest.ByUnmarshallingJSON(&result),
   118  		autorest.ByClosing())
   119  	result.Response = autorest.Response{Response: resp}
   120  	return
   121  }
   122  
   123  // Delete deletes a Content Key Policy in the Media Services account
   124  // Parameters:
   125  // resourceGroupName - the name of the resource group within the Azure subscription.
   126  // accountName - the Media Services account name.
   127  // contentKeyPolicyName - the Content Key Policy name.
   128  func (client ContentKeyPoliciesClient) Delete(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string) (result autorest.Response, err error) {
   129  	if tracing.IsEnabled() {
   130  		ctx = tracing.StartSpan(ctx, fqdn+"/ContentKeyPoliciesClient.Delete")
   131  		defer func() {
   132  			sc := -1
   133  			if result.Response != nil {
   134  				sc = result.Response.StatusCode
   135  			}
   136  			tracing.EndSpan(ctx, sc, err)
   137  		}()
   138  	}
   139  	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, contentKeyPolicyName)
   140  	if err != nil {
   141  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Delete", nil, "Failure preparing request")
   142  		return
   143  	}
   144  
   145  	resp, err := client.DeleteSender(req)
   146  	if err != nil {
   147  		result.Response = resp
   148  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Delete", resp, "Failure sending request")
   149  		return
   150  	}
   151  
   152  	result, err = client.DeleteResponder(resp)
   153  	if err != nil {
   154  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Delete", resp, "Failure responding to request")
   155  		return
   156  	}
   157  
   158  	return
   159  }
   160  
   161  // DeletePreparer prepares the Delete request.
   162  func (client ContentKeyPoliciesClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string) (*http.Request, error) {
   163  	pathParameters := map[string]interface{}{
   164  		"accountName":          autorest.Encode("path", accountName),
   165  		"contentKeyPolicyName": autorest.Encode("path", contentKeyPolicyName),
   166  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   167  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   168  	}
   169  
   170  	const APIVersion = "2018-07-01"
   171  	queryParameters := map[string]interface{}{
   172  		"api-version": APIVersion,
   173  	}
   174  
   175  	preparer := autorest.CreatePreparer(
   176  		autorest.AsDelete(),
   177  		autorest.WithBaseURL(client.BaseURI),
   178  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/contentKeyPolicies/{contentKeyPolicyName}", pathParameters),
   179  		autorest.WithQueryParameters(queryParameters))
   180  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   181  }
   182  
   183  // DeleteSender sends the Delete request. The method will close the
   184  // http.Response Body if it receives an error.
   185  func (client ContentKeyPoliciesClient) DeleteSender(req *http.Request) (*http.Response, error) {
   186  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   187  }
   188  
   189  // DeleteResponder handles the response to the Delete request. The method always
   190  // closes the http.Response Body.
   191  func (client ContentKeyPoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   192  	err = autorest.Respond(
   193  		resp,
   194  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   195  		autorest.ByClosing())
   196  	result.Response = resp
   197  	return
   198  }
   199  
   200  // Get get the details of a Content Key Policy in the Media Services account
   201  // Parameters:
   202  // resourceGroupName - the name of the resource group within the Azure subscription.
   203  // accountName - the Media Services account name.
   204  // contentKeyPolicyName - the Content Key Policy name.
   205  func (client ContentKeyPoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string) (result ContentKeyPolicy, err error) {
   206  	if tracing.IsEnabled() {
   207  		ctx = tracing.StartSpan(ctx, fqdn+"/ContentKeyPoliciesClient.Get")
   208  		defer func() {
   209  			sc := -1
   210  			if result.Response.Response != nil {
   211  				sc = result.Response.Response.StatusCode
   212  			}
   213  			tracing.EndSpan(ctx, sc, err)
   214  		}()
   215  	}
   216  	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, contentKeyPolicyName)
   217  	if err != nil {
   218  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Get", nil, "Failure preparing request")
   219  		return
   220  	}
   221  
   222  	resp, err := client.GetSender(req)
   223  	if err != nil {
   224  		result.Response = autorest.Response{Response: resp}
   225  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Get", resp, "Failure sending request")
   226  		return
   227  	}
   228  
   229  	result, err = client.GetResponder(resp)
   230  	if err != nil {
   231  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Get", resp, "Failure responding to request")
   232  		return
   233  	}
   234  
   235  	return
   236  }
   237  
   238  // GetPreparer prepares the Get request.
   239  func (client ContentKeyPoliciesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string) (*http.Request, error) {
   240  	pathParameters := map[string]interface{}{
   241  		"accountName":          autorest.Encode("path", accountName),
   242  		"contentKeyPolicyName": autorest.Encode("path", contentKeyPolicyName),
   243  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   244  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   245  	}
   246  
   247  	const APIVersion = "2018-07-01"
   248  	queryParameters := map[string]interface{}{
   249  		"api-version": APIVersion,
   250  	}
   251  
   252  	preparer := autorest.CreatePreparer(
   253  		autorest.AsGet(),
   254  		autorest.WithBaseURL(client.BaseURI),
   255  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/contentKeyPolicies/{contentKeyPolicyName}", pathParameters),
   256  		autorest.WithQueryParameters(queryParameters))
   257  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   258  }
   259  
   260  // GetSender sends the Get request. The method will close the
   261  // http.Response Body if it receives an error.
   262  func (client ContentKeyPoliciesClient) GetSender(req *http.Request) (*http.Response, error) {
   263  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   264  }
   265  
   266  // GetResponder handles the response to the Get request. The method always
   267  // closes the http.Response Body.
   268  func (client ContentKeyPoliciesClient) GetResponder(resp *http.Response) (result ContentKeyPolicy, err error) {
   269  	err = autorest.Respond(
   270  		resp,
   271  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
   272  		autorest.ByUnmarshallingJSON(&result),
   273  		autorest.ByClosing())
   274  	result.Response = autorest.Response{Response: resp}
   275  	return
   276  }
   277  
   278  // GetPolicyPropertiesWithSecrets get a Content Key Policy including secret values
   279  // Parameters:
   280  // resourceGroupName - the name of the resource group within the Azure subscription.
   281  // accountName - the Media Services account name.
   282  // contentKeyPolicyName - the Content Key Policy name.
   283  func (client ContentKeyPoliciesClient) GetPolicyPropertiesWithSecrets(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string) (result ContentKeyPolicyProperties, err error) {
   284  	if tracing.IsEnabled() {
   285  		ctx = tracing.StartSpan(ctx, fqdn+"/ContentKeyPoliciesClient.GetPolicyPropertiesWithSecrets")
   286  		defer func() {
   287  			sc := -1
   288  			if result.Response.Response != nil {
   289  				sc = result.Response.Response.StatusCode
   290  			}
   291  			tracing.EndSpan(ctx, sc, err)
   292  		}()
   293  	}
   294  	req, err := client.GetPolicyPropertiesWithSecretsPreparer(ctx, resourceGroupName, accountName, contentKeyPolicyName)
   295  	if err != nil {
   296  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "GetPolicyPropertiesWithSecrets", nil, "Failure preparing request")
   297  		return
   298  	}
   299  
   300  	resp, err := client.GetPolicyPropertiesWithSecretsSender(req)
   301  	if err != nil {
   302  		result.Response = autorest.Response{Response: resp}
   303  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "GetPolicyPropertiesWithSecrets", resp, "Failure sending request")
   304  		return
   305  	}
   306  
   307  	result, err = client.GetPolicyPropertiesWithSecretsResponder(resp)
   308  	if err != nil {
   309  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "GetPolicyPropertiesWithSecrets", resp, "Failure responding to request")
   310  		return
   311  	}
   312  
   313  	return
   314  }
   315  
   316  // GetPolicyPropertiesWithSecretsPreparer prepares the GetPolicyPropertiesWithSecrets request.
   317  func (client ContentKeyPoliciesClient) GetPolicyPropertiesWithSecretsPreparer(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string) (*http.Request, error) {
   318  	pathParameters := map[string]interface{}{
   319  		"accountName":          autorest.Encode("path", accountName),
   320  		"contentKeyPolicyName": autorest.Encode("path", contentKeyPolicyName),
   321  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   322  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   323  	}
   324  
   325  	const APIVersion = "2018-07-01"
   326  	queryParameters := map[string]interface{}{
   327  		"api-version": APIVersion,
   328  	}
   329  
   330  	preparer := autorest.CreatePreparer(
   331  		autorest.AsPost(),
   332  		autorest.WithBaseURL(client.BaseURI),
   333  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/contentKeyPolicies/{contentKeyPolicyName}/getPolicyPropertiesWithSecrets", pathParameters),
   334  		autorest.WithQueryParameters(queryParameters))
   335  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   336  }
   337  
   338  // GetPolicyPropertiesWithSecretsSender sends the GetPolicyPropertiesWithSecrets request. The method will close the
   339  // http.Response Body if it receives an error.
   340  func (client ContentKeyPoliciesClient) GetPolicyPropertiesWithSecretsSender(req *http.Request) (*http.Response, error) {
   341  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   342  }
   343  
   344  // GetPolicyPropertiesWithSecretsResponder handles the response to the GetPolicyPropertiesWithSecrets request. The method always
   345  // closes the http.Response Body.
   346  func (client ContentKeyPoliciesClient) GetPolicyPropertiesWithSecretsResponder(resp *http.Response) (result ContentKeyPolicyProperties, err error) {
   347  	err = autorest.Respond(
   348  		resp,
   349  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotFound),
   350  		autorest.ByUnmarshallingJSON(&result),
   351  		autorest.ByClosing())
   352  	result.Response = autorest.Response{Response: resp}
   353  	return
   354  }
   355  
   356  // List lists the Content Key Policies in the account
   357  // Parameters:
   358  // resourceGroupName - the name of the resource group within the Azure subscription.
   359  // accountName - the Media Services account name.
   360  // filter - restricts the set of items returned.
   361  // top - specifies a non-negative integer n that limits the number of items returned from a collection. The
   362  // service returns the number of available items up to but not greater than the specified value n.
   363  // orderby - specifies the key by which the result collection should be ordered.
   364  func (client ContentKeyPoliciesClient) List(ctx context.Context, resourceGroupName string, accountName string, filter string, top *int32, orderby string) (result ContentKeyPolicyCollectionPage, err error) {
   365  	if tracing.IsEnabled() {
   366  		ctx = tracing.StartSpan(ctx, fqdn+"/ContentKeyPoliciesClient.List")
   367  		defer func() {
   368  			sc := -1
   369  			if result.ckpc.Response.Response != nil {
   370  				sc = result.ckpc.Response.Response.StatusCode
   371  			}
   372  			tracing.EndSpan(ctx, sc, err)
   373  		}()
   374  	}
   375  	result.fn = client.listNextResults
   376  	req, err := client.ListPreparer(ctx, resourceGroupName, accountName, filter, top, orderby)
   377  	if err != nil {
   378  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "List", nil, "Failure preparing request")
   379  		return
   380  	}
   381  
   382  	resp, err := client.ListSender(req)
   383  	if err != nil {
   384  		result.ckpc.Response = autorest.Response{Response: resp}
   385  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "List", resp, "Failure sending request")
   386  		return
   387  	}
   388  
   389  	result.ckpc, err = client.ListResponder(resp)
   390  	if err != nil {
   391  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "List", resp, "Failure responding to request")
   392  		return
   393  	}
   394  	if result.ckpc.hasNextLink() && result.ckpc.IsEmpty() {
   395  		err = result.NextWithContext(ctx)
   396  		return
   397  	}
   398  
   399  	return
   400  }
   401  
   402  // ListPreparer prepares the List request.
   403  func (client ContentKeyPoliciesClient) ListPreparer(ctx context.Context, resourceGroupName string, accountName string, filter string, top *int32, orderby string) (*http.Request, error) {
   404  	pathParameters := map[string]interface{}{
   405  		"accountName":       autorest.Encode("path", accountName),
   406  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   407  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   408  	}
   409  
   410  	const APIVersion = "2018-07-01"
   411  	queryParameters := map[string]interface{}{
   412  		"api-version": APIVersion,
   413  	}
   414  	if len(filter) > 0 {
   415  		queryParameters["$filter"] = autorest.Encode("query", filter)
   416  	}
   417  	if top != nil {
   418  		queryParameters["$top"] = autorest.Encode("query", *top)
   419  	}
   420  	if len(orderby) > 0 {
   421  		queryParameters["$orderby"] = autorest.Encode("query", orderby)
   422  	}
   423  
   424  	preparer := autorest.CreatePreparer(
   425  		autorest.AsGet(),
   426  		autorest.WithBaseURL(client.BaseURI),
   427  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/contentKeyPolicies", pathParameters),
   428  		autorest.WithQueryParameters(queryParameters))
   429  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   430  }
   431  
   432  // ListSender sends the List request. The method will close the
   433  // http.Response Body if it receives an error.
   434  func (client ContentKeyPoliciesClient) ListSender(req *http.Request) (*http.Response, error) {
   435  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   436  }
   437  
   438  // ListResponder handles the response to the List request. The method always
   439  // closes the http.Response Body.
   440  func (client ContentKeyPoliciesClient) ListResponder(resp *http.Response) (result ContentKeyPolicyCollection, err error) {
   441  	err = autorest.Respond(
   442  		resp,
   443  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   444  		autorest.ByUnmarshallingJSON(&result),
   445  		autorest.ByClosing())
   446  	result.Response = autorest.Response{Response: resp}
   447  	return
   448  }
   449  
   450  // listNextResults retrieves the next set of results, if any.
   451  func (client ContentKeyPoliciesClient) listNextResults(ctx context.Context, lastResults ContentKeyPolicyCollection) (result ContentKeyPolicyCollection, err error) {
   452  	req, err := lastResults.contentKeyPolicyCollectionPreparer(ctx)
   453  	if err != nil {
   454  		return result, autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "listNextResults", nil, "Failure preparing next results request")
   455  	}
   456  	if req == nil {
   457  		return
   458  	}
   459  	resp, err := client.ListSender(req)
   460  	if err != nil {
   461  		result.Response = autorest.Response{Response: resp}
   462  		return result, autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "listNextResults", resp, "Failure sending next results request")
   463  	}
   464  	result, err = client.ListResponder(resp)
   465  	if err != nil {
   466  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "listNextResults", resp, "Failure responding to next results request")
   467  	}
   468  	return
   469  }
   470  
   471  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   472  func (client ContentKeyPoliciesClient) ListComplete(ctx context.Context, resourceGroupName string, accountName string, filter string, top *int32, orderby string) (result ContentKeyPolicyCollectionIterator, err error) {
   473  	if tracing.IsEnabled() {
   474  		ctx = tracing.StartSpan(ctx, fqdn+"/ContentKeyPoliciesClient.List")
   475  		defer func() {
   476  			sc := -1
   477  			if result.Response().Response.Response != nil {
   478  				sc = result.page.Response().Response.Response.StatusCode
   479  			}
   480  			tracing.EndSpan(ctx, sc, err)
   481  		}()
   482  	}
   483  	result.page, err = client.List(ctx, resourceGroupName, accountName, filter, top, orderby)
   484  	return
   485  }
   486  
   487  // Update updates an existing Content Key Policy in the Media Services account
   488  // Parameters:
   489  // resourceGroupName - the name of the resource group within the Azure subscription.
   490  // accountName - the Media Services account name.
   491  // contentKeyPolicyName - the Content Key Policy name.
   492  // parameters - the request parameters
   493  func (client ContentKeyPoliciesClient) Update(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string, parameters ContentKeyPolicy) (result ContentKeyPolicy, err error) {
   494  	if tracing.IsEnabled() {
   495  		ctx = tracing.StartSpan(ctx, fqdn+"/ContentKeyPoliciesClient.Update")
   496  		defer func() {
   497  			sc := -1
   498  			if result.Response.Response != nil {
   499  				sc = result.Response.Response.StatusCode
   500  			}
   501  			tracing.EndSpan(ctx, sc, err)
   502  		}()
   503  	}
   504  	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, contentKeyPolicyName, parameters)
   505  	if err != nil {
   506  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Update", nil, "Failure preparing request")
   507  		return
   508  	}
   509  
   510  	resp, err := client.UpdateSender(req)
   511  	if err != nil {
   512  		result.Response = autorest.Response{Response: resp}
   513  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Update", resp, "Failure sending request")
   514  		return
   515  	}
   516  
   517  	result, err = client.UpdateResponder(resp)
   518  	if err != nil {
   519  		err = autorest.NewErrorWithError(err, "media.ContentKeyPoliciesClient", "Update", resp, "Failure responding to request")
   520  		return
   521  	}
   522  
   523  	return
   524  }
   525  
   526  // UpdatePreparer prepares the Update request.
   527  func (client ContentKeyPoliciesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, contentKeyPolicyName string, parameters ContentKeyPolicy) (*http.Request, error) {
   528  	pathParameters := map[string]interface{}{
   529  		"accountName":          autorest.Encode("path", accountName),
   530  		"contentKeyPolicyName": autorest.Encode("path", contentKeyPolicyName),
   531  		"resourceGroupName":    autorest.Encode("path", resourceGroupName),
   532  		"subscriptionId":       autorest.Encode("path", client.SubscriptionID),
   533  	}
   534  
   535  	const APIVersion = "2018-07-01"
   536  	queryParameters := map[string]interface{}{
   537  		"api-version": APIVersion,
   538  	}
   539  
   540  	preparer := autorest.CreatePreparer(
   541  		autorest.AsContentType("application/json; charset=utf-8"),
   542  		autorest.AsPatch(),
   543  		autorest.WithBaseURL(client.BaseURI),
   544  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/contentKeyPolicies/{contentKeyPolicyName}", pathParameters),
   545  		autorest.WithJSON(parameters),
   546  		autorest.WithQueryParameters(queryParameters))
   547  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   548  }
   549  
   550  // UpdateSender sends the Update request. The method will close the
   551  // http.Response Body if it receives an error.
   552  func (client ContentKeyPoliciesClient) UpdateSender(req *http.Request) (*http.Response, error) {
   553  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   554  }
   555  
   556  // UpdateResponder handles the response to the Update request. The method always
   557  // closes the http.Response Body.
   558  func (client ContentKeyPoliciesClient) UpdateResponder(resp *http.Response) (result ContentKeyPolicy, err error) {
   559  	err = autorest.Respond(
   560  		resp,
   561  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   562  		autorest.ByUnmarshallingJSON(&result),
   563  		autorest.ByClosing())
   564  	result.Response = autorest.Response{Response: resp}
   565  	return
   566  }
   567
View as plain text