managementgroups.go

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