mediaservices.go

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