scheduledqueryrules.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/monitor/mgmt/2022-10-01-preview/insights

     1  package insights
     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  // ScheduledQueryRulesClient is the monitor Management Client
    19  type ScheduledQueryRulesClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewScheduledQueryRulesClient creates an instance of the ScheduledQueryRulesClient client.
    24  func NewScheduledQueryRulesClient(subscriptionID string) ScheduledQueryRulesClient {
    25  	return NewScheduledQueryRulesClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewScheduledQueryRulesClientWithBaseURI creates an instance of the ScheduledQueryRulesClient client using a custom
    29  // endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
    30  // stack).
    31  func NewScheduledQueryRulesClientWithBaseURI(baseURI string, subscriptionID string) ScheduledQueryRulesClient {
    32  	return ScheduledQueryRulesClient{NewWithBaseURI(baseURI, subscriptionID)}
    33  }
    34  
    35  // CreateOrUpdate creates or updates a scheduled query rule.
    36  // Parameters:
    37  // resourceGroupName - the name of the resource group. The name is case insensitive.
    38  // ruleName - the name of the rule.
    39  // parameters - the parameters of the rule to create or update.
    40  func (client ScheduledQueryRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, ruleName string, parameters ScheduledQueryRuleResource) (result ScheduledQueryRuleResource, err error) {
    41  	if tracing.IsEnabled() {
    42  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.CreateOrUpdate")
    43  		defer func() {
    44  			sc := -1
    45  			if result.Response.Response != nil {
    46  				sc = result.Response.Response.StatusCode
    47  			}
    48  			tracing.EndSpan(ctx, sc, err)
    49  		}()
    50  	}
    51  	if err := validation.Validate([]validation.Validation{
    52  		{TargetValue: client.SubscriptionID,
    53  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
    54  		{TargetValue: resourceGroupName,
    55  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
    56  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
    57  		{TargetValue: parameters,
    58  			Constraints: []validation.Constraint{{Target: "parameters.Location", Name: validation.Null, Rule: true, Chain: nil},
    59  				{Target: "parameters.ScheduledQueryRuleProperties", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
    60  		return result, validation.NewError("insights.ScheduledQueryRulesClient", "CreateOrUpdate", err.Error())
    61  	}
    62  
    63  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, ruleName, parameters)
    64  	if err != nil {
    65  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "CreateOrUpdate", nil, "Failure preparing request")
    66  		return
    67  	}
    68  
    69  	resp, err := client.CreateOrUpdateSender(req)
    70  	if err != nil {
    71  		result.Response = autorest.Response{Response: resp}
    72  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "CreateOrUpdate", resp, "Failure sending request")
    73  		return
    74  	}
    75  
    76  	result, err = client.CreateOrUpdateResponder(resp)
    77  	if err != nil {
    78  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "CreateOrUpdate", resp, "Failure responding to request")
    79  		return
    80  	}
    81  
    82  	return
    83  }
    84  
    85  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    86  func (client ScheduledQueryRulesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, ruleName string, parameters ScheduledQueryRuleResource) (*http.Request, error) {
    87  	pathParameters := map[string]interface{}{
    88  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    89  		"ruleName":          autorest.Encode("path", ruleName),
    90  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    91  	}
    92  
    93  	const APIVersion = "2022-06-15"
    94  	queryParameters := map[string]interface{}{
    95  		"api-version": APIVersion,
    96  	}
    97  
    98  	parameters.ID = nil
    99  	parameters.Name = nil
   100  	parameters.Type = nil
   101  	parameters.Etag = nil
   102  	parameters.SystemData = nil
   103  	preparer := autorest.CreatePreparer(
   104  		autorest.AsContentType("application/json; charset=utf-8"),
   105  		autorest.AsPut(),
   106  		autorest.WithBaseURL(client.BaseURI),
   107  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Insights/scheduledQueryRules/{ruleName}", pathParameters),
   108  		autorest.WithJSON(parameters),
   109  		autorest.WithQueryParameters(queryParameters))
   110  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   111  }
   112  
   113  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   114  // http.Response Body if it receives an error.
   115  func (client ScheduledQueryRulesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
   116  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   117  }
   118  
   119  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   120  // closes the http.Response Body.
   121  func (client ScheduledQueryRulesClient) CreateOrUpdateResponder(resp *http.Response) (result ScheduledQueryRuleResource, err error) {
   122  	err = autorest.Respond(
   123  		resp,
   124  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   125  		autorest.ByUnmarshallingJSON(&result),
   126  		autorest.ByClosing())
   127  	result.Response = autorest.Response{Response: resp}
   128  	return
   129  }
   130  
   131  // Delete deletes a scheduled query rule.
   132  // Parameters:
   133  // resourceGroupName - the name of the resource group. The name is case insensitive.
   134  // ruleName - the name of the rule.
   135  func (client ScheduledQueryRulesClient) Delete(ctx context.Context, resourceGroupName string, ruleName string) (result autorest.Response, err error) {
   136  	if tracing.IsEnabled() {
   137  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.Delete")
   138  		defer func() {
   139  			sc := -1
   140  			if result.Response != nil {
   141  				sc = result.Response.StatusCode
   142  			}
   143  			tracing.EndSpan(ctx, sc, err)
   144  		}()
   145  	}
   146  	if err := validation.Validate([]validation.Validation{
   147  		{TargetValue: client.SubscriptionID,
   148  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   149  		{TargetValue: resourceGroupName,
   150  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   151  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   152  		return result, validation.NewError("insights.ScheduledQueryRulesClient", "Delete", err.Error())
   153  	}
   154  
   155  	req, err := client.DeletePreparer(ctx, resourceGroupName, ruleName)
   156  	if err != nil {
   157  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Delete", nil, "Failure preparing request")
   158  		return
   159  	}
   160  
   161  	resp, err := client.DeleteSender(req)
   162  	if err != nil {
   163  		result.Response = resp
   164  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Delete", resp, "Failure sending request")
   165  		return
   166  	}
   167  
   168  	result, err = client.DeleteResponder(resp)
   169  	if err != nil {
   170  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Delete", resp, "Failure responding to request")
   171  		return
   172  	}
   173  
   174  	return
   175  }
   176  
   177  // DeletePreparer prepares the Delete request.
   178  func (client ScheduledQueryRulesClient) DeletePreparer(ctx context.Context, resourceGroupName string, ruleName string) (*http.Request, error) {
   179  	pathParameters := map[string]interface{}{
   180  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   181  		"ruleName":          autorest.Encode("path", ruleName),
   182  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   183  	}
   184  
   185  	const APIVersion = "2022-06-15"
   186  	queryParameters := map[string]interface{}{
   187  		"api-version": APIVersion,
   188  	}
   189  
   190  	preparer := autorest.CreatePreparer(
   191  		autorest.AsDelete(),
   192  		autorest.WithBaseURL(client.BaseURI),
   193  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Insights/scheduledQueryRules/{ruleName}", pathParameters),
   194  		autorest.WithQueryParameters(queryParameters))
   195  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   196  }
   197  
   198  // DeleteSender sends the Delete request. The method will close the
   199  // http.Response Body if it receives an error.
   200  func (client ScheduledQueryRulesClient) DeleteSender(req *http.Request) (*http.Response, error) {
   201  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   202  }
   203  
   204  // DeleteResponder handles the response to the Delete request. The method always
   205  // closes the http.Response Body.
   206  func (client ScheduledQueryRulesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   207  	err = autorest.Respond(
   208  		resp,
   209  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   210  		autorest.ByClosing())
   211  	result.Response = resp
   212  	return
   213  }
   214  
   215  // Get retrieve an scheduled query rule definition.
   216  // Parameters:
   217  // resourceGroupName - the name of the resource group. The name is case insensitive.
   218  // ruleName - the name of the rule.
   219  func (client ScheduledQueryRulesClient) Get(ctx context.Context, resourceGroupName string, ruleName string) (result ScheduledQueryRuleResource, err error) {
   220  	if tracing.IsEnabled() {
   221  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.Get")
   222  		defer func() {
   223  			sc := -1
   224  			if result.Response.Response != nil {
   225  				sc = result.Response.Response.StatusCode
   226  			}
   227  			tracing.EndSpan(ctx, sc, err)
   228  		}()
   229  	}
   230  	if err := validation.Validate([]validation.Validation{
   231  		{TargetValue: client.SubscriptionID,
   232  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   233  		{TargetValue: resourceGroupName,
   234  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   235  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   236  		return result, validation.NewError("insights.ScheduledQueryRulesClient", "Get", err.Error())
   237  	}
   238  
   239  	req, err := client.GetPreparer(ctx, resourceGroupName, ruleName)
   240  	if err != nil {
   241  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Get", nil, "Failure preparing request")
   242  		return
   243  	}
   244  
   245  	resp, err := client.GetSender(req)
   246  	if err != nil {
   247  		result.Response = autorest.Response{Response: resp}
   248  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Get", resp, "Failure sending request")
   249  		return
   250  	}
   251  
   252  	result, err = client.GetResponder(resp)
   253  	if err != nil {
   254  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Get", resp, "Failure responding to request")
   255  		return
   256  	}
   257  
   258  	return
   259  }
   260  
   261  // GetPreparer prepares the Get request.
   262  func (client ScheduledQueryRulesClient) GetPreparer(ctx context.Context, resourceGroupName string, ruleName string) (*http.Request, error) {
   263  	pathParameters := map[string]interface{}{
   264  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   265  		"ruleName":          autorest.Encode("path", ruleName),
   266  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   267  	}
   268  
   269  	const APIVersion = "2022-06-15"
   270  	queryParameters := map[string]interface{}{
   271  		"api-version": APIVersion,
   272  	}
   273  
   274  	preparer := autorest.CreatePreparer(
   275  		autorest.AsGet(),
   276  		autorest.WithBaseURL(client.BaseURI),
   277  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Insights/scheduledQueryRules/{ruleName}", pathParameters),
   278  		autorest.WithQueryParameters(queryParameters))
   279  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   280  }
   281  
   282  // GetSender sends the Get request. The method will close the
   283  // http.Response Body if it receives an error.
   284  func (client ScheduledQueryRulesClient) GetSender(req *http.Request) (*http.Response, error) {
   285  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   286  }
   287  
   288  // GetResponder handles the response to the Get request. The method always
   289  // closes the http.Response Body.
   290  func (client ScheduledQueryRulesClient) GetResponder(resp *http.Response) (result ScheduledQueryRuleResource, err error) {
   291  	err = autorest.Respond(
   292  		resp,
   293  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   294  		autorest.ByUnmarshallingJSON(&result),
   295  		autorest.ByClosing())
   296  	result.Response = autorest.Response{Response: resp}
   297  	return
   298  }
   299  
   300  // ListByResourceGroup retrieve scheduled query rule definitions in a resource group.
   301  // Parameters:
   302  // resourceGroupName - the name of the resource group. The name is case insensitive.
   303  func (client ScheduledQueryRulesClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ScheduledQueryRuleResourceCollectionPage, err error) {
   304  	if tracing.IsEnabled() {
   305  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.ListByResourceGroup")
   306  		defer func() {
   307  			sc := -1
   308  			if result.sqrrc.Response.Response != nil {
   309  				sc = result.sqrrc.Response.Response.StatusCode
   310  			}
   311  			tracing.EndSpan(ctx, sc, err)
   312  		}()
   313  	}
   314  	if err := validation.Validate([]validation.Validation{
   315  		{TargetValue: client.SubscriptionID,
   316  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   317  		{TargetValue: resourceGroupName,
   318  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   319  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   320  		return result, validation.NewError("insights.ScheduledQueryRulesClient", "ListByResourceGroup", err.Error())
   321  	}
   322  
   323  	result.fn = client.listByResourceGroupNextResults
   324  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
   325  	if err != nil {
   326  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "ListByResourceGroup", nil, "Failure preparing request")
   327  		return
   328  	}
   329  
   330  	resp, err := client.ListByResourceGroupSender(req)
   331  	if err != nil {
   332  		result.sqrrc.Response = autorest.Response{Response: resp}
   333  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "ListByResourceGroup", resp, "Failure sending request")
   334  		return
   335  	}
   336  
   337  	result.sqrrc, err = client.ListByResourceGroupResponder(resp)
   338  	if err != nil {
   339  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "ListByResourceGroup", resp, "Failure responding to request")
   340  		return
   341  	}
   342  	if result.sqrrc.hasNextLink() && result.sqrrc.IsEmpty() {
   343  		err = result.NextWithContext(ctx)
   344  		return
   345  	}
   346  
   347  	return
   348  }
   349  
   350  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   351  func (client ScheduledQueryRulesClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
   352  	pathParameters := map[string]interface{}{
   353  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   354  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   355  	}
   356  
   357  	const APIVersion = "2022-06-15"
   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.Insights/scheduledQueryRules", pathParameters),
   366  		autorest.WithQueryParameters(queryParameters))
   367  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   368  }
   369  
   370  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   371  // http.Response Body if it receives an error.
   372  func (client ScheduledQueryRulesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   373  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   374  }
   375  
   376  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   377  // closes the http.Response Body.
   378  func (client ScheduledQueryRulesClient) ListByResourceGroupResponder(resp *http.Response) (result ScheduledQueryRuleResourceCollection, 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  // listByResourceGroupNextResults retrieves the next set of results, if any.
   389  func (client ScheduledQueryRulesClient) listByResourceGroupNextResults(ctx context.Context, lastResults ScheduledQueryRuleResourceCollection) (result ScheduledQueryRuleResourceCollection, err error) {
   390  	req, err := lastResults.scheduledQueryRuleResourceCollectionPreparer(ctx)
   391  	if err != nil {
   392  		return result, autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
   393  	}
   394  	if req == nil {
   395  		return
   396  	}
   397  	resp, err := client.ListByResourceGroupSender(req)
   398  	if err != nil {
   399  		result.Response = autorest.Response{Response: resp}
   400  		return result, autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
   401  	}
   402  	result, err = client.ListByResourceGroupResponder(resp)
   403  	if err != nil {
   404  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
   405  	}
   406  	return
   407  }
   408  
   409  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
   410  func (client ScheduledQueryRulesClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ScheduledQueryRuleResourceCollectionIterator, err error) {
   411  	if tracing.IsEnabled() {
   412  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.ListByResourceGroup")
   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.ListByResourceGroup(ctx, resourceGroupName)
   422  	return
   423  }
   424  
   425  // ListBySubscription retrieve a scheduled query rule definitions in a subscription.
   426  func (client ScheduledQueryRulesClient) ListBySubscription(ctx context.Context) (result ScheduledQueryRuleResourceCollectionPage, err error) {
   427  	if tracing.IsEnabled() {
   428  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.ListBySubscription")
   429  		defer func() {
   430  			sc := -1
   431  			if result.sqrrc.Response.Response != nil {
   432  				sc = result.sqrrc.Response.Response.StatusCode
   433  			}
   434  			tracing.EndSpan(ctx, sc, err)
   435  		}()
   436  	}
   437  	if err := validation.Validate([]validation.Validation{
   438  		{TargetValue: client.SubscriptionID,
   439  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   440  		return result, validation.NewError("insights.ScheduledQueryRulesClient", "ListBySubscription", err.Error())
   441  	}
   442  
   443  	result.fn = client.listBySubscriptionNextResults
   444  	req, err := client.ListBySubscriptionPreparer(ctx)
   445  	if err != nil {
   446  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "ListBySubscription", nil, "Failure preparing request")
   447  		return
   448  	}
   449  
   450  	resp, err := client.ListBySubscriptionSender(req)
   451  	if err != nil {
   452  		result.sqrrc.Response = autorest.Response{Response: resp}
   453  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "ListBySubscription", resp, "Failure sending request")
   454  		return
   455  	}
   456  
   457  	result.sqrrc, err = client.ListBySubscriptionResponder(resp)
   458  	if err != nil {
   459  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "ListBySubscription", resp, "Failure responding to request")
   460  		return
   461  	}
   462  	if result.sqrrc.hasNextLink() && result.sqrrc.IsEmpty() {
   463  		err = result.NextWithContext(ctx)
   464  		return
   465  	}
   466  
   467  	return
   468  }
   469  
   470  // ListBySubscriptionPreparer prepares the ListBySubscription request.
   471  func (client ScheduledQueryRulesClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) {
   472  	pathParameters := map[string]interface{}{
   473  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   474  	}
   475  
   476  	const APIVersion = "2022-06-15"
   477  	queryParameters := map[string]interface{}{
   478  		"api-version": APIVersion,
   479  	}
   480  
   481  	preparer := autorest.CreatePreparer(
   482  		autorest.AsGet(),
   483  		autorest.WithBaseURL(client.BaseURI),
   484  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Insights/scheduledQueryRules", pathParameters),
   485  		autorest.WithQueryParameters(queryParameters))
   486  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   487  }
   488  
   489  // ListBySubscriptionSender sends the ListBySubscription request. The method will close the
   490  // http.Response Body if it receives an error.
   491  func (client ScheduledQueryRulesClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
   492  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   493  }
   494  
   495  // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
   496  // closes the http.Response Body.
   497  func (client ScheduledQueryRulesClient) ListBySubscriptionResponder(resp *http.Response) (result ScheduledQueryRuleResourceCollection, err error) {
   498  	err = autorest.Respond(
   499  		resp,
   500  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   501  		autorest.ByUnmarshallingJSON(&result),
   502  		autorest.ByClosing())
   503  	result.Response = autorest.Response{Response: resp}
   504  	return
   505  }
   506  
   507  // listBySubscriptionNextResults retrieves the next set of results, if any.
   508  func (client ScheduledQueryRulesClient) listBySubscriptionNextResults(ctx context.Context, lastResults ScheduledQueryRuleResourceCollection) (result ScheduledQueryRuleResourceCollection, err error) {
   509  	req, err := lastResults.scheduledQueryRuleResourceCollectionPreparer(ctx)
   510  	if err != nil {
   511  		return result, autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
   512  	}
   513  	if req == nil {
   514  		return
   515  	}
   516  	resp, err := client.ListBySubscriptionSender(req)
   517  	if err != nil {
   518  		result.Response = autorest.Response{Response: resp}
   519  		return result, autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
   520  	}
   521  	result, err = client.ListBySubscriptionResponder(resp)
   522  	if err != nil {
   523  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
   524  	}
   525  	return
   526  }
   527  
   528  // ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
   529  func (client ScheduledQueryRulesClient) ListBySubscriptionComplete(ctx context.Context) (result ScheduledQueryRuleResourceCollectionIterator, err error) {
   530  	if tracing.IsEnabled() {
   531  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.ListBySubscription")
   532  		defer func() {
   533  			sc := -1
   534  			if result.Response().Response.Response != nil {
   535  				sc = result.page.Response().Response.Response.StatusCode
   536  			}
   537  			tracing.EndSpan(ctx, sc, err)
   538  		}()
   539  	}
   540  	result.page, err = client.ListBySubscription(ctx)
   541  	return
   542  }
   543  
   544  // Update update a scheduled query rule.
   545  // Parameters:
   546  // resourceGroupName - the name of the resource group. The name is case insensitive.
   547  // ruleName - the name of the rule.
   548  // parameters - the parameters of the rule to update.
   549  func (client ScheduledQueryRulesClient) Update(ctx context.Context, resourceGroupName string, ruleName string, parameters ScheduledQueryRuleResourcePatch) (result ScheduledQueryRuleResource, err error) {
   550  	if tracing.IsEnabled() {
   551  		ctx = tracing.StartSpan(ctx, fqdn+"/ScheduledQueryRulesClient.Update")
   552  		defer func() {
   553  			sc := -1
   554  			if result.Response.Response != nil {
   555  				sc = result.Response.Response.StatusCode
   556  			}
   557  			tracing.EndSpan(ctx, sc, err)
   558  		}()
   559  	}
   560  	if err := validation.Validate([]validation.Validation{
   561  		{TargetValue: client.SubscriptionID,
   562  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   563  		{TargetValue: resourceGroupName,
   564  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   565  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   566  		return result, validation.NewError("insights.ScheduledQueryRulesClient", "Update", err.Error())
   567  	}
   568  
   569  	req, err := client.UpdatePreparer(ctx, resourceGroupName, ruleName, parameters)
   570  	if err != nil {
   571  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Update", nil, "Failure preparing request")
   572  		return
   573  	}
   574  
   575  	resp, err := client.UpdateSender(req)
   576  	if err != nil {
   577  		result.Response = autorest.Response{Response: resp}
   578  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Update", resp, "Failure sending request")
   579  		return
   580  	}
   581  
   582  	result, err = client.UpdateResponder(resp)
   583  	if err != nil {
   584  		err = autorest.NewErrorWithError(err, "insights.ScheduledQueryRulesClient", "Update", resp, "Failure responding to request")
   585  		return
   586  	}
   587  
   588  	return
   589  }
   590  
   591  // UpdatePreparer prepares the Update request.
   592  func (client ScheduledQueryRulesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, ruleName string, parameters ScheduledQueryRuleResourcePatch) (*http.Request, error) {
   593  	pathParameters := map[string]interface{}{
   594  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   595  		"ruleName":          autorest.Encode("path", ruleName),
   596  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   597  	}
   598  
   599  	const APIVersion = "2022-06-15"
   600  	queryParameters := map[string]interface{}{
   601  		"api-version": APIVersion,
   602  	}
   603  
   604  	preparer := autorest.CreatePreparer(
   605  		autorest.AsContentType("application/json; charset=utf-8"),
   606  		autorest.AsPatch(),
   607  		autorest.WithBaseURL(client.BaseURI),
   608  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Insights/scheduledQueryRules/{ruleName}", pathParameters),
   609  		autorest.WithJSON(parameters),
   610  		autorest.WithQueryParameters(queryParameters))
   611  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   612  }
   613  
   614  // UpdateSender sends the Update request. The method will close the
   615  // http.Response Body if it receives an error.
   616  func (client ScheduledQueryRulesClient) UpdateSender(req *http.Request) (*http.Response, error) {
   617  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   618  }
   619  
   620  // UpdateResponder handles the response to the Update request. The method always
   621  // closes the http.Response Body.
   622  func (client ScheduledQueryRulesClient) UpdateResponder(resp *http.Response) (result ScheduledQueryRuleResource, err error) {
   623  	err = autorest.Respond(
   624  		resp,
   625  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   626  		autorest.ByUnmarshallingJSON(&result),
   627  		autorest.ByClosing())
   628  	result.Response = autorest.Response{Response: resp}
   629  	return
   630  }
   631
View as plain text