service.go

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