managementgroups.go

Documentation: github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2020-02-01/managementgroups

     1  package managementgroups
     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/tracing"
    14  	"net/http"
    15  )
    16  
    17  // Client is the the Azure Management Groups API enables consolidation of multiple
    18  // subscriptions/resources into an organizational hierarchy and centrally
    19  // manage access control, policies, alerting and reporting for those resources.
    20  type Client struct {
    21  	BaseClient
    22  }
    23  
    24  // NewClient creates an instance of the Client client.
    25  func NewClient() Client {
    26  	return NewClientWithBaseURI(DefaultBaseURI)
    27  }
    28  
    29  // NewClientWithBaseURI creates an instance of the Client client using a custom endpoint.  Use this when interacting
    30  // with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    31  func NewClientWithBaseURI(baseURI string) Client {
    32  	return Client{NewWithBaseURI(baseURI)}
    33  }
    34  
    35  // CreateOrUpdate create or update a management group.
    36  // If a management group is already created and a subsequent create request is issued with different properties, the
    37  // management group properties will be updated.
    38  // Parameters:
    39  // groupID - management Group ID.
    40  // createManagementGroupRequest - management group creation parameters.
    41  // cacheControl - indicates that the request shouldn't utilize any caches.
    42  func (client Client) CreateOrUpdate(ctx context.Context, groupID string, createManagementGroupRequest CreateManagementGroupRequest, cacheControl string) (result CreateOrUpdateFuture, err error) {
    43  	if tracing.IsEnabled() {
    44  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.CreateOrUpdate")
    45  		defer func() {
    46  			sc := -1
    47  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    48  				sc = result.FutureAPI.Response().StatusCode
    49  			}
    50  			tracing.EndSpan(ctx, sc, err)
    51  		}()
    52  	}
    53  	req, err := client.CreateOrUpdatePreparer(ctx, groupID, createManagementGroupRequest, cacheControl)
    54  	if err != nil {
    55  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "CreateOrUpdate", nil, "Failure preparing request")
    56  		return
    57  	}
    58  
    59  	result, err = client.CreateOrUpdateSender(req)
    60  	if err != nil {
    61  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "CreateOrUpdate", result.Response(), "Failure sending request")
    62  		return
    63  	}
    64  
    65  	return
    66  }
    67  
    68  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    69  func (client Client) CreateOrUpdatePreparer(ctx context.Context, groupID string, createManagementGroupRequest CreateManagementGroupRequest, cacheControl string) (*http.Request, error) {
    70  	pathParameters := map[string]interface{}{
    71  		"groupId": autorest.Encode("path", groupID),
    72  	}
    73  
    74  	const APIVersion = "2020-02-01"
    75  	queryParameters := map[string]interface{}{
    76  		"api-version": APIVersion,
    77  	}
    78  
    79  	createManagementGroupRequest.ID = nil
    80  	createManagementGroupRequest.Type = nil
    81  	preparer := autorest.CreatePreparer(
    82  		autorest.AsContentType("application/json; charset=utf-8"),
    83  		autorest.AsPut(),
    84  		autorest.WithBaseURL(client.BaseURI),
    85  		autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters),
    86  		autorest.WithJSON(createManagementGroupRequest),
    87  		autorest.WithQueryParameters(queryParameters))
    88  	if len(cacheControl) > 0 {
    89  		preparer = autorest.DecoratePreparer(preparer,
    90  			autorest.WithHeader("Cache-Control", autorest.String(cacheControl)))
    91  	} else {
    92  		preparer = autorest.DecoratePreparer(preparer,
    93  			autorest.WithHeader("Cache-Control", autorest.String("no-cache")))
    94  	}
    95  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    96  }
    97  
    98  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
    99  // http.Response Body if it receives an error.
   100  func (client Client) CreateOrUpdateSender(req *http.Request) (future CreateOrUpdateFuture, err error) {
   101  	var resp *http.Response
   102  	future.FutureAPI = &azure.Future{}
   103  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   104  	if err != nil {
   105  		return
   106  	}
   107  	var azf azure.Future
   108  	azf, err = azure.NewFutureFromResponse(resp)
   109  	future.FutureAPI = &azf
   110  	future.Result = future.result
   111  	return
   112  }
   113  
   114  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   115  // closes the http.Response Body.
   116  func (client Client) CreateOrUpdateResponder(resp *http.Response) (result SetObject, err error) {
   117  	err = autorest.Respond(
   118  		resp,
   119  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   120  		autorest.ByUnmarshallingJSON(&result.Value),
   121  		autorest.ByClosing())
   122  	result.Response = autorest.Response{Response: resp}
   123  	return
   124  }
   125  
   126  // Delete delete management group.
   127  // If a management group contains child resources, the request will fail.
   128  // Parameters:
   129  // groupID - management Group ID.
   130  // cacheControl - indicates that the request shouldn't utilize any caches.
   131  func (client Client) Delete(ctx context.Context, groupID string, cacheControl string) (result DeleteFuture, err error) {
   132  	if tracing.IsEnabled() {
   133  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.Delete")
   134  		defer func() {
   135  			sc := -1
   136  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   137  				sc = result.FutureAPI.Response().StatusCode
   138  			}
   139  			tracing.EndSpan(ctx, sc, err)
   140  		}()
   141  	}
   142  	req, err := client.DeletePreparer(ctx, groupID, cacheControl)
   143  	if err != nil {
   144  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Delete", nil, "Failure preparing request")
   145  		return
   146  	}
   147  
   148  	result, err = client.DeleteSender(req)
   149  	if err != nil {
   150  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Delete", result.Response(), "Failure sending request")
   151  		return
   152  	}
   153  
   154  	return
   155  }
   156  
   157  // DeletePreparer prepares the Delete request.
   158  func (client Client) DeletePreparer(ctx context.Context, groupID string, cacheControl string) (*http.Request, error) {
   159  	pathParameters := map[string]interface{}{
   160  		"groupId": autorest.Encode("path", groupID),
   161  	}
   162  
   163  	const APIVersion = "2020-02-01"
   164  	queryParameters := map[string]interface{}{
   165  		"api-version": APIVersion,
   166  	}
   167  
   168  	preparer := autorest.CreatePreparer(
   169  		autorest.AsDelete(),
   170  		autorest.WithBaseURL(client.BaseURI),
   171  		autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters),
   172  		autorest.WithQueryParameters(queryParameters))
   173  	if len(cacheControl) > 0 {
   174  		preparer = autorest.DecoratePreparer(preparer,
   175  			autorest.WithHeader("Cache-Control", autorest.String(cacheControl)))
   176  	} else {
   177  		preparer = autorest.DecoratePreparer(preparer,
   178  			autorest.WithHeader("Cache-Control", autorest.String("no-cache")))
   179  	}
   180  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   181  }
   182  
   183  // DeleteSender sends the Delete request. The method will close the
   184  // http.Response Body if it receives an error.
   185  func (client Client) DeleteSender(req *http.Request) (future DeleteFuture, err error) {
   186  	var resp *http.Response
   187  	future.FutureAPI = &azure.Future{}
   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  // DeleteResponder handles the response to the Delete request. The method always
   200  // closes the http.Response Body.
   201  func (client Client) DeleteResponder(resp *http.Response) (result AzureAsyncOperationResults, err error) {
   202  	err = autorest.Respond(
   203  		resp,
   204  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   205  		autorest.ByUnmarshallingJSON(&result),
   206  		autorest.ByClosing())
   207  	result.Response = autorest.Response{Response: resp}
   208  	return
   209  }
   210  
   211  // Get get the details of the management group.
   212  // Parameters:
   213  // groupID - management Group ID.
   214  // expand - the $expand=children query string parameter allows clients to request inclusion of children in the
   215  // response payload.  $expand=path includes the path from the root group to the current group.
   216  // recurse - the $recurse=true query string parameter allows clients to request inclusion of entire hierarchy
   217  // in the response payload. Note that  $expand=children must be passed up if $recurse is set to true.
   218  // filter - a filter which allows the exclusion of subscriptions from results (i.e. '$filter=children.childType
   219  // ne Subscription')
   220  // cacheControl - indicates that the request shouldn't utilize any caches.
   221  func (client Client) Get(ctx context.Context, groupID string, expand string, recurse *bool, filter string, cacheControl string) (result ManagementGroup, err error) {
   222  	if tracing.IsEnabled() {
   223  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.Get")
   224  		defer func() {
   225  			sc := -1
   226  			if result.Response.Response != nil {
   227  				sc = result.Response.Response.StatusCode
   228  			}
   229  			tracing.EndSpan(ctx, sc, err)
   230  		}()
   231  	}
   232  	req, err := client.GetPreparer(ctx, groupID, expand, recurse, filter, cacheControl)
   233  	if err != nil {
   234  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Get", nil, "Failure preparing request")
   235  		return
   236  	}
   237  
   238  	resp, err := client.GetSender(req)
   239  	if err != nil {
   240  		result.Response = autorest.Response{Response: resp}
   241  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Get", resp, "Failure sending request")
   242  		return
   243  	}
   244  
   245  	result, err = client.GetResponder(resp)
   246  	if err != nil {
   247  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Get", resp, "Failure responding to request")
   248  		return
   249  	}
   250  
   251  	return
   252  }
   253  
   254  // GetPreparer prepares the Get request.
   255  func (client Client) GetPreparer(ctx context.Context, groupID string, expand string, recurse *bool, filter string, cacheControl string) (*http.Request, error) {
   256  	pathParameters := map[string]interface{}{
   257  		"groupId": autorest.Encode("path", groupID),
   258  	}
   259  
   260  	const APIVersion = "2020-02-01"
   261  	queryParameters := map[string]interface{}{
   262  		"api-version": APIVersion,
   263  	}
   264  	if len(string(expand)) > 0 {
   265  		queryParameters["$expand"] = autorest.Encode("query", expand)
   266  	}
   267  	if recurse != nil {
   268  		queryParameters["$recurse"] = autorest.Encode("query", *recurse)
   269  	}
   270  	if len(filter) > 0 {
   271  		queryParameters["$filter"] = autorest.Encode("query", filter)
   272  	}
   273  
   274  	preparer := autorest.CreatePreparer(
   275  		autorest.AsGet(),
   276  		autorest.WithBaseURL(client.BaseURI),
   277  		autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters),
   278  		autorest.WithQueryParameters(queryParameters))
   279  	if len(cacheControl) > 0 {
   280  		preparer = autorest.DecoratePreparer(preparer,
   281  			autorest.WithHeader("Cache-Control", autorest.String(cacheControl)))
   282  	} else {
   283  		preparer = autorest.DecoratePreparer(preparer,
   284  			autorest.WithHeader("Cache-Control", autorest.String("no-cache")))
   285  	}
   286  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   287  }
   288  
   289  // GetSender sends the Get request. The method will close the
   290  // http.Response Body if it receives an error.
   291  func (client Client) GetSender(req *http.Request) (*http.Response, error) {
   292  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   293  }
   294  
   295  // GetResponder handles the response to the Get request. The method always
   296  // closes the http.Response Body.
   297  func (client Client) GetResponder(resp *http.Response) (result ManagementGroup, err error) {
   298  	err = autorest.Respond(
   299  		resp,
   300  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   301  		autorest.ByUnmarshallingJSON(&result),
   302  		autorest.ByClosing())
   303  	result.Response = autorest.Response{Response: resp}
   304  	return
   305  }
   306  
   307  // GetDescendants list all entities that descend from a management group.
   308  // Parameters:
   309  // groupID - management Group ID.
   310  // skiptoken - page continuation token is only used if a previous operation returned a partial result.
   311  // If a previous response contains a nextLink element, the value of the nextLink element will include a token
   312  // parameter that specifies a starting point to use for subsequent calls.
   313  // top - number of elements to return when retrieving results. Passing this in will override $skipToken.
   314  func (client Client) GetDescendants(ctx context.Context, groupID string, skiptoken string, top *int32) (result DescendantListResultPage, err error) {
   315  	if tracing.IsEnabled() {
   316  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.GetDescendants")
   317  		defer func() {
   318  			sc := -1
   319  			if result.dlr.Response.Response != nil {
   320  				sc = result.dlr.Response.Response.StatusCode
   321  			}
   322  			tracing.EndSpan(ctx, sc, err)
   323  		}()
   324  	}
   325  	result.fn = client.getDescendantsNextResults
   326  	req, err := client.GetDescendantsPreparer(ctx, groupID, skiptoken, top)
   327  	if err != nil {
   328  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "GetDescendants", nil, "Failure preparing request")
   329  		return
   330  	}
   331  
   332  	resp, err := client.GetDescendantsSender(req)
   333  	if err != nil {
   334  		result.dlr.Response = autorest.Response{Response: resp}
   335  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "GetDescendants", resp, "Failure sending request")
   336  		return
   337  	}
   338  
   339  	result.dlr, err = client.GetDescendantsResponder(resp)
   340  	if err != nil {
   341  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "GetDescendants", resp, "Failure responding to request")
   342  		return
   343  	}
   344  	if result.dlr.hasNextLink() && result.dlr.IsEmpty() {
   345  		err = result.NextWithContext(ctx)
   346  		return
   347  	}
   348  
   349  	return
   350  }
   351  
   352  // GetDescendantsPreparer prepares the GetDescendants request.
   353  func (client Client) GetDescendantsPreparer(ctx context.Context, groupID string, skiptoken string, top *int32) (*http.Request, error) {
   354  	pathParameters := map[string]interface{}{
   355  		"groupId": autorest.Encode("path", groupID),
   356  	}
   357  
   358  	const APIVersion = "2020-02-01"
   359  	queryParameters := map[string]interface{}{
   360  		"api-version": APIVersion,
   361  	}
   362  	if len(skiptoken) > 0 {
   363  		queryParameters["$skiptoken"] = autorest.Encode("query", skiptoken)
   364  	}
   365  	if top != nil {
   366  		queryParameters["$top"] = autorest.Encode("query", *top)
   367  	}
   368  
   369  	preparer := autorest.CreatePreparer(
   370  		autorest.AsGet(),
   371  		autorest.WithBaseURL(client.BaseURI),
   372  		autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/descendants", pathParameters),
   373  		autorest.WithQueryParameters(queryParameters))
   374  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   375  }
   376  
   377  // GetDescendantsSender sends the GetDescendants request. The method will close the
   378  // http.Response Body if it receives an error.
   379  func (client Client) GetDescendantsSender(req *http.Request) (*http.Response, error) {
   380  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   381  }
   382  
   383  // GetDescendantsResponder handles the response to the GetDescendants request. The method always
   384  // closes the http.Response Body.
   385  func (client Client) GetDescendantsResponder(resp *http.Response) (result DescendantListResult, err error) {
   386  	err = autorest.Respond(
   387  		resp,
   388  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   389  		autorest.ByUnmarshallingJSON(&result),
   390  		autorest.ByClosing())
   391  	result.Response = autorest.Response{Response: resp}
   392  	return
   393  }
   394  
   395  // getDescendantsNextResults retrieves the next set of results, if any.
   396  func (client Client) getDescendantsNextResults(ctx context.Context, lastResults DescendantListResult) (result DescendantListResult, err error) {
   397  	req, err := lastResults.descendantListResultPreparer(ctx)
   398  	if err != nil {
   399  		return result, autorest.NewErrorWithError(err, "managementgroups.Client", "getDescendantsNextResults", nil, "Failure preparing next results request")
   400  	}
   401  	if req == nil {
   402  		return
   403  	}
   404  	resp, err := client.GetDescendantsSender(req)
   405  	if err != nil {
   406  		result.Response = autorest.Response{Response: resp}
   407  		return result, autorest.NewErrorWithError(err, "managementgroups.Client", "getDescendantsNextResults", resp, "Failure sending next results request")
   408  	}
   409  	result, err = client.GetDescendantsResponder(resp)
   410  	if err != nil {
   411  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "getDescendantsNextResults", resp, "Failure responding to next results request")
   412  	}
   413  	return
   414  }
   415  
   416  // GetDescendantsComplete enumerates all values, automatically crossing page boundaries as required.
   417  func (client Client) GetDescendantsComplete(ctx context.Context, groupID string, skiptoken string, top *int32) (result DescendantListResultIterator, err error) {
   418  	if tracing.IsEnabled() {
   419  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.GetDescendants")
   420  		defer func() {
   421  			sc := -1
   422  			if result.Response().Response.Response != nil {
   423  				sc = result.page.Response().Response.Response.StatusCode
   424  			}
   425  			tracing.EndSpan(ctx, sc, err)
   426  		}()
   427  	}
   428  	result.page, err = client.GetDescendants(ctx, groupID, skiptoken, top)
   429  	return
   430  }
   431  
   432  // List list management groups for the authenticated user.
   433  // Parameters:
   434  // cacheControl - indicates that the request shouldn't utilize any caches.
   435  // skiptoken - page continuation token is only used if a previous operation returned a partial result.
   436  // If a previous response contains a nextLink element, the value of the nextLink element will include a token
   437  // parameter that specifies a starting point to use for subsequent calls.
   438  func (client Client) List(ctx context.Context, cacheControl string, skiptoken string) (result ListResultPage, err error) {
   439  	if tracing.IsEnabled() {
   440  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.List")
   441  		defer func() {
   442  			sc := -1
   443  			if result.lr.Response.Response != nil {
   444  				sc = result.lr.Response.Response.StatusCode
   445  			}
   446  			tracing.EndSpan(ctx, sc, err)
   447  		}()
   448  	}
   449  	result.fn = client.listNextResults
   450  	req, err := client.ListPreparer(ctx, cacheControl, skiptoken)
   451  	if err != nil {
   452  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "List", nil, "Failure preparing request")
   453  		return
   454  	}
   455  
   456  	resp, err := client.ListSender(req)
   457  	if err != nil {
   458  		result.lr.Response = autorest.Response{Response: resp}
   459  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "List", resp, "Failure sending request")
   460  		return
   461  	}
   462  
   463  	result.lr, err = client.ListResponder(resp)
   464  	if err != nil {
   465  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "List", resp, "Failure responding to request")
   466  		return
   467  	}
   468  	if result.lr.hasNextLink() && result.lr.IsEmpty() {
   469  		err = result.NextWithContext(ctx)
   470  		return
   471  	}
   472  
   473  	return
   474  }
   475  
   476  // ListPreparer prepares the List request.
   477  func (client Client) ListPreparer(ctx context.Context, cacheControl string, skiptoken string) (*http.Request, error) {
   478  	const APIVersion = "2020-02-01"
   479  	queryParameters := map[string]interface{}{
   480  		"api-version": APIVersion,
   481  	}
   482  	if len(skiptoken) > 0 {
   483  		queryParameters["$skiptoken"] = autorest.Encode("query", skiptoken)
   484  	}
   485  
   486  	preparer := autorest.CreatePreparer(
   487  		autorest.AsGet(),
   488  		autorest.WithBaseURL(client.BaseURI),
   489  		autorest.WithPath("/providers/Microsoft.Management/managementGroups"),
   490  		autorest.WithQueryParameters(queryParameters))
   491  	if len(cacheControl) > 0 {
   492  		preparer = autorest.DecoratePreparer(preparer,
   493  			autorest.WithHeader("Cache-Control", autorest.String(cacheControl)))
   494  	} else {
   495  		preparer = autorest.DecoratePreparer(preparer,
   496  			autorest.WithHeader("Cache-Control", autorest.String("no-cache")))
   497  	}
   498  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   499  }
   500  
   501  // ListSender sends the List request. The method will close the
   502  // http.Response Body if it receives an error.
   503  func (client Client) ListSender(req *http.Request) (*http.Response, error) {
   504  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   505  }
   506  
   507  // ListResponder handles the response to the List request. The method always
   508  // closes the http.Response Body.
   509  func (client Client) ListResponder(resp *http.Response) (result ListResult, err error) {
   510  	err = autorest.Respond(
   511  		resp,
   512  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   513  		autorest.ByUnmarshallingJSON(&result),
   514  		autorest.ByClosing())
   515  	result.Response = autorest.Response{Response: resp}
   516  	return
   517  }
   518  
   519  // listNextResults retrieves the next set of results, if any.
   520  func (client Client) listNextResults(ctx context.Context, lastResults ListResult) (result ListResult, err error) {
   521  	req, err := lastResults.listResultPreparer(ctx)
   522  	if err != nil {
   523  		return result, autorest.NewErrorWithError(err, "managementgroups.Client", "listNextResults", nil, "Failure preparing next results request")
   524  	}
   525  	if req == nil {
   526  		return
   527  	}
   528  	resp, err := client.ListSender(req)
   529  	if err != nil {
   530  		result.Response = autorest.Response{Response: resp}
   531  		return result, autorest.NewErrorWithError(err, "managementgroups.Client", "listNextResults", resp, "Failure sending next results request")
   532  	}
   533  	result, err = client.ListResponder(resp)
   534  	if err != nil {
   535  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "listNextResults", resp, "Failure responding to next results request")
   536  	}
   537  	return
   538  }
   539  
   540  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   541  func (client Client) ListComplete(ctx context.Context, cacheControl string, skiptoken string) (result ListResultIterator, err error) {
   542  	if tracing.IsEnabled() {
   543  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.List")
   544  		defer func() {
   545  			sc := -1
   546  			if result.Response().Response.Response != nil {
   547  				sc = result.page.Response().Response.Response.StatusCode
   548  			}
   549  			tracing.EndSpan(ctx, sc, err)
   550  		}()
   551  	}
   552  	result.page, err = client.List(ctx, cacheControl, skiptoken)
   553  	return
   554  }
   555  
   556  // Update update a management group.
   557  // Parameters:
   558  // groupID - management Group ID.
   559  // patchGroupRequest - management group patch parameters.
   560  // cacheControl - indicates that the request shouldn't utilize any caches.
   561  func (client Client) Update(ctx context.Context, groupID string, patchGroupRequest PatchManagementGroupRequest, cacheControl string) (result ManagementGroup, err error) {
   562  	if tracing.IsEnabled() {
   563  		ctx = tracing.StartSpan(ctx, fqdn+"/Client.Update")
   564  		defer func() {
   565  			sc := -1
   566  			if result.Response.Response != nil {
   567  				sc = result.Response.Response.StatusCode
   568  			}
   569  			tracing.EndSpan(ctx, sc, err)
   570  		}()
   571  	}
   572  	req, err := client.UpdatePreparer(ctx, groupID, patchGroupRequest, cacheControl)
   573  	if err != nil {
   574  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Update", nil, "Failure preparing request")
   575  		return
   576  	}
   577  
   578  	resp, err := client.UpdateSender(req)
   579  	if err != nil {
   580  		result.Response = autorest.Response{Response: resp}
   581  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Update", resp, "Failure sending request")
   582  		return
   583  	}
   584  
   585  	result, err = client.UpdateResponder(resp)
   586  	if err != nil {
   587  		err = autorest.NewErrorWithError(err, "managementgroups.Client", "Update", resp, "Failure responding to request")
   588  		return
   589  	}
   590  
   591  	return
   592  }
   593  
   594  // UpdatePreparer prepares the Update request.
   595  func (client Client) UpdatePreparer(ctx context.Context, groupID string, patchGroupRequest PatchManagementGroupRequest, cacheControl string) (*http.Request, error) {
   596  	pathParameters := map[string]interface{}{
   597  		"groupId": autorest.Encode("path", groupID),
   598  	}
   599  
   600  	const APIVersion = "2020-02-01"
   601  	queryParameters := map[string]interface{}{
   602  		"api-version": APIVersion,
   603  	}
   604  
   605  	preparer := autorest.CreatePreparer(
   606  		autorest.AsContentType("application/json; charset=utf-8"),
   607  		autorest.AsPatch(),
   608  		autorest.WithBaseURL(client.BaseURI),
   609  		autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters),
   610  		autorest.WithJSON(patchGroupRequest),
   611  		autorest.WithQueryParameters(queryParameters))
   612  	if len(cacheControl) > 0 {
   613  		preparer = autorest.DecoratePreparer(preparer,
   614  			autorest.WithHeader("Cache-Control", autorest.String(cacheControl)))
   615  	} else {
   616  		preparer = autorest.DecoratePreparer(preparer,
   617  			autorest.WithHeader("Cache-Control", autorest.String("no-cache")))
   618  	}
   619  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   620  }
   621  
   622  // UpdateSender sends the Update request. The method will close the
   623  // http.Response Body if it receives an error.
   624  func (client Client) UpdateSender(req *http.Request) (*http.Response, error) {
   625  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   626  }
   627  
   628  // UpdateResponder handles the response to the Update request. The method always
   629  // closes the http.Response Body.
   630  func (client Client) UpdateResponder(resp *http.Response) (result ManagementGroup, err error) {
   631  	err = autorest.Respond(
   632  		resp,
   633  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   634  		autorest.ByUnmarshallingJSON(&result),
   635  		autorest.ByClosing())
   636  	result.Response = autorest.Response{Response: resp}
   637  	return
   638  }
   639
View as plain text