mediaservices.go

Documentation: github.com/Azure/azure-sdk-for-go/services/mediaservices/mgmt/2021-06-01/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  // MediaservicesClient is the client for the Mediaservices methods of the Media service.
    19  type MediaservicesClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewMediaservicesClient creates an instance of the MediaservicesClient client.
    24  func NewMediaservicesClient(subscriptionID string) MediaservicesClient {
    25  	return NewMediaservicesClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewMediaservicesClientWithBaseURI creates an instance of the MediaservicesClient 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 NewMediaservicesClientWithBaseURI(baseURI string, subscriptionID string) MediaservicesClient {
    31  	return MediaservicesClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CreateOrUpdate creates or updates a Media Services account
    35  // Parameters:
    36  // resourceGroupName - the name of the resource group within the Azure subscription.
    37  // accountName - the Media Services account name.
    38  // parameters - the request parameters
    39  func (client MediaservicesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, parameters Service) (result Service, err error) {
    40  	if tracing.IsEnabled() {
    41  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.CreateOrUpdate")
    42  		defer func() {
    43  			sc := -1
    44  			if result.Response.Response != nil {
    45  				sc = result.Response.Response.StatusCode
    46  			}
    47  			tracing.EndSpan(ctx, sc, err)
    48  		}()
    49  	}
    50  	if err := validation.Validate([]validation.Validation{
    51  		{TargetValue: parameters,
    52  			Constraints: []validation.Constraint{{Target: "parameters.ServiceProperties", Name: validation.Null, Rule: false,
    53  				Chain: []validation.Constraint{{Target: "parameters.ServiceProperties.Encryption", Name: validation.Null, Rule: false,
    54  					Chain: []validation.Constraint{{Target: "parameters.ServiceProperties.Encryption.Identity", Name: validation.Null, Rule: false,
    55  						Chain: []validation.Constraint{{Target: "parameters.ServiceProperties.Encryption.Identity.UseSystemAssignedIdentity", Name: validation.Null, Rule: true, Chain: nil}}},
    56  					}},
    57  				}},
    58  				{Target: "parameters.Identity", Name: validation.Null, Rule: false,
    59  					Chain: []validation.Constraint{{Target: "parameters.Identity.Type", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil {
    60  		return result, validation.NewError("media.MediaservicesClient", "CreateOrUpdate", err.Error())
    61  	}
    62  
    63  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, parameters)
    64  	if err != nil {
    65  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "CreateOrUpdate", nil, "Failure preparing request")
    66  		return
    67  	}
    68  
    69  	resp, err := client.CreateOrUpdateSender(req)
    70  	if err != nil {
    71  		result.Response = autorest.Response{Response: resp}
    72  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "CreateOrUpdate", resp, "Failure sending request")
    73  		return
    74  	}
    75  
    76  	result, err = client.CreateOrUpdateResponder(resp)
    77  	if err != nil {
    78  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "CreateOrUpdate", resp, "Failure responding to request")
    79  		return
    80  	}
    81  
    82  	return
    83  }
    84  
    85  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    86  func (client MediaservicesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters Service) (*http.Request, error) {
    87  	pathParameters := map[string]interface{}{
    88  		"accountName":       autorest.Encode("path", accountName),
    89  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    90  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    91  	}
    92  
    93  	const APIVersion = "2021-06-01"
    94  	queryParameters := map[string]interface{}{
    95  		"api-version": APIVersion,
    96  	}
    97  
    98  	parameters.SystemData = nil
    99  	preparer := autorest.CreatePreparer(
   100  		autorest.AsContentType("application/json; charset=utf-8"),
   101  		autorest.AsPut(),
   102  		autorest.WithBaseURL(client.BaseURI),
   103  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaservices/{accountName}", pathParameters),
   104  		autorest.WithJSON(parameters),
   105  		autorest.WithQueryParameters(queryParameters))
   106  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   107  }
   108  
   109  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   110  // http.Response Body if it receives an error.
   111  func (client MediaservicesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
   112  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   113  }
   114  
   115  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   116  // closes the http.Response Body.
   117  func (client MediaservicesClient) CreateOrUpdateResponder(resp *http.Response) (result Service, err error) {
   118  	err = autorest.Respond(
   119  		resp,
   120  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   121  		autorest.ByUnmarshallingJSON(&result),
   122  		autorest.ByClosing())
   123  	result.Response = autorest.Response{Response: resp}
   124  	return
   125  }
   126  
   127  // Delete deletes a Media Services account
   128  // Parameters:
   129  // resourceGroupName - the name of the resource group within the Azure subscription.
   130  // accountName - the Media Services account name.
   131  func (client MediaservicesClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result autorest.Response, err error) {
   132  	if tracing.IsEnabled() {
   133  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.Delete")
   134  		defer func() {
   135  			sc := -1
   136  			if result.Response != nil {
   137  				sc = result.Response.StatusCode
   138  			}
   139  			tracing.EndSpan(ctx, sc, err)
   140  		}()
   141  	}
   142  	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
   143  	if err != nil {
   144  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Delete", nil, "Failure preparing request")
   145  		return
   146  	}
   147  
   148  	resp, err := client.DeleteSender(req)
   149  	if err != nil {
   150  		result.Response = resp
   151  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Delete", resp, "Failure sending request")
   152  		return
   153  	}
   154  
   155  	result, err = client.DeleteResponder(resp)
   156  	if err != nil {
   157  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Delete", resp, "Failure responding to request")
   158  		return
   159  	}
   160  
   161  	return
   162  }
   163  
   164  // DeletePreparer prepares the Delete request.
   165  func (client MediaservicesClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   166  	pathParameters := map[string]interface{}{
   167  		"accountName":       autorest.Encode("path", accountName),
   168  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   169  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   170  	}
   171  
   172  	const APIVersion = "2021-06-01"
   173  	queryParameters := map[string]interface{}{
   174  		"api-version": APIVersion,
   175  	}
   176  
   177  	preparer := autorest.CreatePreparer(
   178  		autorest.AsDelete(),
   179  		autorest.WithBaseURL(client.BaseURI),
   180  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaservices/{accountName}", pathParameters),
   181  		autorest.WithQueryParameters(queryParameters))
   182  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   183  }
   184  
   185  // DeleteSender sends the Delete request. The method will close the
   186  // http.Response Body if it receives an error.
   187  func (client MediaservicesClient) DeleteSender(req *http.Request) (*http.Response, error) {
   188  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   189  }
   190  
   191  // DeleteResponder handles the response to the Delete request. The method always
   192  // closes the http.Response Body.
   193  func (client MediaservicesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   194  	err = autorest.Respond(
   195  		resp,
   196  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   197  		autorest.ByClosing())
   198  	result.Response = resp
   199  	return
   200  }
   201  
   202  // Get get the details of a Media Services account
   203  // Parameters:
   204  // resourceGroupName - the name of the resource group within the Azure subscription.
   205  // accountName - the Media Services account name.
   206  func (client MediaservicesClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result Service, err error) {
   207  	if tracing.IsEnabled() {
   208  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.Get")
   209  		defer func() {
   210  			sc := -1
   211  			if result.Response.Response != nil {
   212  				sc = result.Response.Response.StatusCode
   213  			}
   214  			tracing.EndSpan(ctx, sc, err)
   215  		}()
   216  	}
   217  	req, err := client.GetPreparer(ctx, resourceGroupName, accountName)
   218  	if err != nil {
   219  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Get", nil, "Failure preparing request")
   220  		return
   221  	}
   222  
   223  	resp, err := client.GetSender(req)
   224  	if err != nil {
   225  		result.Response = autorest.Response{Response: resp}
   226  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Get", resp, "Failure sending request")
   227  		return
   228  	}
   229  
   230  	result, err = client.GetResponder(resp)
   231  	if err != nil {
   232  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Get", resp, "Failure responding to request")
   233  		return
   234  	}
   235  
   236  	return
   237  }
   238  
   239  // GetPreparer prepares the Get request.
   240  func (client MediaservicesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   241  	pathParameters := map[string]interface{}{
   242  		"accountName":       autorest.Encode("path", accountName),
   243  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   244  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   245  	}
   246  
   247  	const APIVersion = "2021-06-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}", 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 MediaservicesClient) 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 MediaservicesClient) GetResponder(resp *http.Response) (result Service, err error) {
   269  	err = autorest.Respond(
   270  		resp,
   271  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   272  		autorest.ByUnmarshallingJSON(&result),
   273  		autorest.ByClosing())
   274  	result.Response = autorest.Response{Response: resp}
   275  	return
   276  }
   277  
   278  // List list Media Services accounts in the resource group
   279  // Parameters:
   280  // resourceGroupName - the name of the resource group within the Azure subscription.
   281  func (client MediaservicesClient) List(ctx context.Context, resourceGroupName string) (result ServiceCollectionPage, err error) {
   282  	if tracing.IsEnabled() {
   283  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.List")
   284  		defer func() {
   285  			sc := -1
   286  			if result.sc.Response.Response != nil {
   287  				sc = result.sc.Response.Response.StatusCode
   288  			}
   289  			tracing.EndSpan(ctx, sc, err)
   290  		}()
   291  	}
   292  	result.fn = client.listNextResults
   293  	req, err := client.ListPreparer(ctx, resourceGroupName)
   294  	if err != nil {
   295  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "List", nil, "Failure preparing request")
   296  		return
   297  	}
   298  
   299  	resp, err := client.ListSender(req)
   300  	if err != nil {
   301  		result.sc.Response = autorest.Response{Response: resp}
   302  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "List", resp, "Failure sending request")
   303  		return
   304  	}
   305  
   306  	result.sc, err = client.ListResponder(resp)
   307  	if err != nil {
   308  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "List", resp, "Failure responding to request")
   309  		return
   310  	}
   311  	if result.sc.hasNextLink() && result.sc.IsEmpty() {
   312  		err = result.NextWithContext(ctx)
   313  		return
   314  	}
   315  
   316  	return
   317  }
   318  
   319  // ListPreparer prepares the List request.
   320  func (client MediaservicesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
   321  	pathParameters := map[string]interface{}{
   322  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   323  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   324  	}
   325  
   326  	const APIVersion = "2021-06-01"
   327  	queryParameters := map[string]interface{}{
   328  		"api-version": APIVersion,
   329  	}
   330  
   331  	preparer := autorest.CreatePreparer(
   332  		autorest.AsGet(),
   333  		autorest.WithBaseURL(client.BaseURI),
   334  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaservices", pathParameters),
   335  		autorest.WithQueryParameters(queryParameters))
   336  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   337  }
   338  
   339  // ListSender sends the List request. The method will close the
   340  // http.Response Body if it receives an error.
   341  func (client MediaservicesClient) ListSender(req *http.Request) (*http.Response, error) {
   342  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   343  }
   344  
   345  // ListResponder handles the response to the List request. The method always
   346  // closes the http.Response Body.
   347  func (client MediaservicesClient) ListResponder(resp *http.Response) (result ServiceCollection, err error) {
   348  	err = autorest.Respond(
   349  		resp,
   350  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   351  		autorest.ByUnmarshallingJSON(&result),
   352  		autorest.ByClosing())
   353  	result.Response = autorest.Response{Response: resp}
   354  	return
   355  }
   356  
   357  // listNextResults retrieves the next set of results, if any.
   358  func (client MediaservicesClient) listNextResults(ctx context.Context, lastResults ServiceCollection) (result ServiceCollection, err error) {
   359  	req, err := lastResults.serviceCollectionPreparer(ctx)
   360  	if err != nil {
   361  		return result, autorest.NewErrorWithError(err, "media.MediaservicesClient", "listNextResults", nil, "Failure preparing next results request")
   362  	}
   363  	if req == nil {
   364  		return
   365  	}
   366  	resp, err := client.ListSender(req)
   367  	if err != nil {
   368  		result.Response = autorest.Response{Response: resp}
   369  		return result, autorest.NewErrorWithError(err, "media.MediaservicesClient", "listNextResults", resp, "Failure sending next results request")
   370  	}
   371  	result, err = client.ListResponder(resp)
   372  	if err != nil {
   373  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "listNextResults", resp, "Failure responding to next results request")
   374  	}
   375  	return
   376  }
   377  
   378  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   379  func (client MediaservicesClient) ListComplete(ctx context.Context, resourceGroupName string) (result ServiceCollectionIterator, err error) {
   380  	if tracing.IsEnabled() {
   381  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.List")
   382  		defer func() {
   383  			sc := -1
   384  			if result.Response().Response.Response != nil {
   385  				sc = result.page.Response().Response.Response.StatusCode
   386  			}
   387  			tracing.EndSpan(ctx, sc, err)
   388  		}()
   389  	}
   390  	result.page, err = client.List(ctx, resourceGroupName)
   391  	return
   392  }
   393  
   394  // ListBySubscription list Media Services accounts in the subscription.
   395  func (client MediaservicesClient) ListBySubscription(ctx context.Context) (result ServiceCollectionPage, err error) {
   396  	if tracing.IsEnabled() {
   397  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.ListBySubscription")
   398  		defer func() {
   399  			sc := -1
   400  			if result.sc.Response.Response != nil {
   401  				sc = result.sc.Response.Response.StatusCode
   402  			}
   403  			tracing.EndSpan(ctx, sc, err)
   404  		}()
   405  	}
   406  	result.fn = client.listBySubscriptionNextResults
   407  	req, err := client.ListBySubscriptionPreparer(ctx)
   408  	if err != nil {
   409  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "ListBySubscription", nil, "Failure preparing request")
   410  		return
   411  	}
   412  
   413  	resp, err := client.ListBySubscriptionSender(req)
   414  	if err != nil {
   415  		result.sc.Response = autorest.Response{Response: resp}
   416  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "ListBySubscription", resp, "Failure sending request")
   417  		return
   418  	}
   419  
   420  	result.sc, err = client.ListBySubscriptionResponder(resp)
   421  	if err != nil {
   422  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "ListBySubscription", resp, "Failure responding to request")
   423  		return
   424  	}
   425  	if result.sc.hasNextLink() && result.sc.IsEmpty() {
   426  		err = result.NextWithContext(ctx)
   427  		return
   428  	}
   429  
   430  	return
   431  }
   432  
   433  // ListBySubscriptionPreparer prepares the ListBySubscription request.
   434  func (client MediaservicesClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) {
   435  	pathParameters := map[string]interface{}{
   436  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   437  	}
   438  
   439  	const APIVersion = "2021-06-01"
   440  	queryParameters := map[string]interface{}{
   441  		"api-version": APIVersion,
   442  	}
   443  
   444  	preparer := autorest.CreatePreparer(
   445  		autorest.AsGet(),
   446  		autorest.WithBaseURL(client.BaseURI),
   447  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Media/mediaservices", pathParameters),
   448  		autorest.WithQueryParameters(queryParameters))
   449  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   450  }
   451  
   452  // ListBySubscriptionSender sends the ListBySubscription request. The method will close the
   453  // http.Response Body if it receives an error.
   454  func (client MediaservicesClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
   455  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   456  }
   457  
   458  // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
   459  // closes the http.Response Body.
   460  func (client MediaservicesClient) ListBySubscriptionResponder(resp *http.Response) (result ServiceCollection, err error) {
   461  	err = autorest.Respond(
   462  		resp,
   463  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   464  		autorest.ByUnmarshallingJSON(&result),
   465  		autorest.ByClosing())
   466  	result.Response = autorest.Response{Response: resp}
   467  	return
   468  }
   469  
   470  // listBySubscriptionNextResults retrieves the next set of results, if any.
   471  func (client MediaservicesClient) listBySubscriptionNextResults(ctx context.Context, lastResults ServiceCollection) (result ServiceCollection, err error) {
   472  	req, err := lastResults.serviceCollectionPreparer(ctx)
   473  	if err != nil {
   474  		return result, autorest.NewErrorWithError(err, "media.MediaservicesClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
   475  	}
   476  	if req == nil {
   477  		return
   478  	}
   479  	resp, err := client.ListBySubscriptionSender(req)
   480  	if err != nil {
   481  		result.Response = autorest.Response{Response: resp}
   482  		return result, autorest.NewErrorWithError(err, "media.MediaservicesClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
   483  	}
   484  	result, err = client.ListBySubscriptionResponder(resp)
   485  	if err != nil {
   486  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
   487  	}
   488  	return
   489  }
   490  
   491  // ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
   492  func (client MediaservicesClient) ListBySubscriptionComplete(ctx context.Context) (result ServiceCollectionIterator, err error) {
   493  	if tracing.IsEnabled() {
   494  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.ListBySubscription")
   495  		defer func() {
   496  			sc := -1
   497  			if result.Response().Response.Response != nil {
   498  				sc = result.page.Response().Response.Response.StatusCode
   499  			}
   500  			tracing.EndSpan(ctx, sc, err)
   501  		}()
   502  	}
   503  	result.page, err = client.ListBySubscription(ctx)
   504  	return
   505  }
   506  
   507  // ListEdgePolicies list the media edge policies associated with the Media Services account.
   508  // Parameters:
   509  // resourceGroupName - the name of the resource group within the Azure subscription.
   510  // accountName - the Media Services account name.
   511  // parameters - the request parameters
   512  func (client MediaservicesClient) ListEdgePolicies(ctx context.Context, resourceGroupName string, accountName string, parameters ListEdgePoliciesInput) (result EdgePolicies, err error) {
   513  	if tracing.IsEnabled() {
   514  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.ListEdgePolicies")
   515  		defer func() {
   516  			sc := -1
   517  			if result.Response.Response != nil {
   518  				sc = result.Response.Response.StatusCode
   519  			}
   520  			tracing.EndSpan(ctx, sc, err)
   521  		}()
   522  	}
   523  	req, err := client.ListEdgePoliciesPreparer(ctx, resourceGroupName, accountName, parameters)
   524  	if err != nil {
   525  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "ListEdgePolicies", nil, "Failure preparing request")
   526  		return
   527  	}
   528  
   529  	resp, err := client.ListEdgePoliciesSender(req)
   530  	if err != nil {
   531  		result.Response = autorest.Response{Response: resp}
   532  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "ListEdgePolicies", resp, "Failure sending request")
   533  		return
   534  	}
   535  
   536  	result, err = client.ListEdgePoliciesResponder(resp)
   537  	if err != nil {
   538  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "ListEdgePolicies", resp, "Failure responding to request")
   539  		return
   540  	}
   541  
   542  	return
   543  }
   544  
   545  // ListEdgePoliciesPreparer prepares the ListEdgePolicies request.
   546  func (client MediaservicesClient) ListEdgePoliciesPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters ListEdgePoliciesInput) (*http.Request, error) {
   547  	pathParameters := map[string]interface{}{
   548  		"accountName":       autorest.Encode("path", accountName),
   549  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   550  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   551  	}
   552  
   553  	const APIVersion = "2021-06-01"
   554  	queryParameters := map[string]interface{}{
   555  		"api-version": APIVersion,
   556  	}
   557  
   558  	preparer := autorest.CreatePreparer(
   559  		autorest.AsContentType("application/json; charset=utf-8"),
   560  		autorest.AsPost(),
   561  		autorest.WithBaseURL(client.BaseURI),
   562  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaservices/{accountName}/listEdgePolicies", pathParameters),
   563  		autorest.WithJSON(parameters),
   564  		autorest.WithQueryParameters(queryParameters))
   565  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   566  }
   567  
   568  // ListEdgePoliciesSender sends the ListEdgePolicies request. The method will close the
   569  // http.Response Body if it receives an error.
   570  func (client MediaservicesClient) ListEdgePoliciesSender(req *http.Request) (*http.Response, error) {
   571  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   572  }
   573  
   574  // ListEdgePoliciesResponder handles the response to the ListEdgePolicies request. The method always
   575  // closes the http.Response Body.
   576  func (client MediaservicesClient) ListEdgePoliciesResponder(resp *http.Response) (result EdgePolicies, err error) {
   577  	err = autorest.Respond(
   578  		resp,
   579  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   580  		autorest.ByUnmarshallingJSON(&result),
   581  		autorest.ByClosing())
   582  	result.Response = autorest.Response{Response: resp}
   583  	return
   584  }
   585  
   586  // SyncStorageKeys synchronizes storage account keys for a storage account associated with the Media Service account.
   587  // Parameters:
   588  // resourceGroupName - the name of the resource group within the Azure subscription.
   589  // accountName - the Media Services account name.
   590  // parameters - the request parameters
   591  func (client MediaservicesClient) SyncStorageKeys(ctx context.Context, resourceGroupName string, accountName string, parameters SyncStorageKeysInput) (result autorest.Response, err error) {
   592  	if tracing.IsEnabled() {
   593  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.SyncStorageKeys")
   594  		defer func() {
   595  			sc := -1
   596  			if result.Response != nil {
   597  				sc = result.Response.StatusCode
   598  			}
   599  			tracing.EndSpan(ctx, sc, err)
   600  		}()
   601  	}
   602  	req, err := client.SyncStorageKeysPreparer(ctx, resourceGroupName, accountName, parameters)
   603  	if err != nil {
   604  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "SyncStorageKeys", nil, "Failure preparing request")
   605  		return
   606  	}
   607  
   608  	resp, err := client.SyncStorageKeysSender(req)
   609  	if err != nil {
   610  		result.Response = resp
   611  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "SyncStorageKeys", resp, "Failure sending request")
   612  		return
   613  	}
   614  
   615  	result, err = client.SyncStorageKeysResponder(resp)
   616  	if err != nil {
   617  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "SyncStorageKeys", resp, "Failure responding to request")
   618  		return
   619  	}
   620  
   621  	return
   622  }
   623  
   624  // SyncStorageKeysPreparer prepares the SyncStorageKeys request.
   625  func (client MediaservicesClient) SyncStorageKeysPreparer(ctx context.Context, resourceGroupName string, accountName string, parameters SyncStorageKeysInput) (*http.Request, error) {
   626  	pathParameters := map[string]interface{}{
   627  		"accountName":       autorest.Encode("path", accountName),
   628  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   629  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   630  	}
   631  
   632  	const APIVersion = "2021-06-01"
   633  	queryParameters := map[string]interface{}{
   634  		"api-version": APIVersion,
   635  	}
   636  
   637  	preparer := autorest.CreatePreparer(
   638  		autorest.AsContentType("application/json; charset=utf-8"),
   639  		autorest.AsPost(),
   640  		autorest.WithBaseURL(client.BaseURI),
   641  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaservices/{accountName}/syncStorageKeys", pathParameters),
   642  		autorest.WithJSON(parameters),
   643  		autorest.WithQueryParameters(queryParameters))
   644  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   645  }
   646  
   647  // SyncStorageKeysSender sends the SyncStorageKeys request. The method will close the
   648  // http.Response Body if it receives an error.
   649  func (client MediaservicesClient) SyncStorageKeysSender(req *http.Request) (*http.Response, error) {
   650  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   651  }
   652  
   653  // SyncStorageKeysResponder handles the response to the SyncStorageKeys request. The method always
   654  // closes the http.Response Body.
   655  func (client MediaservicesClient) SyncStorageKeysResponder(resp *http.Response) (result autorest.Response, err error) {
   656  	err = autorest.Respond(
   657  		resp,
   658  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   659  		autorest.ByClosing())
   660  	result.Response = resp
   661  	return
   662  }
   663  
   664  // Update updates an existing Media Services account
   665  // Parameters:
   666  // resourceGroupName - the name of the resource group within the Azure subscription.
   667  // accountName - the Media Services account name.
   668  // parameters - the request parameters
   669  func (client MediaservicesClient) Update(ctx context.Context, resourceGroupName string, accountName string, parameters ServiceUpdate) (result Service, err error) {
   670  	if tracing.IsEnabled() {
   671  		ctx = tracing.StartSpan(ctx, fqdn+"/MediaservicesClient.Update")
   672  		defer func() {
   673  			sc := -1
   674  			if result.Response.Response != nil {
   675  				sc = result.Response.Response.StatusCode
   676  			}
   677  			tracing.EndSpan(ctx, sc, err)
   678  		}()
   679  	}
   680  	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, parameters)
   681  	if err != nil {
   682  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Update", nil, "Failure preparing request")
   683  		return
   684  	}
   685  
   686  	resp, err := client.UpdateSender(req)
   687  	if err != nil {
   688  		result.Response = autorest.Response{Response: resp}
   689  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Update", resp, "Failure sending request")
   690  		return
   691  	}
   692  
   693  	result, err = client.UpdateResponder(resp)
   694  	if err != nil {
   695  		err = autorest.NewErrorWithError(err, "media.MediaservicesClient", "Update", resp, "Failure responding to request")
   696  		return
   697  	}
   698  
   699  	return
   700  }
   701  
   702  // UpdatePreparer prepares the Update request.
   703  func (client MediaservicesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters ServiceUpdate) (*http.Request, error) {
   704  	pathParameters := map[string]interface{}{
   705  		"accountName":       autorest.Encode("path", accountName),
   706  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   707  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   708  	}
   709  
   710  	const APIVersion = "2021-06-01"
   711  	queryParameters := map[string]interface{}{
   712  		"api-version": APIVersion,
   713  	}
   714  
   715  	preparer := autorest.CreatePreparer(
   716  		autorest.AsContentType("application/json; charset=utf-8"),
   717  		autorest.AsPatch(),
   718  		autorest.WithBaseURL(client.BaseURI),
   719  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaservices/{accountName}", pathParameters),
   720  		autorest.WithJSON(parameters),
   721  		autorest.WithQueryParameters(queryParameters))
   722  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   723  }
   724  
   725  // UpdateSender sends the Update request. The method will close the
   726  // http.Response Body if it receives an error.
   727  func (client MediaservicesClient) UpdateSender(req *http.Request) (*http.Response, error) {
   728  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   729  }
   730  
   731  // UpdateResponder handles the response to the Update request. The method always
   732  // closes the http.Response Body.
   733  func (client MediaservicesClient) UpdateResponder(resp *http.Response) (result Service, err error) {
   734  	err = autorest.Respond(
   735  		resp,
   736  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   737  		autorest.ByUnmarshallingJSON(&result),
   738  		autorest.ByClosing())
   739  	result.Response = autorest.Response{Response: resp}
   740  	return
   741  }
   742
View as plain text