Source file src/github.com/Azure/azure-sdk-for-go/services/mediaservices/mgmt/2018-07-01/media/liveevents.go

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

View as plain text