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