trigger.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/synapse/2019-06-01-preview/artifacts

     1  package artifacts
     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  // TriggerClient is the client for the Trigger methods of the Artifacts service.
    19  type TriggerClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewTriggerClient creates an instance of the TriggerClient client.
    24  func NewTriggerClient(endpoint string) TriggerClient {
    25  	return TriggerClient{New(endpoint)}
    26  }
    27  
    28  // CreateOrUpdateTrigger creates or updates a trigger.
    29  // Parameters:
    30  // triggerName - the trigger name.
    31  // trigger - trigger resource definition.
    32  // ifMatch - eTag of the trigger entity.  Should only be specified for update, for which it should match
    33  // existing entity or can be * for unconditional update.
    34  func (client TriggerClient) CreateOrUpdateTrigger(ctx context.Context, triggerName string, trigger TriggerResource, ifMatch string) (result TriggerCreateOrUpdateTriggerFuture, err error) {
    35  	if tracing.IsEnabled() {
    36  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.CreateOrUpdateTrigger")
    37  		defer func() {
    38  			sc := -1
    39  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    40  				sc = result.FutureAPI.Response().StatusCode
    41  			}
    42  			tracing.EndSpan(ctx, sc, err)
    43  		}()
    44  	}
    45  	if err := validation.Validate([]validation.Validation{
    46  		{TargetValue: triggerName,
    47  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
    48  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
    49  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
    50  		return result, validation.NewError("artifacts.TriggerClient", "CreateOrUpdateTrigger", err.Error())
    51  	}
    52  
    53  	req, err := client.CreateOrUpdateTriggerPreparer(ctx, triggerName, trigger, ifMatch)
    54  	if err != nil {
    55  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "CreateOrUpdateTrigger", nil, "Failure preparing request")
    56  		return
    57  	}
    58  
    59  	result, err = client.CreateOrUpdateTriggerSender(req)
    60  	if err != nil {
    61  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "CreateOrUpdateTrigger", nil, "Failure sending request")
    62  		return
    63  	}
    64  
    65  	return
    66  }
    67  
    68  // CreateOrUpdateTriggerPreparer prepares the CreateOrUpdateTrigger request.
    69  func (client TriggerClient) CreateOrUpdateTriggerPreparer(ctx context.Context, triggerName string, trigger TriggerResource, ifMatch string) (*http.Request, error) {
    70  	urlParameters := map[string]interface{}{
    71  		"endpoint": client.Endpoint,
    72  	}
    73  
    74  	pathParameters := map[string]interface{}{
    75  		"triggerName": autorest.Encode("path", triggerName),
    76  	}
    77  
    78  	const APIVersion = "2019-06-01-preview"
    79  	queryParameters := map[string]interface{}{
    80  		"api-version": APIVersion,
    81  	}
    82  
    83  	preparer := autorest.CreatePreparer(
    84  		autorest.AsContentType("application/json; charset=utf-8"),
    85  		autorest.AsPut(),
    86  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
    87  		autorest.WithPathParameters("/triggers/{triggerName}", pathParameters),
    88  		autorest.WithJSON(trigger),
    89  		autorest.WithQueryParameters(queryParameters))
    90  	if len(ifMatch) > 0 {
    91  		preparer = autorest.DecoratePreparer(preparer,
    92  			autorest.WithHeader("If-Match", autorest.String(ifMatch)))
    93  	}
    94  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    95  }
    96  
    97  // CreateOrUpdateTriggerSender sends the CreateOrUpdateTrigger request. The method will close the
    98  // http.Response Body if it receives an error.
    99  func (client TriggerClient) CreateOrUpdateTriggerSender(req *http.Request) (future TriggerCreateOrUpdateTriggerFuture, err error) {
   100  	var resp *http.Response
   101  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   102  	if err != nil {
   103  		return
   104  	}
   105  	var azf azure.Future
   106  	azf, err = azure.NewFutureFromResponse(resp)
   107  	future.FutureAPI = &azf
   108  	future.Result = future.result
   109  	return
   110  }
   111  
   112  // CreateOrUpdateTriggerResponder handles the response to the CreateOrUpdateTrigger request. The method always
   113  // closes the http.Response Body.
   114  func (client TriggerClient) CreateOrUpdateTriggerResponder(resp *http.Response) (result TriggerResource, err error) {
   115  	err = autorest.Respond(
   116  		resp,
   117  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   118  		autorest.ByUnmarshallingJSON(&result),
   119  		autorest.ByClosing())
   120  	result.Response = autorest.Response{Response: resp}
   121  	return
   122  }
   123  
   124  // DeleteTrigger deletes a trigger.
   125  // Parameters:
   126  // triggerName - the trigger name.
   127  func (client TriggerClient) DeleteTrigger(ctx context.Context, triggerName string) (result TriggerDeleteTriggerFuture, err error) {
   128  	if tracing.IsEnabled() {
   129  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.DeleteTrigger")
   130  		defer func() {
   131  			sc := -1
   132  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   133  				sc = result.FutureAPI.Response().StatusCode
   134  			}
   135  			tracing.EndSpan(ctx, sc, err)
   136  		}()
   137  	}
   138  	if err := validation.Validate([]validation.Validation{
   139  		{TargetValue: triggerName,
   140  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   141  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
   142  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   143  		return result, validation.NewError("artifacts.TriggerClient", "DeleteTrigger", err.Error())
   144  	}
   145  
   146  	req, err := client.DeleteTriggerPreparer(ctx, triggerName)
   147  	if err != nil {
   148  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "DeleteTrigger", nil, "Failure preparing request")
   149  		return
   150  	}
   151  
   152  	result, err = client.DeleteTriggerSender(req)
   153  	if err != nil {
   154  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "DeleteTrigger", nil, "Failure sending request")
   155  		return
   156  	}
   157  
   158  	return
   159  }
   160  
   161  // DeleteTriggerPreparer prepares the DeleteTrigger request.
   162  func (client TriggerClient) DeleteTriggerPreparer(ctx context.Context, triggerName string) (*http.Request, error) {
   163  	urlParameters := map[string]interface{}{
   164  		"endpoint": client.Endpoint,
   165  	}
   166  
   167  	pathParameters := map[string]interface{}{
   168  		"triggerName": autorest.Encode("path", triggerName),
   169  	}
   170  
   171  	const APIVersion = "2019-06-01-preview"
   172  	queryParameters := map[string]interface{}{
   173  		"api-version": APIVersion,
   174  	}
   175  
   176  	preparer := autorest.CreatePreparer(
   177  		autorest.AsDelete(),
   178  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   179  		autorest.WithPathParameters("/triggers/{triggerName}", pathParameters),
   180  		autorest.WithQueryParameters(queryParameters))
   181  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   182  }
   183  
   184  // DeleteTriggerSender sends the DeleteTrigger request. The method will close the
   185  // http.Response Body if it receives an error.
   186  func (client TriggerClient) DeleteTriggerSender(req *http.Request) (future TriggerDeleteTriggerFuture, err error) {
   187  	var resp *http.Response
   188  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   189  	if err != nil {
   190  		return
   191  	}
   192  	var azf azure.Future
   193  	azf, err = azure.NewFutureFromResponse(resp)
   194  	future.FutureAPI = &azf
   195  	future.Result = future.result
   196  	return
   197  }
   198  
   199  // DeleteTriggerResponder handles the response to the DeleteTrigger request. The method always
   200  // closes the http.Response Body.
   201  func (client TriggerClient) DeleteTriggerResponder(resp *http.Response) (result autorest.Response, err error) {
   202  	err = autorest.Respond(
   203  		resp,
   204  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   205  		autorest.ByClosing())
   206  	result.Response = resp
   207  	return
   208  }
   209  
   210  // GetEventSubscriptionStatus get a trigger's event subscription status.
   211  // Parameters:
   212  // triggerName - the trigger name.
   213  func (client TriggerClient) GetEventSubscriptionStatus(ctx context.Context, triggerName string) (result TriggerSubscriptionOperationStatus, err error) {
   214  	if tracing.IsEnabled() {
   215  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.GetEventSubscriptionStatus")
   216  		defer func() {
   217  			sc := -1
   218  			if result.Response.Response != nil {
   219  				sc = result.Response.Response.StatusCode
   220  			}
   221  			tracing.EndSpan(ctx, sc, err)
   222  		}()
   223  	}
   224  	if err := validation.Validate([]validation.Validation{
   225  		{TargetValue: triggerName,
   226  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   227  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
   228  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   229  		return result, validation.NewError("artifacts.TriggerClient", "GetEventSubscriptionStatus", err.Error())
   230  	}
   231  
   232  	req, err := client.GetEventSubscriptionStatusPreparer(ctx, triggerName)
   233  	if err != nil {
   234  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetEventSubscriptionStatus", nil, "Failure preparing request")
   235  		return
   236  	}
   237  
   238  	resp, err := client.GetEventSubscriptionStatusSender(req)
   239  	if err != nil {
   240  		result.Response = autorest.Response{Response: resp}
   241  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetEventSubscriptionStatus", resp, "Failure sending request")
   242  		return
   243  	}
   244  
   245  	result, err = client.GetEventSubscriptionStatusResponder(resp)
   246  	if err != nil {
   247  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetEventSubscriptionStatus", resp, "Failure responding to request")
   248  		return
   249  	}
   250  
   251  	return
   252  }
   253  
   254  // GetEventSubscriptionStatusPreparer prepares the GetEventSubscriptionStatus request.
   255  func (client TriggerClient) GetEventSubscriptionStatusPreparer(ctx context.Context, triggerName string) (*http.Request, error) {
   256  	urlParameters := map[string]interface{}{
   257  		"endpoint": client.Endpoint,
   258  	}
   259  
   260  	pathParameters := map[string]interface{}{
   261  		"triggerName": autorest.Encode("path", triggerName),
   262  	}
   263  
   264  	const APIVersion = "2019-06-01-preview"
   265  	queryParameters := map[string]interface{}{
   266  		"api-version": APIVersion,
   267  	}
   268  
   269  	preparer := autorest.CreatePreparer(
   270  		autorest.AsPost(),
   271  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   272  		autorest.WithPathParameters("/triggers/{triggerName}/getEventSubscriptionStatus", pathParameters),
   273  		autorest.WithQueryParameters(queryParameters))
   274  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   275  }
   276  
   277  // GetEventSubscriptionStatusSender sends the GetEventSubscriptionStatus request. The method will close the
   278  // http.Response Body if it receives an error.
   279  func (client TriggerClient) GetEventSubscriptionStatusSender(req *http.Request) (*http.Response, error) {
   280  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   281  }
   282  
   283  // GetEventSubscriptionStatusResponder handles the response to the GetEventSubscriptionStatus request. The method always
   284  // closes the http.Response Body.
   285  func (client TriggerClient) GetEventSubscriptionStatusResponder(resp *http.Response) (result TriggerSubscriptionOperationStatus, err error) {
   286  	err = autorest.Respond(
   287  		resp,
   288  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   289  		autorest.ByUnmarshallingJSON(&result),
   290  		autorest.ByClosing())
   291  	result.Response = autorest.Response{Response: resp}
   292  	return
   293  }
   294  
   295  // GetTrigger gets a trigger.
   296  // Parameters:
   297  // triggerName - the trigger name.
   298  // ifNoneMatch - eTag of the trigger entity. Should only be specified for get. If the ETag matches the existing
   299  // entity tag, or if * was provided, then no content will be returned.
   300  func (client TriggerClient) GetTrigger(ctx context.Context, triggerName string, ifNoneMatch string) (result TriggerResource, err error) {
   301  	if tracing.IsEnabled() {
   302  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.GetTrigger")
   303  		defer func() {
   304  			sc := -1
   305  			if result.Response.Response != nil {
   306  				sc = result.Response.Response.StatusCode
   307  			}
   308  			tracing.EndSpan(ctx, sc, err)
   309  		}()
   310  	}
   311  	if err := validation.Validate([]validation.Validation{
   312  		{TargetValue: triggerName,
   313  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   314  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
   315  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   316  		return result, validation.NewError("artifacts.TriggerClient", "GetTrigger", err.Error())
   317  	}
   318  
   319  	req, err := client.GetTriggerPreparer(ctx, triggerName, ifNoneMatch)
   320  	if err != nil {
   321  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetTrigger", nil, "Failure preparing request")
   322  		return
   323  	}
   324  
   325  	resp, err := client.GetTriggerSender(req)
   326  	if err != nil {
   327  		result.Response = autorest.Response{Response: resp}
   328  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetTrigger", resp, "Failure sending request")
   329  		return
   330  	}
   331  
   332  	result, err = client.GetTriggerResponder(resp)
   333  	if err != nil {
   334  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetTrigger", resp, "Failure responding to request")
   335  		return
   336  	}
   337  
   338  	return
   339  }
   340  
   341  // GetTriggerPreparer prepares the GetTrigger request.
   342  func (client TriggerClient) GetTriggerPreparer(ctx context.Context, triggerName string, ifNoneMatch string) (*http.Request, error) {
   343  	urlParameters := map[string]interface{}{
   344  		"endpoint": client.Endpoint,
   345  	}
   346  
   347  	pathParameters := map[string]interface{}{
   348  		"triggerName": autorest.Encode("path", triggerName),
   349  	}
   350  
   351  	const APIVersion = "2019-06-01-preview"
   352  	queryParameters := map[string]interface{}{
   353  		"api-version": APIVersion,
   354  	}
   355  
   356  	preparer := autorest.CreatePreparer(
   357  		autorest.AsGet(),
   358  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   359  		autorest.WithPathParameters("/triggers/{triggerName}", pathParameters),
   360  		autorest.WithQueryParameters(queryParameters))
   361  	if len(ifNoneMatch) > 0 {
   362  		preparer = autorest.DecoratePreparer(preparer,
   363  			autorest.WithHeader("If-None-Match", autorest.String(ifNoneMatch)))
   364  	}
   365  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   366  }
   367  
   368  // GetTriggerSender sends the GetTrigger request. The method will close the
   369  // http.Response Body if it receives an error.
   370  func (client TriggerClient) GetTriggerSender(req *http.Request) (*http.Response, error) {
   371  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   372  }
   373  
   374  // GetTriggerResponder handles the response to the GetTrigger request. The method always
   375  // closes the http.Response Body.
   376  func (client TriggerClient) GetTriggerResponder(resp *http.Response) (result TriggerResource, err error) {
   377  	err = autorest.Respond(
   378  		resp,
   379  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotModified),
   380  		autorest.ByUnmarshallingJSON(&result),
   381  		autorest.ByClosing())
   382  	result.Response = autorest.Response{Response: resp}
   383  	return
   384  }
   385  
   386  // GetTriggersByWorkspace lists triggers.
   387  func (client TriggerClient) GetTriggersByWorkspace(ctx context.Context) (result TriggerListResponsePage, err error) {
   388  	if tracing.IsEnabled() {
   389  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.GetTriggersByWorkspace")
   390  		defer func() {
   391  			sc := -1
   392  			if result.tlr.Response.Response != nil {
   393  				sc = result.tlr.Response.Response.StatusCode
   394  			}
   395  			tracing.EndSpan(ctx, sc, err)
   396  		}()
   397  	}
   398  	result.fn = client.getTriggersByWorkspaceNextResults
   399  	req, err := client.GetTriggersByWorkspacePreparer(ctx)
   400  	if err != nil {
   401  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetTriggersByWorkspace", nil, "Failure preparing request")
   402  		return
   403  	}
   404  
   405  	resp, err := client.GetTriggersByWorkspaceSender(req)
   406  	if err != nil {
   407  		result.tlr.Response = autorest.Response{Response: resp}
   408  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetTriggersByWorkspace", resp, "Failure sending request")
   409  		return
   410  	}
   411  
   412  	result.tlr, err = client.GetTriggersByWorkspaceResponder(resp)
   413  	if err != nil {
   414  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "GetTriggersByWorkspace", resp, "Failure responding to request")
   415  		return
   416  	}
   417  	if result.tlr.hasNextLink() && result.tlr.IsEmpty() {
   418  		err = result.NextWithContext(ctx)
   419  		return
   420  	}
   421  
   422  	return
   423  }
   424  
   425  // GetTriggersByWorkspacePreparer prepares the GetTriggersByWorkspace request.
   426  func (client TriggerClient) GetTriggersByWorkspacePreparer(ctx context.Context) (*http.Request, error) {
   427  	urlParameters := map[string]interface{}{
   428  		"endpoint": client.Endpoint,
   429  	}
   430  
   431  	const APIVersion = "2019-06-01-preview"
   432  	queryParameters := map[string]interface{}{
   433  		"api-version": APIVersion,
   434  	}
   435  
   436  	preparer := autorest.CreatePreparer(
   437  		autorest.AsGet(),
   438  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   439  		autorest.WithPath("/triggers"),
   440  		autorest.WithQueryParameters(queryParameters))
   441  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   442  }
   443  
   444  // GetTriggersByWorkspaceSender sends the GetTriggersByWorkspace request. The method will close the
   445  // http.Response Body if it receives an error.
   446  func (client TriggerClient) GetTriggersByWorkspaceSender(req *http.Request) (*http.Response, error) {
   447  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   448  }
   449  
   450  // GetTriggersByWorkspaceResponder handles the response to the GetTriggersByWorkspace request. The method always
   451  // closes the http.Response Body.
   452  func (client TriggerClient) GetTriggersByWorkspaceResponder(resp *http.Response) (result TriggerListResponse, err error) {
   453  	err = autorest.Respond(
   454  		resp,
   455  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   456  		autorest.ByUnmarshallingJSON(&result),
   457  		autorest.ByClosing())
   458  	result.Response = autorest.Response{Response: resp}
   459  	return
   460  }
   461  
   462  // getTriggersByWorkspaceNextResults retrieves the next set of results, if any.
   463  func (client TriggerClient) getTriggersByWorkspaceNextResults(ctx context.Context, lastResults TriggerListResponse) (result TriggerListResponse, err error) {
   464  	req, err := lastResults.triggerListResponsePreparer(ctx)
   465  	if err != nil {
   466  		return result, autorest.NewErrorWithError(err, "artifacts.TriggerClient", "getTriggersByWorkspaceNextResults", nil, "Failure preparing next results request")
   467  	}
   468  	if req == nil {
   469  		return
   470  	}
   471  	resp, err := client.GetTriggersByWorkspaceSender(req)
   472  	if err != nil {
   473  		result.Response = autorest.Response{Response: resp}
   474  		return result, autorest.NewErrorWithError(err, "artifacts.TriggerClient", "getTriggersByWorkspaceNextResults", resp, "Failure sending next results request")
   475  	}
   476  	result, err = client.GetTriggersByWorkspaceResponder(resp)
   477  	if err != nil {
   478  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "getTriggersByWorkspaceNextResults", resp, "Failure responding to next results request")
   479  	}
   480  	return
   481  }
   482  
   483  // GetTriggersByWorkspaceComplete enumerates all values, automatically crossing page boundaries as required.
   484  func (client TriggerClient) GetTriggersByWorkspaceComplete(ctx context.Context) (result TriggerListResponseIterator, err error) {
   485  	if tracing.IsEnabled() {
   486  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.GetTriggersByWorkspace")
   487  		defer func() {
   488  			sc := -1
   489  			if result.Response().Response.Response != nil {
   490  				sc = result.page.Response().Response.Response.StatusCode
   491  			}
   492  			tracing.EndSpan(ctx, sc, err)
   493  		}()
   494  	}
   495  	result.page, err = client.GetTriggersByWorkspace(ctx)
   496  	return
   497  }
   498  
   499  // StartTrigger starts a trigger.
   500  // Parameters:
   501  // triggerName - the trigger name.
   502  func (client TriggerClient) StartTrigger(ctx context.Context, triggerName string) (result TriggerStartTriggerFuture, err error) {
   503  	if tracing.IsEnabled() {
   504  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.StartTrigger")
   505  		defer func() {
   506  			sc := -1
   507  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   508  				sc = result.FutureAPI.Response().StatusCode
   509  			}
   510  			tracing.EndSpan(ctx, sc, err)
   511  		}()
   512  	}
   513  	if err := validation.Validate([]validation.Validation{
   514  		{TargetValue: triggerName,
   515  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   516  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
   517  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   518  		return result, validation.NewError("artifacts.TriggerClient", "StartTrigger", err.Error())
   519  	}
   520  
   521  	req, err := client.StartTriggerPreparer(ctx, triggerName)
   522  	if err != nil {
   523  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "StartTrigger", nil, "Failure preparing request")
   524  		return
   525  	}
   526  
   527  	result, err = client.StartTriggerSender(req)
   528  	if err != nil {
   529  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "StartTrigger", nil, "Failure sending request")
   530  		return
   531  	}
   532  
   533  	return
   534  }
   535  
   536  // StartTriggerPreparer prepares the StartTrigger request.
   537  func (client TriggerClient) StartTriggerPreparer(ctx context.Context, triggerName string) (*http.Request, error) {
   538  	urlParameters := map[string]interface{}{
   539  		"endpoint": client.Endpoint,
   540  	}
   541  
   542  	pathParameters := map[string]interface{}{
   543  		"triggerName": autorest.Encode("path", triggerName),
   544  	}
   545  
   546  	const APIVersion = "2019-06-01-preview"
   547  	queryParameters := map[string]interface{}{
   548  		"api-version": APIVersion,
   549  	}
   550  
   551  	preparer := autorest.CreatePreparer(
   552  		autorest.AsPost(),
   553  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   554  		autorest.WithPathParameters("/triggers/{triggerName}/start", pathParameters),
   555  		autorest.WithQueryParameters(queryParameters))
   556  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   557  }
   558  
   559  // StartTriggerSender sends the StartTrigger request. The method will close the
   560  // http.Response Body if it receives an error.
   561  func (client TriggerClient) StartTriggerSender(req *http.Request) (future TriggerStartTriggerFuture, err error) {
   562  	var resp *http.Response
   563  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   564  	if err != nil {
   565  		return
   566  	}
   567  	var azf azure.Future
   568  	azf, err = azure.NewFutureFromResponse(resp)
   569  	future.FutureAPI = &azf
   570  	future.Result = future.result
   571  	return
   572  }
   573  
   574  // StartTriggerResponder handles the response to the StartTrigger request. The method always
   575  // closes the http.Response Body.
   576  func (client TriggerClient) StartTriggerResponder(resp *http.Response) (result autorest.Response, err error) {
   577  	err = autorest.Respond(
   578  		resp,
   579  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   580  		autorest.ByClosing())
   581  	result.Response = resp
   582  	return
   583  }
   584  
   585  // StopTrigger stops a trigger.
   586  // Parameters:
   587  // triggerName - the trigger name.
   588  func (client TriggerClient) StopTrigger(ctx context.Context, triggerName string) (result TriggerStopTriggerFuture, err error) {
   589  	if tracing.IsEnabled() {
   590  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.StopTrigger")
   591  		defer func() {
   592  			sc := -1
   593  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   594  				sc = result.FutureAPI.Response().StatusCode
   595  			}
   596  			tracing.EndSpan(ctx, sc, err)
   597  		}()
   598  	}
   599  	if err := validation.Validate([]validation.Validation{
   600  		{TargetValue: triggerName,
   601  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   602  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
   603  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   604  		return result, validation.NewError("artifacts.TriggerClient", "StopTrigger", err.Error())
   605  	}
   606  
   607  	req, err := client.StopTriggerPreparer(ctx, triggerName)
   608  	if err != nil {
   609  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "StopTrigger", nil, "Failure preparing request")
   610  		return
   611  	}
   612  
   613  	result, err = client.StopTriggerSender(req)
   614  	if err != nil {
   615  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "StopTrigger", nil, "Failure sending request")
   616  		return
   617  	}
   618  
   619  	return
   620  }
   621  
   622  // StopTriggerPreparer prepares the StopTrigger request.
   623  func (client TriggerClient) StopTriggerPreparer(ctx context.Context, triggerName string) (*http.Request, error) {
   624  	urlParameters := map[string]interface{}{
   625  		"endpoint": client.Endpoint,
   626  	}
   627  
   628  	pathParameters := map[string]interface{}{
   629  		"triggerName": autorest.Encode("path", triggerName),
   630  	}
   631  
   632  	const APIVersion = "2019-06-01-preview"
   633  	queryParameters := map[string]interface{}{
   634  		"api-version": APIVersion,
   635  	}
   636  
   637  	preparer := autorest.CreatePreparer(
   638  		autorest.AsPost(),
   639  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   640  		autorest.WithPathParameters("/triggers/{triggerName}/stop", pathParameters),
   641  		autorest.WithQueryParameters(queryParameters))
   642  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   643  }
   644  
   645  // StopTriggerSender sends the StopTrigger request. The method will close the
   646  // http.Response Body if it receives an error.
   647  func (client TriggerClient) StopTriggerSender(req *http.Request) (future TriggerStopTriggerFuture, err error) {
   648  	var resp *http.Response
   649  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   650  	if err != nil {
   651  		return
   652  	}
   653  	var azf azure.Future
   654  	azf, err = azure.NewFutureFromResponse(resp)
   655  	future.FutureAPI = &azf
   656  	future.Result = future.result
   657  	return
   658  }
   659  
   660  // StopTriggerResponder handles the response to the StopTrigger request. The method always
   661  // closes the http.Response Body.
   662  func (client TriggerClient) StopTriggerResponder(resp *http.Response) (result autorest.Response, err error) {
   663  	err = autorest.Respond(
   664  		resp,
   665  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   666  		autorest.ByClosing())
   667  	result.Response = resp
   668  	return
   669  }
   670  
   671  // SubscribeTriggerToEvents subscribe event trigger to events.
   672  // Parameters:
   673  // triggerName - the trigger name.
   674  func (client TriggerClient) SubscribeTriggerToEvents(ctx context.Context, triggerName string) (result TriggerSubscribeTriggerToEventsFuture, err error) {
   675  	if tracing.IsEnabled() {
   676  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.SubscribeTriggerToEvents")
   677  		defer func() {
   678  			sc := -1
   679  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   680  				sc = result.FutureAPI.Response().StatusCode
   681  			}
   682  			tracing.EndSpan(ctx, sc, err)
   683  		}()
   684  	}
   685  	if err := validation.Validate([]validation.Validation{
   686  		{TargetValue: triggerName,
   687  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   688  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
   689  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   690  		return result, validation.NewError("artifacts.TriggerClient", "SubscribeTriggerToEvents", err.Error())
   691  	}
   692  
   693  	req, err := client.SubscribeTriggerToEventsPreparer(ctx, triggerName)
   694  	if err != nil {
   695  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "SubscribeTriggerToEvents", nil, "Failure preparing request")
   696  		return
   697  	}
   698  
   699  	result, err = client.SubscribeTriggerToEventsSender(req)
   700  	if err != nil {
   701  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "SubscribeTriggerToEvents", nil, "Failure sending request")
   702  		return
   703  	}
   704  
   705  	return
   706  }
   707  
   708  // SubscribeTriggerToEventsPreparer prepares the SubscribeTriggerToEvents request.
   709  func (client TriggerClient) SubscribeTriggerToEventsPreparer(ctx context.Context, triggerName string) (*http.Request, error) {
   710  	urlParameters := map[string]interface{}{
   711  		"endpoint": client.Endpoint,
   712  	}
   713  
   714  	pathParameters := map[string]interface{}{
   715  		"triggerName": autorest.Encode("path", triggerName),
   716  	}
   717  
   718  	const APIVersion = "2019-06-01-preview"
   719  	queryParameters := map[string]interface{}{
   720  		"api-version": APIVersion,
   721  	}
   722  
   723  	preparer := autorest.CreatePreparer(
   724  		autorest.AsPost(),
   725  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   726  		autorest.WithPathParameters("/triggers/{triggerName}/subscribeToEvents", pathParameters),
   727  		autorest.WithQueryParameters(queryParameters))
   728  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   729  }
   730  
   731  // SubscribeTriggerToEventsSender sends the SubscribeTriggerToEvents request. The method will close the
   732  // http.Response Body if it receives an error.
   733  func (client TriggerClient) SubscribeTriggerToEventsSender(req *http.Request) (future TriggerSubscribeTriggerToEventsFuture, err error) {
   734  	var resp *http.Response
   735  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   736  	if err != nil {
   737  		return
   738  	}
   739  	var azf azure.Future
   740  	azf, err = azure.NewFutureFromResponse(resp)
   741  	future.FutureAPI = &azf
   742  	future.Result = future.result
   743  	return
   744  }
   745  
   746  // SubscribeTriggerToEventsResponder handles the response to the SubscribeTriggerToEvents request. The method always
   747  // closes the http.Response Body.
   748  func (client TriggerClient) SubscribeTriggerToEventsResponder(resp *http.Response) (result TriggerSubscriptionOperationStatus, err error) {
   749  	err = autorest.Respond(
   750  		resp,
   751  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   752  		autorest.ByUnmarshallingJSON(&result),
   753  		autorest.ByClosing())
   754  	result.Response = autorest.Response{Response: resp}
   755  	return
   756  }
   757  
   758  // UnsubscribeTriggerFromEvents unsubscribe event trigger from events.
   759  // Parameters:
   760  // triggerName - the trigger name.
   761  func (client TriggerClient) UnsubscribeTriggerFromEvents(ctx context.Context, triggerName string) (result TriggerUnsubscribeTriggerFromEventsFuture, err error) {
   762  	if tracing.IsEnabled() {
   763  		ctx = tracing.StartSpan(ctx, fqdn+"/TriggerClient.UnsubscribeTriggerFromEvents")
   764  		defer func() {
   765  			sc := -1
   766  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   767  				sc = result.FutureAPI.Response().StatusCode
   768  			}
   769  			tracing.EndSpan(ctx, sc, err)
   770  		}()
   771  	}
   772  	if err := validation.Validate([]validation.Validation{
   773  		{TargetValue: triggerName,
   774  			Constraints: []validation.Constraint{{Target: "triggerName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   775  				{Target: "triggerName", Name: validation.MinLength, Rule: 1, Chain: nil},
   776  				{Target: "triggerName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   777  		return result, validation.NewError("artifacts.TriggerClient", "UnsubscribeTriggerFromEvents", err.Error())
   778  	}
   779  
   780  	req, err := client.UnsubscribeTriggerFromEventsPreparer(ctx, triggerName)
   781  	if err != nil {
   782  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "UnsubscribeTriggerFromEvents", nil, "Failure preparing request")
   783  		return
   784  	}
   785  
   786  	result, err = client.UnsubscribeTriggerFromEventsSender(req)
   787  	if err != nil {
   788  		err = autorest.NewErrorWithError(err, "artifacts.TriggerClient", "UnsubscribeTriggerFromEvents", nil, "Failure sending request")
   789  		return
   790  	}
   791  
   792  	return
   793  }
   794  
   795  // UnsubscribeTriggerFromEventsPreparer prepares the UnsubscribeTriggerFromEvents request.
   796  func (client TriggerClient) UnsubscribeTriggerFromEventsPreparer(ctx context.Context, triggerName string) (*http.Request, error) {
   797  	urlParameters := map[string]interface{}{
   798  		"endpoint": client.Endpoint,
   799  	}
   800  
   801  	pathParameters := map[string]interface{}{
   802  		"triggerName": autorest.Encode("path", triggerName),
   803  	}
   804  
   805  	const APIVersion = "2019-06-01-preview"
   806  	queryParameters := map[string]interface{}{
   807  		"api-version": APIVersion,
   808  	}
   809  
   810  	preparer := autorest.CreatePreparer(
   811  		autorest.AsPost(),
   812  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   813  		autorest.WithPathParameters("/triggers/{triggerName}/unsubscribeFromEvents", pathParameters),
   814  		autorest.WithQueryParameters(queryParameters))
   815  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   816  }
   817  
   818  // UnsubscribeTriggerFromEventsSender sends the UnsubscribeTriggerFromEvents request. The method will close the
   819  // http.Response Body if it receives an error.
   820  func (client TriggerClient) UnsubscribeTriggerFromEventsSender(req *http.Request) (future TriggerUnsubscribeTriggerFromEventsFuture, err error) {
   821  	var resp *http.Response
   822  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   823  	if err != nil {
   824  		return
   825  	}
   826  	var azf azure.Future
   827  	azf, err = azure.NewFutureFromResponse(resp)
   828  	future.FutureAPI = &azf
   829  	future.Result = future.result
   830  	return
   831  }
   832  
   833  // UnsubscribeTriggerFromEventsResponder handles the response to the UnsubscribeTriggerFromEvents request. The method always
   834  // closes the http.Response Body.
   835  func (client TriggerClient) UnsubscribeTriggerFromEventsResponder(resp *http.Response) (result TriggerSubscriptionOperationStatus, err error) {
   836  	err = autorest.Respond(
   837  		resp,
   838  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   839  		autorest.ByUnmarshallingJSON(&result),
   840  		autorest.ByClosing())
   841  	result.Response = autorest.Response{Response: resp}
   842  	return
   843  }
   844
View as plain text