accounts.go

Documentation: github.com/Azure/azure-sdk-for-go/services/datalake/analytics/mgmt/2016-11-01/account

     1  package account
     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  // AccountsClient is the creates an Azure Data Lake Analytics account management client.
    19  type AccountsClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewAccountsClient creates an instance of the AccountsClient client.
    24  func NewAccountsClient(subscriptionID string) AccountsClient {
    25  	return NewAccountsClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewAccountsClientWithBaseURI creates an instance of the AccountsClient 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 NewAccountsClientWithBaseURI(baseURI string, subscriptionID string) AccountsClient {
    31  	return AccountsClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CheckNameAvailability checks whether the specified account name is available or taken.
    35  // Parameters:
    36  // location - the resource location without whitespace.
    37  // parameters - parameters supplied to check the Data Lake Analytics account name availability.
    38  func (client AccountsClient) CheckNameAvailability(ctx context.Context, location string, parameters CheckNameAvailabilityParameters) (result NameAvailabilityInformation, err error) {
    39  	if tracing.IsEnabled() {
    40  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.CheckNameAvailability")
    41  		defer func() {
    42  			sc := -1
    43  			if result.Response.Response != nil {
    44  				sc = result.Response.Response.StatusCode
    45  			}
    46  			tracing.EndSpan(ctx, sc, err)
    47  		}()
    48  	}
    49  	if err := validation.Validate([]validation.Validation{
    50  		{TargetValue: parameters,
    51  			Constraints: []validation.Constraint{{Target: "parameters.Name", Name: validation.Null, Rule: true, Chain: nil},
    52  				{Target: "parameters.Type", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
    53  		return result, validation.NewError("account.AccountsClient", "CheckNameAvailability", err.Error())
    54  	}
    55  
    56  	req, err := client.CheckNameAvailabilityPreparer(ctx, location, parameters)
    57  	if err != nil {
    58  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "CheckNameAvailability", nil, "Failure preparing request")
    59  		return
    60  	}
    61  
    62  	resp, err := client.CheckNameAvailabilitySender(req)
    63  	if err != nil {
    64  		result.Response = autorest.Response{Response: resp}
    65  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "CheckNameAvailability", resp, "Failure sending request")
    66  		return
    67  	}
    68  
    69  	result, err = client.CheckNameAvailabilityResponder(resp)
    70  	if err != nil {
    71  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "CheckNameAvailability", resp, "Failure responding to request")
    72  		return
    73  	}
    74  
    75  	return
    76  }
    77  
    78  // CheckNameAvailabilityPreparer prepares the CheckNameAvailability request.
    79  func (client AccountsClient) CheckNameAvailabilityPreparer(ctx context.Context, location string, parameters CheckNameAvailabilityParameters) (*http.Request, error) {
    80  	pathParameters := map[string]interface{}{
    81  		"location":       autorest.Encode("path", location),
    82  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
    83  	}
    84  
    85  	const APIVersion = "2016-11-01"
    86  	queryParameters := map[string]interface{}{
    87  		"api-version": APIVersion,
    88  	}
    89  
    90  	preparer := autorest.CreatePreparer(
    91  		autorest.AsContentType("application/json; charset=utf-8"),
    92  		autorest.AsPost(),
    93  		autorest.WithBaseURL(client.BaseURI),
    94  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DataLakeAnalytics/locations/{location}/checkNameAvailability", pathParameters),
    95  		autorest.WithJSON(parameters),
    96  		autorest.WithQueryParameters(queryParameters))
    97  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    98  }
    99  
   100  // CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the
   101  // http.Response Body if it receives an error.
   102  func (client AccountsClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) {
   103  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   104  }
   105  
   106  // CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always
   107  // closes the http.Response Body.
   108  func (client AccountsClient) CheckNameAvailabilityResponder(resp *http.Response) (result NameAvailabilityInformation, err error) {
   109  	err = autorest.Respond(
   110  		resp,
   111  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   112  		autorest.ByUnmarshallingJSON(&result),
   113  		autorest.ByClosing())
   114  	result.Response = autorest.Response{Response: resp}
   115  	return
   116  }
   117  
   118  // Create creates the specified Data Lake Analytics account. This supplies the user with computation services for Data
   119  // Lake Analytics workloads.
   120  // Parameters:
   121  // resourceGroupName - the name of the Azure resource group.
   122  // accountName - the name of the Data Lake Analytics account.
   123  // parameters - parameters supplied to create a new Data Lake Analytics account.
   124  func (client AccountsClient) Create(ctx context.Context, resourceGroupName string, accountName string, parameters CreateDataLakeAnalyticsAccountParameters) (result AccountsCreateFutureType, err error) {
   125  	if tracing.IsEnabled() {
   126  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Create")
   127  		defer func() {
   128  			sc := -1
   129  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   130  				sc = result.FutureAPI.Response().StatusCode
   131  			}
   132  			tracing.EndSpan(ctx, sc, err)
   133  		}()
   134  	}
   135  	if err := validation.Validate([]validation.Validation{
   136  		{TargetValue: parameters,
   137  			Constraints: []validation.Constraint{{Target: "parameters.Location", Name: validation.Null, Rule: true, Chain: nil},
   138  				{Target: "parameters.CreateDataLakeAnalyticsAccountProperties", Name: validation.Null, Rule: true,
   139  					Chain: []validation.Constraint{{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.DefaultDataLakeStoreAccount", Name: validation.Null, Rule: true, Chain: nil},
   140  						{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.DataLakeStoreAccounts", Name: validation.Null, Rule: true, Chain: nil},
   141  						{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MaxJobCount", Name: validation.Null, Rule: false,
   142  							Chain: []validation.Constraint{{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MaxJobCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   143  						{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MaxDegreeOfParallelism", Name: validation.Null, Rule: false,
   144  							Chain: []validation.Constraint{{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MaxDegreeOfParallelism", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   145  						{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MaxDegreeOfParallelismPerJob", Name: validation.Null, Rule: false,
   146  							Chain: []validation.Constraint{{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MaxDegreeOfParallelismPerJob", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   147  						{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MinPriorityPerJob", Name: validation.Null, Rule: false,
   148  							Chain: []validation.Constraint{{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.MinPriorityPerJob", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   149  						{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.QueryStoreRetention", Name: validation.Null, Rule: false,
   150  							Chain: []validation.Constraint{{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.QueryStoreRetention", Name: validation.InclusiveMaximum, Rule: int64(180), Chain: nil},
   151  								{Target: "parameters.CreateDataLakeAnalyticsAccountProperties.QueryStoreRetention", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   152  							}},
   153  					}}}}}); err != nil {
   154  		return result, validation.NewError("account.AccountsClient", "Create", err.Error())
   155  	}
   156  
   157  	req, err := client.CreatePreparer(ctx, resourceGroupName, accountName, parameters)
   158  	if err != nil {
   159  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Create", nil, "Failure preparing request")
   160  		return
   161  	}
   162  
   163  	result, err = client.CreateSender(req)
   164  	if err != nil {
   165  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Create", result.Response(), "Failure sending request")
   166  		return
   167  	}
   168  
   169  	return
   170  }
   171  
   172  // CreatePreparer prepares the Create request.
   173  func (client AccountsClient) CreatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters CreateDataLakeAnalyticsAccountParameters) (*http.Request, error) {
   174  	pathParameters := map[string]interface{}{
   175  		"accountName":       autorest.Encode("path", accountName),
   176  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   177  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   178  	}
   179  
   180  	const APIVersion = "2016-11-01"
   181  	queryParameters := map[string]interface{}{
   182  		"api-version": APIVersion,
   183  	}
   184  
   185  	preparer := autorest.CreatePreparer(
   186  		autorest.AsContentType("application/json; charset=utf-8"),
   187  		autorest.AsPut(),
   188  		autorest.WithBaseURL(client.BaseURI),
   189  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
   190  		autorest.WithJSON(parameters),
   191  		autorest.WithQueryParameters(queryParameters))
   192  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   193  }
   194  
   195  // CreateSender sends the Create request. The method will close the
   196  // http.Response Body if it receives an error.
   197  func (client AccountsClient) CreateSender(req *http.Request) (future AccountsCreateFutureType, err error) {
   198  	var resp *http.Response
   199  	future.FutureAPI = &azure.Future{}
   200  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   201  	if err != nil {
   202  		return
   203  	}
   204  	var azf azure.Future
   205  	azf, err = azure.NewFutureFromResponse(resp)
   206  	future.FutureAPI = &azf
   207  	future.Result = future.result
   208  	return
   209  }
   210  
   211  // CreateResponder handles the response to the Create request. The method always
   212  // closes the http.Response Body.
   213  func (client AccountsClient) CreateResponder(resp *http.Response) (result DataLakeAnalyticsAccount, err error) {
   214  	err = autorest.Respond(
   215  		resp,
   216  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   217  		autorest.ByUnmarshallingJSON(&result),
   218  		autorest.ByClosing())
   219  	result.Response = autorest.Response{Response: resp}
   220  	return
   221  }
   222  
   223  // Delete begins the delete process for the Data Lake Analytics account object specified by the account name.
   224  // Parameters:
   225  // resourceGroupName - the name of the Azure resource group.
   226  // accountName - the name of the Data Lake Analytics account.
   227  func (client AccountsClient) Delete(ctx context.Context, resourceGroupName string, accountName string) (result AccountsDeleteFutureType, err error) {
   228  	if tracing.IsEnabled() {
   229  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Delete")
   230  		defer func() {
   231  			sc := -1
   232  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   233  				sc = result.FutureAPI.Response().StatusCode
   234  			}
   235  			tracing.EndSpan(ctx, sc, err)
   236  		}()
   237  	}
   238  	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName)
   239  	if err != nil {
   240  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Delete", nil, "Failure preparing request")
   241  		return
   242  	}
   243  
   244  	result, err = client.DeleteSender(req)
   245  	if err != nil {
   246  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Delete", result.Response(), "Failure sending request")
   247  		return
   248  	}
   249  
   250  	return
   251  }
   252  
   253  // DeletePreparer prepares the Delete request.
   254  func (client AccountsClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   255  	pathParameters := map[string]interface{}{
   256  		"accountName":       autorest.Encode("path", accountName),
   257  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   258  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   259  	}
   260  
   261  	const APIVersion = "2016-11-01"
   262  	queryParameters := map[string]interface{}{
   263  		"api-version": APIVersion,
   264  	}
   265  
   266  	preparer := autorest.CreatePreparer(
   267  		autorest.AsDelete(),
   268  		autorest.WithBaseURL(client.BaseURI),
   269  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
   270  		autorest.WithQueryParameters(queryParameters))
   271  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   272  }
   273  
   274  // DeleteSender sends the Delete request. The method will close the
   275  // http.Response Body if it receives an error.
   276  func (client AccountsClient) DeleteSender(req *http.Request) (future AccountsDeleteFutureType, err error) {
   277  	var resp *http.Response
   278  	future.FutureAPI = &azure.Future{}
   279  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   280  	if err != nil {
   281  		return
   282  	}
   283  	var azf azure.Future
   284  	azf, err = azure.NewFutureFromResponse(resp)
   285  	future.FutureAPI = &azf
   286  	future.Result = future.result
   287  	return
   288  }
   289  
   290  // DeleteResponder handles the response to the Delete request. The method always
   291  // closes the http.Response Body.
   292  func (client AccountsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   293  	err = autorest.Respond(
   294  		resp,
   295  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   296  		autorest.ByClosing())
   297  	result.Response = resp
   298  	return
   299  }
   300  
   301  // Get gets details of the specified Data Lake Analytics account.
   302  // Parameters:
   303  // resourceGroupName - the name of the Azure resource group.
   304  // accountName - the name of the Data Lake Analytics account.
   305  func (client AccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string) (result DataLakeAnalyticsAccount, err error) {
   306  	if tracing.IsEnabled() {
   307  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Get")
   308  		defer func() {
   309  			sc := -1
   310  			if result.Response.Response != nil {
   311  				sc = result.Response.Response.StatusCode
   312  			}
   313  			tracing.EndSpan(ctx, sc, err)
   314  		}()
   315  	}
   316  	req, err := client.GetPreparer(ctx, resourceGroupName, accountName)
   317  	if err != nil {
   318  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Get", nil, "Failure preparing request")
   319  		return
   320  	}
   321  
   322  	resp, err := client.GetSender(req)
   323  	if err != nil {
   324  		result.Response = autorest.Response{Response: resp}
   325  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Get", resp, "Failure sending request")
   326  		return
   327  	}
   328  
   329  	result, err = client.GetResponder(resp)
   330  	if err != nil {
   331  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Get", resp, "Failure responding to request")
   332  		return
   333  	}
   334  
   335  	return
   336  }
   337  
   338  // GetPreparer prepares the Get request.
   339  func (client AccountsClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   340  	pathParameters := map[string]interface{}{
   341  		"accountName":       autorest.Encode("path", accountName),
   342  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   343  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   344  	}
   345  
   346  	const APIVersion = "2016-11-01"
   347  	queryParameters := map[string]interface{}{
   348  		"api-version": APIVersion,
   349  	}
   350  
   351  	preparer := autorest.CreatePreparer(
   352  		autorest.AsGet(),
   353  		autorest.WithBaseURL(client.BaseURI),
   354  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
   355  		autorest.WithQueryParameters(queryParameters))
   356  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   357  }
   358  
   359  // GetSender sends the Get request. The method will close the
   360  // http.Response Body if it receives an error.
   361  func (client AccountsClient) GetSender(req *http.Request) (*http.Response, error) {
   362  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   363  }
   364  
   365  // GetResponder handles the response to the Get request. The method always
   366  // closes the http.Response Body.
   367  func (client AccountsClient) GetResponder(resp *http.Response) (result DataLakeAnalyticsAccount, err error) {
   368  	err = autorest.Respond(
   369  		resp,
   370  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   371  		autorest.ByUnmarshallingJSON(&result),
   372  		autorest.ByClosing())
   373  	result.Response = autorest.Response{Response: resp}
   374  	return
   375  }
   376  
   377  // List gets the first page of Data Lake Analytics accounts, if any, within the current subscription. This includes a
   378  // link to the next page, if any.
   379  // Parameters:
   380  // filter - oData filter. Optional.
   381  // top - the number of items to return. Optional.
   382  // skip - the number of items to skip over before returning elements. Optional.
   383  // selectParameter - oData Select statement. Limits the properties on each entry to just those requested, e.g.
   384  // Categories?$select=CategoryName,Description. Optional.
   385  // orderby - orderBy clause. One or more comma-separated expressions with an optional "asc" (the default) or
   386  // "desc" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc.
   387  // Optional.
   388  // count - the Boolean value of true or false to request a count of the matching resources included with the
   389  // resources in the response, e.g. Categories?$count=true. Optional.
   390  func (client AccountsClient) List(ctx context.Context, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListResultPage, err error) {
   391  	if tracing.IsEnabled() {
   392  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.List")
   393  		defer func() {
   394  			sc := -1
   395  			if result.dlaalr.Response.Response != nil {
   396  				sc = result.dlaalr.Response.Response.StatusCode
   397  			}
   398  			tracing.EndSpan(ctx, sc, err)
   399  		}()
   400  	}
   401  	if err := validation.Validate([]validation.Validation{
   402  		{TargetValue: top,
   403  			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
   404  				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}}}},
   405  		{TargetValue: skip,
   406  			Constraints: []validation.Constraint{{Target: "skip", Name: validation.Null, Rule: false,
   407  				Chain: []validation.Constraint{{Target: "skip", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}}}}}); err != nil {
   408  		return result, validation.NewError("account.AccountsClient", "List", err.Error())
   409  	}
   410  
   411  	result.fn = client.listNextResults
   412  	req, err := client.ListPreparer(ctx, filter, top, skip, selectParameter, orderby, count)
   413  	if err != nil {
   414  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "List", nil, "Failure preparing request")
   415  		return
   416  	}
   417  
   418  	resp, err := client.ListSender(req)
   419  	if err != nil {
   420  		result.dlaalr.Response = autorest.Response{Response: resp}
   421  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "List", resp, "Failure sending request")
   422  		return
   423  	}
   424  
   425  	result.dlaalr, err = client.ListResponder(resp)
   426  	if err != nil {
   427  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "List", resp, "Failure responding to request")
   428  		return
   429  	}
   430  	if result.dlaalr.hasNextLink() && result.dlaalr.IsEmpty() {
   431  		err = result.NextWithContext(ctx)
   432  		return
   433  	}
   434  
   435  	return
   436  }
   437  
   438  // ListPreparer prepares the List request.
   439  func (client AccountsClient) ListPreparer(ctx context.Context, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (*http.Request, error) {
   440  	pathParameters := map[string]interface{}{
   441  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   442  	}
   443  
   444  	const APIVersion = "2016-11-01"
   445  	queryParameters := map[string]interface{}{
   446  		"api-version": APIVersion,
   447  	}
   448  	if len(filter) > 0 {
   449  		queryParameters["$filter"] = autorest.Encode("query", filter)
   450  	}
   451  	if top != nil {
   452  		queryParameters["$top"] = autorest.Encode("query", *top)
   453  	}
   454  	if skip != nil {
   455  		queryParameters["$skip"] = autorest.Encode("query", *skip)
   456  	}
   457  	if len(selectParameter) > 0 {
   458  		queryParameters["$select"] = autorest.Encode("query", selectParameter)
   459  	}
   460  	if len(orderby) > 0 {
   461  		queryParameters["$orderby"] = autorest.Encode("query", orderby)
   462  	}
   463  	if count != nil {
   464  		queryParameters["$count"] = autorest.Encode("query", *count)
   465  	}
   466  
   467  	preparer := autorest.CreatePreparer(
   468  		autorest.AsGet(),
   469  		autorest.WithBaseURL(client.BaseURI),
   470  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DataLakeAnalytics/accounts", pathParameters),
   471  		autorest.WithQueryParameters(queryParameters))
   472  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   473  }
   474  
   475  // ListSender sends the List request. The method will close the
   476  // http.Response Body if it receives an error.
   477  func (client AccountsClient) ListSender(req *http.Request) (*http.Response, error) {
   478  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   479  }
   480  
   481  // ListResponder handles the response to the List request. The method always
   482  // closes the http.Response Body.
   483  func (client AccountsClient) ListResponder(resp *http.Response) (result DataLakeAnalyticsAccountListResult, err error) {
   484  	err = autorest.Respond(
   485  		resp,
   486  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   487  		autorest.ByUnmarshallingJSON(&result),
   488  		autorest.ByClosing())
   489  	result.Response = autorest.Response{Response: resp}
   490  	return
   491  }
   492  
   493  // listNextResults retrieves the next set of results, if any.
   494  func (client AccountsClient) listNextResults(ctx context.Context, lastResults DataLakeAnalyticsAccountListResult) (result DataLakeAnalyticsAccountListResult, err error) {
   495  	req, err := lastResults.dataLakeAnalyticsAccountListResultPreparer(ctx)
   496  	if err != nil {
   497  		return result, autorest.NewErrorWithError(err, "account.AccountsClient", "listNextResults", nil, "Failure preparing next results request")
   498  	}
   499  	if req == nil {
   500  		return
   501  	}
   502  	resp, err := client.ListSender(req)
   503  	if err != nil {
   504  		result.Response = autorest.Response{Response: resp}
   505  		return result, autorest.NewErrorWithError(err, "account.AccountsClient", "listNextResults", resp, "Failure sending next results request")
   506  	}
   507  	result, err = client.ListResponder(resp)
   508  	if err != nil {
   509  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "listNextResults", resp, "Failure responding to next results request")
   510  	}
   511  	return
   512  }
   513  
   514  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   515  func (client AccountsClient) ListComplete(ctx context.Context, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListResultIterator, err error) {
   516  	if tracing.IsEnabled() {
   517  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.List")
   518  		defer func() {
   519  			sc := -1
   520  			if result.Response().Response.Response != nil {
   521  				sc = result.page.Response().Response.Response.StatusCode
   522  			}
   523  			tracing.EndSpan(ctx, sc, err)
   524  		}()
   525  	}
   526  	result.page, err = client.List(ctx, filter, top, skip, selectParameter, orderby, count)
   527  	return
   528  }
   529  
   530  // ListByResourceGroup gets the first page of Data Lake Analytics accounts, if any, within a specific resource group.
   531  // This includes a link to the next page, if any.
   532  // Parameters:
   533  // resourceGroupName - the name of the Azure resource group.
   534  // filter - oData filter. Optional.
   535  // top - the number of items to return. Optional.
   536  // skip - the number of items to skip over before returning elements. Optional.
   537  // selectParameter - oData Select statement. Limits the properties on each entry to just those requested, e.g.
   538  // Categories?$select=CategoryName,Description. Optional.
   539  // orderby - orderBy clause. One or more comma-separated expressions with an optional "asc" (the default) or
   540  // "desc" depending on the order you'd like the values sorted, e.g. Categories?$orderby=CategoryName desc.
   541  // Optional.
   542  // count - the Boolean value of true or false to request a count of the matching resources included with the
   543  // resources in the response, e.g. Categories?$count=true. Optional.
   544  func (client AccountsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListResultPage, err error) {
   545  	if tracing.IsEnabled() {
   546  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListByResourceGroup")
   547  		defer func() {
   548  			sc := -1
   549  			if result.dlaalr.Response.Response != nil {
   550  				sc = result.dlaalr.Response.Response.StatusCode
   551  			}
   552  			tracing.EndSpan(ctx, sc, err)
   553  		}()
   554  	}
   555  	if err := validation.Validate([]validation.Validation{
   556  		{TargetValue: top,
   557  			Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false,
   558  				Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}}}},
   559  		{TargetValue: skip,
   560  			Constraints: []validation.Constraint{{Target: "skip", Name: validation.Null, Rule: false,
   561  				Chain: []validation.Constraint{{Target: "skip", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}}}}}); err != nil {
   562  		return result, validation.NewError("account.AccountsClient", "ListByResourceGroup", err.Error())
   563  	}
   564  
   565  	result.fn = client.listByResourceGroupNextResults
   566  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName, filter, top, skip, selectParameter, orderby, count)
   567  	if err != nil {
   568  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "ListByResourceGroup", nil, "Failure preparing request")
   569  		return
   570  	}
   571  
   572  	resp, err := client.ListByResourceGroupSender(req)
   573  	if err != nil {
   574  		result.dlaalr.Response = autorest.Response{Response: resp}
   575  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "ListByResourceGroup", resp, "Failure sending request")
   576  		return
   577  	}
   578  
   579  	result.dlaalr, err = client.ListByResourceGroupResponder(resp)
   580  	if err != nil {
   581  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "ListByResourceGroup", resp, "Failure responding to request")
   582  		return
   583  	}
   584  	if result.dlaalr.hasNextLink() && result.dlaalr.IsEmpty() {
   585  		err = result.NextWithContext(ctx)
   586  		return
   587  	}
   588  
   589  	return
   590  }
   591  
   592  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   593  func (client AccountsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (*http.Request, error) {
   594  	pathParameters := map[string]interface{}{
   595  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   596  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   597  	}
   598  
   599  	const APIVersion = "2016-11-01"
   600  	queryParameters := map[string]interface{}{
   601  		"api-version": APIVersion,
   602  	}
   603  	if len(filter) > 0 {
   604  		queryParameters["$filter"] = autorest.Encode("query", filter)
   605  	}
   606  	if top != nil {
   607  		queryParameters["$top"] = autorest.Encode("query", *top)
   608  	}
   609  	if skip != nil {
   610  		queryParameters["$skip"] = autorest.Encode("query", *skip)
   611  	}
   612  	if len(selectParameter) > 0 {
   613  		queryParameters["$select"] = autorest.Encode("query", selectParameter)
   614  	}
   615  	if len(orderby) > 0 {
   616  		queryParameters["$orderby"] = autorest.Encode("query", orderby)
   617  	}
   618  	if count != nil {
   619  		queryParameters["$count"] = autorest.Encode("query", *count)
   620  	}
   621  
   622  	preparer := autorest.CreatePreparer(
   623  		autorest.AsGet(),
   624  		autorest.WithBaseURL(client.BaseURI),
   625  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts", pathParameters),
   626  		autorest.WithQueryParameters(queryParameters))
   627  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   628  }
   629  
   630  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   631  // http.Response Body if it receives an error.
   632  func (client AccountsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   633  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   634  }
   635  
   636  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   637  // closes the http.Response Body.
   638  func (client AccountsClient) ListByResourceGroupResponder(resp *http.Response) (result DataLakeAnalyticsAccountListResult, err error) {
   639  	err = autorest.Respond(
   640  		resp,
   641  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   642  		autorest.ByUnmarshallingJSON(&result),
   643  		autorest.ByClosing())
   644  	result.Response = autorest.Response{Response: resp}
   645  	return
   646  }
   647  
   648  // listByResourceGroupNextResults retrieves the next set of results, if any.
   649  func (client AccountsClient) listByResourceGroupNextResults(ctx context.Context, lastResults DataLakeAnalyticsAccountListResult) (result DataLakeAnalyticsAccountListResult, err error) {
   650  	req, err := lastResults.dataLakeAnalyticsAccountListResultPreparer(ctx)
   651  	if err != nil {
   652  		return result, autorest.NewErrorWithError(err, "account.AccountsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
   653  	}
   654  	if req == nil {
   655  		return
   656  	}
   657  	resp, err := client.ListByResourceGroupSender(req)
   658  	if err != nil {
   659  		result.Response = autorest.Response{Response: resp}
   660  		return result, autorest.NewErrorWithError(err, "account.AccountsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
   661  	}
   662  	result, err = client.ListByResourceGroupResponder(resp)
   663  	if err != nil {
   664  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
   665  	}
   666  	return
   667  }
   668  
   669  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
   670  func (client AccountsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string, filter string, top *int32, skip *int32, selectParameter string, orderby string, count *bool) (result DataLakeAnalyticsAccountListResultIterator, err error) {
   671  	if tracing.IsEnabled() {
   672  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.ListByResourceGroup")
   673  		defer func() {
   674  			sc := -1
   675  			if result.Response().Response.Response != nil {
   676  				sc = result.page.Response().Response.Response.StatusCode
   677  			}
   678  			tracing.EndSpan(ctx, sc, err)
   679  		}()
   680  	}
   681  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName, filter, top, skip, selectParameter, orderby, count)
   682  	return
   683  }
   684  
   685  // Update updates the Data Lake Analytics account object specified by the accountName with the contents of the account
   686  // object.
   687  // Parameters:
   688  // resourceGroupName - the name of the Azure resource group.
   689  // accountName - the name of the Data Lake Analytics account.
   690  // parameters - parameters supplied to the update Data Lake Analytics account operation.
   691  func (client AccountsClient) Update(ctx context.Context, resourceGroupName string, accountName string, parameters *UpdateDataLakeAnalyticsAccountParameters) (result AccountsUpdateFutureType, err error) {
   692  	if tracing.IsEnabled() {
   693  		ctx = tracing.StartSpan(ctx, fqdn+"/AccountsClient.Update")
   694  		defer func() {
   695  			sc := -1
   696  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   697  				sc = result.FutureAPI.Response().StatusCode
   698  			}
   699  			tracing.EndSpan(ctx, sc, err)
   700  		}()
   701  	}
   702  	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, parameters)
   703  	if err != nil {
   704  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Update", nil, "Failure preparing request")
   705  		return
   706  	}
   707  
   708  	result, err = client.UpdateSender(req)
   709  	if err != nil {
   710  		err = autorest.NewErrorWithError(err, "account.AccountsClient", "Update", result.Response(), "Failure sending request")
   711  		return
   712  	}
   713  
   714  	return
   715  }
   716  
   717  // UpdatePreparer prepares the Update request.
   718  func (client AccountsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, parameters *UpdateDataLakeAnalyticsAccountParameters) (*http.Request, error) {
   719  	pathParameters := map[string]interface{}{
   720  		"accountName":       autorest.Encode("path", accountName),
   721  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   722  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   723  	}
   724  
   725  	const APIVersion = "2016-11-01"
   726  	queryParameters := map[string]interface{}{
   727  		"api-version": APIVersion,
   728  	}
   729  
   730  	preparer := autorest.CreatePreparer(
   731  		autorest.AsContentType("application/json; charset=utf-8"),
   732  		autorest.AsPatch(),
   733  		autorest.WithBaseURL(client.BaseURI),
   734  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}", pathParameters),
   735  		autorest.WithQueryParameters(queryParameters))
   736  	if parameters != nil {
   737  		preparer = autorest.DecoratePreparer(preparer,
   738  			autorest.WithJSON(parameters))
   739  	}
   740  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   741  }
   742  
   743  // UpdateSender sends the Update request. The method will close the
   744  // http.Response Body if it receives an error.
   745  func (client AccountsClient) UpdateSender(req *http.Request) (future AccountsUpdateFutureType, err error) {
   746  	var resp *http.Response
   747  	future.FutureAPI = &azure.Future{}
   748  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   749  	if err != nil {
   750  		return
   751  	}
   752  	var azf azure.Future
   753  	azf, err = azure.NewFutureFromResponse(resp)
   754  	future.FutureAPI = &azf
   755  	future.Result = future.result
   756  	return
   757  }
   758  
   759  // UpdateResponder handles the response to the Update request. The method always
   760  // closes the http.Response Body.
   761  func (client AccountsClient) UpdateResponder(resp *http.Response) (result DataLakeAnalyticsAccount, err error) {
   762  	err = autorest.Respond(
   763  		resp,
   764  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted),
   765  		autorest.ByUnmarshallingJSON(&result),
   766  		autorest.ByClosing())
   767  	result.Response = autorest.Response{Response: resp}
   768  	return
   769  }
   770
View as plain text