diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/client.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/client.go new file mode 100644 index 000000000000..e4ba2bc6b85d --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/client.go @@ -0,0 +1,270 @@ +// Package managementgroups implements the Azure ARM Managementgroups service API version 2020-02-01. +// +// The Azure Management Groups API enables consolidation of multiple +// subscriptions/resources into an organizational hierarchy and centrally +// manage access control, policies, alerting and reporting for those resources. +// +package managementgroups + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +const ( + // DefaultBaseURI is the default URI used for the service Managementgroups + DefaultBaseURI = "https://management.azure.com" +) + +// BaseClient is the base client for Managementgroups. +type BaseClient struct { + autorest.Client + BaseURI string + OperationResultID string + Skip *int32 + Top *int32 + Skiptoken string +} + +// New creates an instance of the BaseClient client. +func New(operationResultID string, skip *int32, top *int32, skiptoken string) BaseClient { + return NewWithBaseURI(DefaultBaseURI, operationResultID, skip, top, skiptoken) +} + +// NewWithBaseURI creates an instance of the BaseClient client using a custom endpoint. Use this when interacting with +// an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). +func NewWithBaseURI(baseURI string, operationResultID string, skip *int32, top *int32, skiptoken string) BaseClient { + return BaseClient{ + Client: autorest.NewClientWithUserAgent(UserAgent()), + BaseURI: baseURI, + OperationResultID: operationResultID, + Skip: skip, + Top: top, + Skiptoken: skiptoken, + } +} + +// CheckNameAvailability checks if the specified management group name is valid and unique +// Parameters: +// checkNameAvailabilityRequest - management group name availability check parameters. +func (client BaseClient) CheckNameAvailability(ctx context.Context, checkNameAvailabilityRequest CheckNameAvailabilityRequest) (result CheckNameAvailabilityResult, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.CheckNameAvailability") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.CheckNameAvailabilityPreparer(ctx, checkNameAvailabilityRequest) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "CheckNameAvailability", nil, "Failure preparing request") + return + } + + resp, err := client.CheckNameAvailabilitySender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "CheckNameAvailability", resp, "Failure sending request") + return + } + + result, err = client.CheckNameAvailabilityResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "CheckNameAvailability", resp, "Failure responding to request") + } + + return +} + +// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request. +func (client BaseClient) CheckNameAvailabilityPreparer(ctx context.Context, checkNameAvailabilityRequest CheckNameAvailabilityRequest) (*http.Request, error) { + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.Management/checkNameAvailability"), + autorest.WithJSON(checkNameAvailabilityRequest), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the +// http.Response Body if it receives an error. +func (client BaseClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always +// closes the http.Response Body. +func (client BaseClient) CheckNameAvailabilityResponder(resp *http.Response) (result CheckNameAvailabilityResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// StartTenantBackfill starts backfilling subscriptions for the Tenant. +func (client BaseClient) StartTenantBackfill(ctx context.Context) (result TenantBackfillStatusResult, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.StartTenantBackfill") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.StartTenantBackfillPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "StartTenantBackfill", nil, "Failure preparing request") + return + } + + resp, err := client.StartTenantBackfillSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "StartTenantBackfill", resp, "Failure sending request") + return + } + + result, err = client.StartTenantBackfillResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "StartTenantBackfill", resp, "Failure responding to request") + } + + return +} + +// StartTenantBackfillPreparer prepares the StartTenantBackfill request. +func (client BaseClient) StartTenantBackfillPreparer(ctx context.Context) (*http.Request, error) { + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.Management/startTenantBackfill"), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// StartTenantBackfillSender sends the StartTenantBackfill request. The method will close the +// http.Response Body if it receives an error. +func (client BaseClient) StartTenantBackfillSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// StartTenantBackfillResponder handles the response to the StartTenantBackfill request. The method always +// closes the http.Response Body. +func (client BaseClient) StartTenantBackfillResponder(resp *http.Response) (result TenantBackfillStatusResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// TenantBackfillStatus gets tenant backfill status +func (client BaseClient) TenantBackfillStatus(ctx context.Context) (result TenantBackfillStatusResult, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.TenantBackfillStatus") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.TenantBackfillStatusPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "TenantBackfillStatus", nil, "Failure preparing request") + return + } + + resp, err := client.TenantBackfillStatusSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "TenantBackfillStatus", resp, "Failure sending request") + return + } + + result, err = client.TenantBackfillStatusResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.BaseClient", "TenantBackfillStatus", resp, "Failure responding to request") + } + + return +} + +// TenantBackfillStatusPreparer prepares the TenantBackfillStatus request. +func (client BaseClient) TenantBackfillStatusPreparer(ctx context.Context) (*http.Request, error) { + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.Management/tenantBackfillStatus"), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// TenantBackfillStatusSender sends the TenantBackfillStatus request. The method will close the +// http.Response Body if it receives an error. +func (client BaseClient) TenantBackfillStatusSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// TenantBackfillStatusResponder handles the response to the TenantBackfillStatus request. The method always +// closes the http.Response Body. +func (client BaseClient) TenantBackfillStatusResponder(resp *http.Response) (result TenantBackfillStatusResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/entities.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/entities.go new file mode 100644 index 000000000000..007be772b8fd --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/entities.go @@ -0,0 +1,208 @@ +package managementgroups + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// EntitiesClient is the the Azure Management Groups API enables consolidation of multiple +// subscriptions/resources into an organizational hierarchy and centrally +// manage access control, policies, alerting and reporting for those resources. +type EntitiesClient struct { + BaseClient +} + +// NewEntitiesClient creates an instance of the EntitiesClient client. +func NewEntitiesClient(operationResultID string, skip *int32, top *int32, skiptoken string) EntitiesClient { + return NewEntitiesClientWithBaseURI(DefaultBaseURI, operationResultID, skip, top, skiptoken) +} + +// NewEntitiesClientWithBaseURI creates an instance of the EntitiesClient client using a custom endpoint. Use this +// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). +func NewEntitiesClientWithBaseURI(baseURI string, operationResultID string, skip *int32, top *int32, skiptoken string) EntitiesClient { + return EntitiesClient{NewWithBaseURI(baseURI, operationResultID, skip, top, skiptoken)} +} + +// List list all entities (Management Groups, Subscriptions, etc.) for the authenticated user. +// Parameters: +// selectParameter - this parameter specifies the fields to include in the response. Can include any +// combination of Name,DisplayName,Type,ParentDisplayNameChain,ParentChain, e.g. +// '$select=Name,DisplayName,Type,ParentDisplayNameChain,ParentNameChain'. When specified the $select parameter +// can override select in $skipToken. +// search - the $search parameter is used in conjunction with the $filter parameter to return three different +// outputs depending on the parameter passed in. +// With $search=AllowedParents the API will return the entity info of all groups that the requested entity will +// be able to reparent to as determined by the user's permissions. +// With $search=AllowedChildren the API will return the entity info of all entities that can be added as +// children of the requested entity. +// With $search=ParentAndFirstLevelChildren the API will return the parent and first level of children that +// the user has either direct access to or indirect access via one of their descendants. +// With $search=ParentOnly the API will return only the group if the user has access to at least one of the +// descendants of the group. +// With $search=ChildrenOnly the API will return only the first level of children of the group entity info +// specified in $filter. The user must have direct access to the children entities or one of it's descendants +// for it to show up in the results. +// filter - the filter parameter allows you to filter on the the name or display name fields. You can check for +// equality on the name field (e.g. name eq '{entityName}') and you can check for substrings on either the +// name or display name fields(e.g. contains(name, '{substringToSearch}'), contains(displayName, +// '{substringToSearch')). Note that the '{entityName}' and '{substringToSearch}' fields are checked case +// insensitively. +// view - the view parameter allows clients to filter the type of data that is returned by the getEntities +// call. +// groupName - a filter which allows the get entities call to focus on a particular group (i.e. "$filter=name +// eq 'groupName'") +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client EntitiesClient) List(ctx context.Context, selectParameter string, search string, filter string, view string, groupName string, cacheControl string) (result EntityListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EntitiesClient.List") + defer func() { + sc := -1 + if result.elr.Response.Response != nil { + sc = result.elr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, selectParameter, search, filter, view, groupName, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.EntitiesClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.elr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.EntitiesClient", "List", resp, "Failure sending request") + return + } + + result.elr, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.EntitiesClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client EntitiesClient) ListPreparer(ctx context.Context, selectParameter string, search string, filter string, view string, groupName string, cacheControl string) (*http.Request, error) { + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + if len(client.Skiptoken) > 0 { + queryParameters["$skiptoken"] = autorest.Encode("query", client.Skiptoken) + } + if client.Skip != nil { + queryParameters["$skip"] = autorest.Encode("query", *client.Skip) + } + if client.Top != nil { + queryParameters["$top"] = autorest.Encode("query", *client.Top) + } + if len(selectParameter) > 0 { + queryParameters["$select"] = autorest.Encode("query", selectParameter) + } + if len(string(search)) > 0 { + queryParameters["$search"] = autorest.Encode("query", search) + } + if len(filter) > 0 { + queryParameters["$filter"] = autorest.Encode("query", filter) + } + if len(string(view)) > 0 { + queryParameters["$view"] = autorest.Encode("query", view) + } + if len(groupName) > 0 { + queryParameters["groupName"] = autorest.Encode("query", groupName) + } + + preparer := autorest.CreatePreparer( + autorest.AsPost(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.Management/getEntities"), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListSender sends the List request. The method will close the +// http.Response Body if it receives an error. +func (client EntitiesClient) ListSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// ListResponder handles the response to the List request. The method always +// closes the http.Response Body. +func (client EntitiesClient) ListResponder(resp *http.Response) (result EntityListResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listNextResults retrieves the next set of results, if any. +func (client EntitiesClient) listNextResults(ctx context.Context, lastResults EntityListResult) (result EntityListResult, err error) { + req, err := lastResults.entityListResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "managementgroups.EntitiesClient", "listNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "managementgroups.EntitiesClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.EntitiesClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client EntitiesClient) ListComplete(ctx context.Context, selectParameter string, search string, filter string, view string, groupName string, cacheControl string) (result EntityListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EntitiesClient.List") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.List(ctx, selectParameter, search, filter, view, groupName, cacheControl) + return +} diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/hierarchysettings.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/hierarchysettings.go new file mode 100644 index 000000000000..412cefadafd4 --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/hierarchysettings.go @@ -0,0 +1,417 @@ +package managementgroups + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// HierarchySettingsClient is the the Azure Management Groups API enables consolidation of multiple +// subscriptions/resources into an organizational hierarchy and centrally +// manage access control, policies, alerting and reporting for those resources. +type HierarchySettingsClient struct { + BaseClient +} + +// NewHierarchySettingsClient creates an instance of the HierarchySettingsClient client. +func NewHierarchySettingsClient(operationResultID string, skip *int32, top *int32, skiptoken string) HierarchySettingsClient { + return NewHierarchySettingsClientWithBaseURI(DefaultBaseURI, operationResultID, skip, top, skiptoken) +} + +// NewHierarchySettingsClientWithBaseURI creates an instance of the HierarchySettingsClient client using a custom +// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure +// stack). +func NewHierarchySettingsClientWithBaseURI(baseURI string, operationResultID string, skip *int32, top *int32, skiptoken string) HierarchySettingsClient { + return HierarchySettingsClient{NewWithBaseURI(baseURI, operationResultID, skip, top, skiptoken)} +} + +// CreateOrUpdate creates or updates the hierarchy settings defined at the Management Group level. +// Parameters: +// groupID - management Group ID. +// createTenantSettingsRequest - tenant level settings request parameter. +func (client HierarchySettingsClient) CreateOrUpdate(ctx context.Context, groupID string, createTenantSettingsRequest CreateOrUpdateSettingsRequest) (result HierarchySettings, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HierarchySettingsClient.CreateOrUpdate") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.CreateOrUpdatePreparer(ctx, groupID, createTenantSettingsRequest) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + resp, err := client.CreateOrUpdateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "CreateOrUpdate", resp, "Failure sending request") + return + } + + result, err = client.CreateOrUpdateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "CreateOrUpdate", resp, "Failure responding to request") + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client HierarchySettingsClient) CreateOrUpdatePreparer(ctx context.Context, groupID string, createTenantSettingsRequest CreateOrUpdateSettingsRequest) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/settings/default", pathParameters), + autorest.WithJSON(createTenantSettingsRequest), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the +// http.Response Body if it receives an error. +func (client HierarchySettingsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client HierarchySettingsClient) CreateOrUpdateResponder(resp *http.Response) (result HierarchySettings, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Delete deletes the hierarchy settings defined at the Management Group level. +// Parameters: +// groupID - management Group ID. +func (client HierarchySettingsClient) Delete(ctx context.Context, groupID string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HierarchySettingsClient.Delete") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.DeletePreparer(ctx, groupID) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Delete", resp, "Failure responding to request") + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client HierarchySettingsClient) DeletePreparer(ctx context.Context, groupID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/settings/default", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSender sends the Delete request. The method will close the +// http.Response Body if it receives an error. +func (client HierarchySettingsClient) DeleteSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client HierarchySettingsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = resp + return +} + +// Get gets the hierarchy settings defined at the Management Group level. Settings can only be set on the root +// Management Group of the hierarchy. +// Parameters: +// groupID - management Group ID. +func (client HierarchySettingsClient) Get(ctx context.Context, groupID string) (result HierarchySettings, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HierarchySettingsClient.Get") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.GetPreparer(ctx, groupID) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client HierarchySettingsClient) GetPreparer(ctx context.Context, groupID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/settings/default", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetSender sends the Get request. The method will close the +// http.Response Body if it receives an error. +func (client HierarchySettingsClient) GetSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client HierarchySettingsClient) GetResponder(resp *http.Response) (result HierarchySettings, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List gets all the hierarchy settings defined at the Management Group level. Settings can only be set on the root +// Management Group of the hierarchy. +// Parameters: +// groupID - management Group ID. +func (client HierarchySettingsClient) List(ctx context.Context, groupID string) (result HierarchySettingsList, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HierarchySettingsClient.List") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.ListPreparer(ctx, groupID) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "List", resp, "Failure sending request") + return + } + + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client HierarchySettingsClient) ListPreparer(ctx context.Context, groupID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/settings", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListSender sends the List request. The method will close the +// http.Response Body if it receives an error. +func (client HierarchySettingsClient) ListSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// ListResponder handles the response to the List request. The method always +// closes the http.Response Body. +func (client HierarchySettingsClient) ListResponder(resp *http.Response) (result HierarchySettingsList, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Update updates the hierarchy settings defined at the Management Group level. +// Parameters: +// groupID - management Group ID. +// createTenantSettingsRequest - tenant level settings request parameter. +func (client HierarchySettingsClient) Update(ctx context.Context, groupID string, createTenantSettingsRequest CreateOrUpdateSettingsRequest) (result HierarchySettings, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/HierarchySettingsClient.Update") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.UpdatePreparer(ctx, groupID, createTenantSettingsRequest) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Update", nil, "Failure preparing request") + return + } + + resp, err := client.UpdateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Update", resp, "Failure sending request") + return + } + + result, err = client.UpdateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.HierarchySettingsClient", "Update", resp, "Failure responding to request") + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client HierarchySettingsClient) UpdatePreparer(ctx context.Context, groupID string, createTenantSettingsRequest CreateOrUpdateSettingsRequest) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPatch(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/settings/default", pathParameters), + autorest.WithJSON(createTenantSettingsRequest), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// UpdateSender sends the Update request. The method will close the +// http.Response Body if it receives an error. +func (client HierarchySettingsClient) UpdateSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client HierarchySettingsClient) UpdateResponder(resp *http.Response) (result HierarchySettings, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/managementgroups.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/managementgroups.go new file mode 100644 index 000000000000..06880f3e8aa7 --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/managementgroups.go @@ -0,0 +1,628 @@ +package managementgroups + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// Client is the the Azure Management Groups API enables consolidation of multiple +// subscriptions/resources into an organizational hierarchy and centrally +// manage access control, policies, alerting and reporting for those resources. +type Client struct { + BaseClient +} + +// NewClient creates an instance of the Client client. +func NewClient(operationResultID string, skip *int32, top *int32, skiptoken string) Client { + return NewClientWithBaseURI(DefaultBaseURI, operationResultID, skip, top, skiptoken) +} + +// NewClientWithBaseURI creates an instance of the Client client using a custom endpoint. Use this when interacting +// with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). +func NewClientWithBaseURI(baseURI string, operationResultID string, skip *int32, top *int32, skiptoken string) Client { + return Client{NewWithBaseURI(baseURI, operationResultID, skip, top, skiptoken)} +} + +// CreateOrUpdate create or update a management group. +// If a management group is already created and a subsequent create request is issued with different properties, the +// management group properties will be updated. +// Parameters: +// groupID - management Group ID. +// createManagementGroupRequest - management group creation parameters. +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client Client) CreateOrUpdate(ctx context.Context, groupID string, createManagementGroupRequest CreateManagementGroupRequest, cacheControl string) (result CreateOrUpdateFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.CreateOrUpdate") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.CreateOrUpdatePreparer(ctx, groupID, createManagementGroupRequest, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "CreateOrUpdate", nil, "Failure preparing request") + return + } + + result, err = client.CreateOrUpdateSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "CreateOrUpdate", result.Response(), "Failure sending request") + return + } + + return +} + +// CreateOrUpdatePreparer prepares the CreateOrUpdate request. +func (client Client) CreateOrUpdatePreparer(ctx context.Context, groupID string, createManagementGroupRequest CreateManagementGroupRequest, cacheControl string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + createManagementGroupRequest.ID = nil + createManagementGroupRequest.Type = nil + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters), + autorest.WithJSON(createManagementGroupRequest), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the +// http.Response Body if it receives an error. +func (client Client) CreateOrUpdateSender(req *http.Request) (future CreateOrUpdateFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always +// closes the http.Response Body. +func (client Client) CreateOrUpdateResponder(resp *http.Response) (result SetObject, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Delete delete management group. +// If a management group contains child resources, the request will fail. +// Parameters: +// groupID - management Group ID. +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client Client) Delete(ctx context.Context, groupID string, cacheControl string) (result DeleteFuture, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.Delete") + defer func() { + sc := -1 + if result.Response() != nil { + sc = result.Response().StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.DeletePreparer(ctx, groupID, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Delete", nil, "Failure preparing request") + return + } + + result, err = client.DeleteSender(req) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Delete", result.Response(), "Failure sending request") + return + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client Client) DeletePreparer(ctx context.Context, groupID string, cacheControl string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSender sends the Delete request. The method will close the +// http.Response Body if it receives an error. +func (client Client) DeleteSender(req *http.Request) (future DeleteFuture, err error) { + var resp *http.Response + resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if err != nil { + return + } + future.Future, err = azure.NewFutureFromResponse(resp) + return +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client Client) DeleteResponder(resp *http.Response) (result AzureAsyncOperationResults, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Get get the details of the management group. +// Parameters: +// groupID - management Group ID. +// expand - the $expand=children query string parameter allows clients to request inclusion of children in the +// response payload. $expand=path includes the path from the root group to the current group. +// recurse - the $recurse=true query string parameter allows clients to request inclusion of entire hierarchy +// in the response payload. Note that $expand=children must be passed up if $recurse is set to true. +// filter - a filter which allows the exclusion of subscriptions from results (i.e. '$filter=children.childType +// ne Subscription') +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client Client) Get(ctx context.Context, groupID string, expand string, recurse *bool, filter string, cacheControl string) (result ManagementGroup, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.Get") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.GetPreparer(ctx, groupID, expand, recurse, filter, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client Client) GetPreparer(ctx context.Context, groupID string, expand string, recurse *bool, filter string, cacheControl string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + if len(string(expand)) > 0 { + queryParameters["$expand"] = autorest.Encode("query", expand) + } + if recurse != nil { + queryParameters["$recurse"] = autorest.Encode("query", *recurse) + } + if len(filter) > 0 { + queryParameters["$filter"] = autorest.Encode("query", filter) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetSender sends the Get request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client Client) GetResponder(resp *http.Response) (result ManagementGroup, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// GetDescendants list all entities that descend from a management group. +// Parameters: +// groupID - management Group ID. +func (client Client) GetDescendants(ctx context.Context, groupID string) (result DescendantListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.GetDescendants") + defer func() { + sc := -1 + if result.dlr.Response.Response != nil { + sc = result.dlr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.getDescendantsNextResults + req, err := client.GetDescendantsPreparer(ctx, groupID) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "GetDescendants", nil, "Failure preparing request") + return + } + + resp, err := client.GetDescendantsSender(req) + if err != nil { + result.dlr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.Client", "GetDescendants", resp, "Failure sending request") + return + } + + result.dlr, err = client.GetDescendantsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "GetDescendants", resp, "Failure responding to request") + } + + return +} + +// GetDescendantsPreparer prepares the GetDescendants request. +func (client Client) GetDescendantsPreparer(ctx context.Context, groupID string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + if len(client.Skiptoken) > 0 { + queryParameters["$skiptoken"] = autorest.Encode("query", client.Skiptoken) + } + if client.Top != nil { + queryParameters["$top"] = autorest.Encode("query", *client.Top) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/descendants", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetDescendantsSender sends the GetDescendants request. The method will close the +// http.Response Body if it receives an error. +func (client Client) GetDescendantsSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// GetDescendantsResponder handles the response to the GetDescendants request. The method always +// closes the http.Response Body. +func (client Client) GetDescendantsResponder(resp *http.Response) (result DescendantListResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// getDescendantsNextResults retrieves the next set of results, if any. +func (client Client) getDescendantsNextResults(ctx context.Context, lastResults DescendantListResult) (result DescendantListResult, err error) { + req, err := lastResults.descendantListResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "managementgroups.Client", "getDescendantsNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.GetDescendantsSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "managementgroups.Client", "getDescendantsNextResults", resp, "Failure sending next results request") + } + result, err = client.GetDescendantsResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "getDescendantsNextResults", resp, "Failure responding to next results request") + } + return +} + +// GetDescendantsComplete enumerates all values, automatically crossing page boundaries as required. +func (client Client) GetDescendantsComplete(ctx context.Context, groupID string) (result DescendantListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.GetDescendants") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.GetDescendants(ctx, groupID) + return +} + +// List list management groups for the authenticated user. +// Parameters: +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client Client) List(ctx context.Context, cacheControl string) (result ListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.List") + defer func() { + sc := -1 + if result.lr.Response.Response != nil { + sc = result.lr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.lr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.Client", "List", resp, "Failure sending request") + return + } + + result.lr, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client Client) ListPreparer(ctx context.Context, cacheControl string) (*http.Request, error) { + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + if len(client.Skiptoken) > 0 { + queryParameters["$skiptoken"] = autorest.Encode("query", client.Skiptoken) + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.Management/managementGroups"), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListSender sends the List request. The method will close the +// http.Response Body if it receives an error. +func (client Client) ListSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// ListResponder handles the response to the List request. The method always +// closes the http.Response Body. +func (client Client) ListResponder(resp *http.Response) (result ListResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listNextResults retrieves the next set of results, if any. +func (client Client) listNextResults(ctx context.Context, lastResults ListResult) (result ListResult, err error) { + req, err := lastResults.listResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "managementgroups.Client", "listNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "managementgroups.Client", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client Client) ListComplete(ctx context.Context, cacheControl string) (result ListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.List") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.List(ctx, cacheControl) + return +} + +// Update update a management group. +// Parameters: +// groupID - management Group ID. +// patchGroupRequest - management group patch parameters. +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client Client) Update(ctx context.Context, groupID string, patchGroupRequest PatchManagementGroupRequest, cacheControl string) (result ManagementGroup, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/Client.Update") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.UpdatePreparer(ctx, groupID, patchGroupRequest, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Update", nil, "Failure preparing request") + return + } + + resp, err := client.UpdateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Update", resp, "Failure sending request") + return + } + + result, err = client.UpdateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.Client", "Update", resp, "Failure responding to request") + } + + return +} + +// UpdatePreparer prepares the Update request. +func (client Client) UpdatePreparer(ctx context.Context, groupID string, patchGroupRequest PatchManagementGroupRequest, cacheControl string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPatch(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}", pathParameters), + autorest.WithJSON(patchGroupRequest), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// UpdateSender sends the Update request. The method will close the +// http.Response Body if it receives an error. +func (client Client) UpdateSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// UpdateResponder handles the response to the Update request. The method always +// closes the http.Response Body. +func (client Client) UpdateResponder(resp *http.Response) (result ManagementGroup, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/managementgroupsapi/interfaces.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/managementgroupsapi/interfaces.go new file mode 100644 index 000000000000..9759a4df20d0 --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/managementgroupsapi/interfaces.go @@ -0,0 +1,82 @@ +package managementgroupsapi + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/services/preview/resources/mgmt/2020-02-01/managementgroups" + "github.com/Azure/go-autorest/autorest" +) + +// BaseClientAPI contains the set of methods on the BaseClient type. +type BaseClientAPI interface { + CheckNameAvailability(ctx context.Context, checkNameAvailabilityRequest managementgroups.CheckNameAvailabilityRequest) (result managementgroups.CheckNameAvailabilityResult, err error) + StartTenantBackfill(ctx context.Context) (result managementgroups.TenantBackfillStatusResult, err error) + TenantBackfillStatus(ctx context.Context) (result managementgroups.TenantBackfillStatusResult, err error) +} + +var _ BaseClientAPI = (*managementgroups.BaseClient)(nil) + +// ClientAPI contains the set of methods on the Client type. +type ClientAPI interface { + CreateOrUpdate(ctx context.Context, groupID string, createManagementGroupRequest managementgroups.CreateManagementGroupRequest, cacheControl string) (result managementgroups.CreateOrUpdateFuture, err error) + Delete(ctx context.Context, groupID string, cacheControl string) (result managementgroups.DeleteFuture, err error) + Get(ctx context.Context, groupID string, expand string, recurse *bool, filter string, cacheControl string) (result managementgroups.ManagementGroup, err error) + GetDescendants(ctx context.Context, groupID string) (result managementgroups.DescendantListResultPage, err error) + GetDescendantsComplete(ctx context.Context, groupID string) (result managementgroups.DescendantListResultIterator, err error) + List(ctx context.Context, cacheControl string) (result managementgroups.ListResultPage, err error) + ListComplete(ctx context.Context, cacheControl string) (result managementgroups.ListResultIterator, err error) + Update(ctx context.Context, groupID string, patchGroupRequest managementgroups.PatchManagementGroupRequest, cacheControl string) (result managementgroups.ManagementGroup, err error) +} + +var _ ClientAPI = (*managementgroups.Client)(nil) + +// SubscriptionsClientAPI contains the set of methods on the SubscriptionsClient type. +type SubscriptionsClientAPI interface { + Create(ctx context.Context, groupID string, subscriptionID string, cacheControl string) (result autorest.Response, err error) + Delete(ctx context.Context, groupID string, subscriptionID string, cacheControl string) (result autorest.Response, err error) +} + +var _ SubscriptionsClientAPI = (*managementgroups.SubscriptionsClient)(nil) + +// HierarchySettingsClientAPI contains the set of methods on the HierarchySettingsClient type. +type HierarchySettingsClientAPI interface { + CreateOrUpdate(ctx context.Context, groupID string, createTenantSettingsRequest managementgroups.CreateOrUpdateSettingsRequest) (result managementgroups.HierarchySettings, err error) + Delete(ctx context.Context, groupID string) (result autorest.Response, err error) + Get(ctx context.Context, groupID string) (result managementgroups.HierarchySettings, err error) + List(ctx context.Context, groupID string) (result managementgroups.HierarchySettingsList, err error) + Update(ctx context.Context, groupID string, createTenantSettingsRequest managementgroups.CreateOrUpdateSettingsRequest) (result managementgroups.HierarchySettings, err error) +} + +var _ HierarchySettingsClientAPI = (*managementgroups.HierarchySettingsClient)(nil) + +// OperationsClientAPI contains the set of methods on the OperationsClient type. +type OperationsClientAPI interface { + List(ctx context.Context) (result managementgroups.OperationListResultPage, err error) + ListComplete(ctx context.Context) (result managementgroups.OperationListResultIterator, err error) +} + +var _ OperationsClientAPI = (*managementgroups.OperationsClient)(nil) + +// EntitiesClientAPI contains the set of methods on the EntitiesClient type. +type EntitiesClientAPI interface { + List(ctx context.Context, selectParameter string, search string, filter string, view string, groupName string, cacheControl string) (result managementgroups.EntityListResultPage, err error) + ListComplete(ctx context.Context, selectParameter string, search string, filter string, view string, groupName string, cacheControl string) (result managementgroups.EntityListResultIterator, err error) +} + +var _ EntitiesClientAPI = (*managementgroups.EntitiesClient)(nil) diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/models.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/models.go new file mode 100644 index 000000000000..ee5717cb63ff --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/models.go @@ -0,0 +1,1852 @@ +package managementgroups + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "encoding/json" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/date" + "github.com/Azure/go-autorest/autorest/to" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// The package's fully qualified name. +const fqdn = "github.com/Azure/azure-sdk-for-go/services/preview/resources/mgmt/2020-02-01/managementgroups" + +// InheritedPermissions enumerates the values for inherited permissions. +type InheritedPermissions string + +const ( + // Delete ... + Delete InheritedPermissions = "delete" + // Edit ... + Edit InheritedPermissions = "edit" + // Noaccess ... + Noaccess InheritedPermissions = "noaccess" + // View ... + View InheritedPermissions = "view" +) + +// PossibleInheritedPermissionsValues returns an array of possible values for the InheritedPermissions const type. +func PossibleInheritedPermissionsValues() []InheritedPermissions { + return []InheritedPermissions{Delete, Edit, Noaccess, View} +} + +// Permissions enumerates the values for permissions. +type Permissions string + +const ( + // PermissionsDelete ... + PermissionsDelete Permissions = "delete" + // PermissionsEdit ... + PermissionsEdit Permissions = "edit" + // PermissionsNoaccess ... + PermissionsNoaccess Permissions = "noaccess" + // PermissionsView ... + PermissionsView Permissions = "view" +) + +// PossiblePermissionsValues returns an array of possible values for the Permissions const type. +func PossiblePermissionsValues() []Permissions { + return []Permissions{PermissionsDelete, PermissionsEdit, PermissionsNoaccess, PermissionsView} +} + +// Permissions1 enumerates the values for permissions 1. +type Permissions1 string + +const ( + // Permissions1Delete ... + Permissions1Delete Permissions1 = "delete" + // Permissions1Edit ... + Permissions1Edit Permissions1 = "edit" + // Permissions1Noaccess ... + Permissions1Noaccess Permissions1 = "noaccess" + // Permissions1View ... + Permissions1View Permissions1 = "view" +) + +// PossiblePermissions1Values returns an array of possible values for the Permissions1 const type. +func PossiblePermissions1Values() []Permissions1 { + return []Permissions1{Permissions1Delete, Permissions1Edit, Permissions1Noaccess, Permissions1View} +} + +// Reason enumerates the values for reason. +type Reason string + +const ( + // AlreadyExists ... + AlreadyExists Reason = "AlreadyExists" + // Invalid ... + Invalid Reason = "Invalid" +) + +// PossibleReasonValues returns an array of possible values for the Reason const type. +func PossibleReasonValues() []Reason { + return []Reason{AlreadyExists, Invalid} +} + +// Status enumerates the values for status. +type Status string + +const ( + // Cancelled ... + Cancelled Status = "Cancelled" + // Completed ... + Completed Status = "Completed" + // Failed ... + Failed Status = "Failed" + // NotStarted ... + NotStarted Status = "NotStarted" + // NotStartedButGroupsExist ... + NotStartedButGroupsExist Status = "NotStartedButGroupsExist" + // Started ... + Started Status = "Started" +) + +// PossibleStatusValues returns an array of possible values for the Status const type. +func PossibleStatusValues() []Status { + return []Status{Cancelled, Completed, Failed, NotStarted, NotStartedButGroupsExist, Started} +} + +// Type enumerates the values for type. +type Type string + +const ( + // MicrosoftManagementmanagementGroup ... + MicrosoftManagementmanagementGroup Type = "Microsoft.Management/managementGroup" +) + +// PossibleTypeValues returns an array of possible values for the Type const type. +func PossibleTypeValues() []Type { + return []Type{MicrosoftManagementmanagementGroup} +} + +// Type1 enumerates the values for type 1. +type Type1 string + +const ( + // MicrosoftManagementmanagementGroups ... + MicrosoftManagementmanagementGroups Type1 = "Microsoft.Management/managementGroups" + // Subscriptions ... + Subscriptions Type1 = "/subscriptions" +) + +// PossibleType1Values returns an array of possible values for the Type1 const type. +func PossibleType1Values() []Type1 { + return []Type1{MicrosoftManagementmanagementGroups, Subscriptions} +} + +// Type2 enumerates the values for type 2. +type Type2 string + +const ( + // Type2MicrosoftManagementmanagementGroups ... + Type2MicrosoftManagementmanagementGroups Type2 = "Microsoft.Management/managementGroups" + // Type2Subscriptions ... + Type2Subscriptions Type2 = "/subscriptions" +) + +// PossibleType2Values returns an array of possible values for the Type2 const type. +func PossibleType2Values() []Type2 { + return []Type2{Type2MicrosoftManagementmanagementGroups, Type2Subscriptions} +} + +// AzureAsyncOperationResults the results of Azure-AsyncOperation. +type AzureAsyncOperationResults struct { + autorest.Response `json:"-"` + // ID - READ-ONLY; The fully qualified ID for the management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the management group. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + // Status - READ-ONLY; The current status of the asynchronous operation performed . For example, Running, Succeeded, Failed + Status *string `json:"status,omitempty"` + *InfoProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for AzureAsyncOperationResults. +func (aaor AzureAsyncOperationResults) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if aaor.InfoProperties != nil { + objectMap["properties"] = aaor.InfoProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for AzureAsyncOperationResults struct. +func (aaor *AzureAsyncOperationResults) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + aaor.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + aaor.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + aaor.Name = &name + } + case "status": + if v != nil { + var status string + err = json.Unmarshal(*v, &status) + if err != nil { + return err + } + aaor.Status = &status + } + case "properties": + if v != nil { + var infoProperties InfoProperties + err = json.Unmarshal(*v, &infoProperties) + if err != nil { + return err + } + aaor.InfoProperties = &infoProperties + } + } + } + + return nil +} + +// CheckNameAvailabilityRequest management group name availability check parameters. +type CheckNameAvailabilityRequest struct { + // Name - the name to check for availability + Name *string `json:"name,omitempty"` + // Type - fully qualified resource type which includes provider namespace. Possible values include: 'MicrosoftManagementmanagementGroup' + Type Type `json:"type,omitempty"` +} + +// CheckNameAvailabilityResult describes the result of the request to check management group name +// availability. +type CheckNameAvailabilityResult struct { + autorest.Response `json:"-"` + // NameAvailable - READ-ONLY; Required. True indicates name is valid and available. False indicates the name is invalid, unavailable, or both. + NameAvailable *bool `json:"nameAvailable,omitempty"` + // Reason - READ-ONLY; Required if nameAvailable == false. Invalid indicates the name provided does not match the resource provider's naming requirements (incorrect length, unsupported characters, etc.) AlreadyExists indicates that the name is already in use and is therefore unavailable. Possible values include: 'Invalid', 'AlreadyExists' + Reason Reason `json:"reason,omitempty"` + // Message - READ-ONLY; Required if nameAvailable == false. Localized. If reason == invalid, provide the user with the reason why the given name is invalid, and provide the resource naming requirements so that the user can select a valid name. If reason == AlreadyExists, explain that is already in use, and direct them to select a different name. + Message *string `json:"message,omitempty"` +} + +// ChildInfo the child information of a management group. +type ChildInfo struct { + // Type - The fully qualified resource type which includes provider namespace (e.g. Microsoft.Management/managementGroups). Possible values include: 'MicrosoftManagementmanagementGroups', 'Subscriptions' + Type Type1 `json:"type,omitempty"` + // ID - The fully qualified ID for the child resource (management group or subscription). For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Name - The name of the child entity. + Name *string `json:"name,omitempty"` + // DisplayName - The friendly name of the child resource. + DisplayName *string `json:"displayName,omitempty"` + // Roles - The roles definitions associated with the management group. + Roles *[]string `json:"roles,omitempty"` + // Children - The list of children. + Children *[]ChildInfo `json:"children,omitempty"` +} + +// CreateManagementGroupChildInfo the child information of a management group used during creation. +type CreateManagementGroupChildInfo struct { + // Type - READ-ONLY; The fully qualified resource type which includes provider namespace (e.g. Microsoft.Management/managementGroups). Possible values include: 'Type2MicrosoftManagementmanagementGroups', 'Type2Subscriptions' + Type Type2 `json:"type,omitempty"` + // ID - READ-ONLY; The fully qualified ID for the child resource (management group or subscription). For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the child entity. + Name *string `json:"name,omitempty"` + // DisplayName - READ-ONLY; The friendly name of the child resource. + DisplayName *string `json:"displayName,omitempty"` + // Roles - READ-ONLY; The roles definitions associated with the management group. + Roles *[]string `json:"roles,omitempty"` + // Children - READ-ONLY; The list of children. + Children *[]CreateManagementGroupChildInfo `json:"children,omitempty"` +} + +// CreateManagementGroupDetails the details of a management group used during creation. +type CreateManagementGroupDetails struct { + // Version - READ-ONLY; The version number of the object. + Version *float64 `json:"version,omitempty"` + // UpdatedTime - READ-ONLY; The date and time when this object was last updated. + UpdatedTime *date.Time `json:"updatedTime,omitempty"` + // UpdatedBy - READ-ONLY; The identity of the principal or process that updated the object. + UpdatedBy *string `json:"updatedBy,omitempty"` + Parent *CreateParentGroupInfo `json:"parent,omitempty"` +} + +// CreateManagementGroupProperties the generic properties of a management group used during creation. +type CreateManagementGroupProperties struct { + // TenantID - READ-ONLY; The AAD Tenant ID associated with the management group. For example, 00000000-0000-0000-0000-000000000000 + TenantID *string `json:"tenantId,omitempty"` + // DisplayName - The friendly name of the management group. If no value is passed then this field will be set to the groupId. + DisplayName *string `json:"displayName,omitempty"` + // Roles - READ-ONLY; The roles definitions associated with the management group. + Roles *[]string `json:"roles,omitempty"` + Details *CreateManagementGroupDetails `json:"details,omitempty"` + // Children - READ-ONLY; The list of children. + Children *[]CreateManagementGroupChildInfo `json:"children,omitempty"` +} + +// CreateManagementGroupRequest management group creation parameters. +type CreateManagementGroupRequest struct { + // ID - READ-ONLY; The fully qualified ID for the management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups + Type *string `json:"type,omitempty"` + // Name - The name of the management group. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + *CreateManagementGroupProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for CreateManagementGroupRequest. +func (cmgr CreateManagementGroupRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if cmgr.Name != nil { + objectMap["name"] = cmgr.Name + } + if cmgr.CreateManagementGroupProperties != nil { + objectMap["properties"] = cmgr.CreateManagementGroupProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for CreateManagementGroupRequest struct. +func (cmgr *CreateManagementGroupRequest) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + cmgr.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + cmgr.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + cmgr.Name = &name + } + case "properties": + if v != nil { + var createManagementGroupProperties CreateManagementGroupProperties + err = json.Unmarshal(*v, &createManagementGroupProperties) + if err != nil { + return err + } + cmgr.CreateManagementGroupProperties = &createManagementGroupProperties + } + } + } + + return nil +} + +// CreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a long-running +// operation. +type CreateOrUpdateFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *CreateOrUpdateFuture) Result(client Client) (so SetObject, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.CreateOrUpdateFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("managementgroups.CreateOrUpdateFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if so.Response.Response, err = future.GetResult(sender); err == nil && so.Response.Response.StatusCode != http.StatusNoContent { + so, err = client.CreateOrUpdateResponder(so.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.CreateOrUpdateFuture", "Result", so.Response.Response, "Failure responding to request") + } + } + return +} + +// CreateOrUpdateSettingsProperties the properties of the request to create or update Management Group +// settings +type CreateOrUpdateSettingsProperties struct { + // RequireAuthorizationForGroupCreation - Indicates whether RBAC access is required upon group creation under the root Management Group. If set to true, user will require Microsoft.Management/managementGroups/write action on the root Management Group scope in order to create new Groups directly under the root. This will prevent new users from creating new Management Groups, unless they are given access. + RequireAuthorizationForGroupCreation *bool `json:"requireAuthorizationForGroupCreation,omitempty"` + // DefaultManagementGroup - Settings that sets the default Management Group under which new subscriptions get added in this tenant. For example, /providers/Microsoft.Management/managementGroups/defaultGroup + DefaultManagementGroup *string `json:"defaultManagementGroup,omitempty"` +} + +// CreateOrUpdateSettingsRequest parameters for creating or updating Management Group settings +type CreateOrUpdateSettingsRequest struct { + *CreateOrUpdateSettingsProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for CreateOrUpdateSettingsRequest. +func (cousr CreateOrUpdateSettingsRequest) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if cousr.CreateOrUpdateSettingsProperties != nil { + objectMap["properties"] = cousr.CreateOrUpdateSettingsProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for CreateOrUpdateSettingsRequest struct. +func (cousr *CreateOrUpdateSettingsRequest) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "properties": + if v != nil { + var createOrUpdateSettingsProperties CreateOrUpdateSettingsProperties + err = json.Unmarshal(*v, &createOrUpdateSettingsProperties) + if err != nil { + return err + } + cousr.CreateOrUpdateSettingsProperties = &createOrUpdateSettingsProperties + } + } + } + + return nil +} + +// CreateParentGroupInfo (Optional) The ID of the parent management group used during creation. +type CreateParentGroupInfo struct { + // ID - The fully qualified ID for the parent management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; The name of the parent management group + Name *string `json:"name,omitempty"` + // DisplayName - READ-ONLY; The friendly name of the parent management group. + DisplayName *string `json:"displayName,omitempty"` +} + +// DeleteFuture an abstraction for monitoring and retrieving the results of a long-running operation. +type DeleteFuture struct { + azure.Future +} + +// Result returns the result of the asynchronous operation. +// If the operation has not completed it will return an error. +func (future *DeleteFuture) Result(client Client) (aaor AzureAsyncOperationResults, err error) { + var done bool + done, err = future.DoneWithContext(context.Background(), client) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.DeleteFuture", "Result", future.Response(), "Polling failure") + return + } + if !done { + err = azure.NewAsyncOpIncompleteError("managementgroups.DeleteFuture") + return + } + sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + if aaor.Response.Response, err = future.GetResult(sender); err == nil && aaor.Response.Response.StatusCode != http.StatusNoContent { + aaor, err = client.DeleteResponder(aaor.Response.Response) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.DeleteFuture", "Result", aaor.Response.Response, "Failure responding to request") + } + } + return +} + +// DescendantInfo the descendant. +type DescendantInfo struct { + // ID - READ-ONLY; The fully qualified ID for the descendant. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 or /subscriptions/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups or /subscriptions + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the descendant. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + *DescendantInfoProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for DescendantInfo. +func (di DescendantInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if di.DescendantInfoProperties != nil { + objectMap["properties"] = di.DescendantInfoProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for DescendantInfo struct. +func (di *DescendantInfo) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + di.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + di.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + di.Name = &name + } + case "properties": + if v != nil { + var descendantInfoProperties DescendantInfoProperties + err = json.Unmarshal(*v, &descendantInfoProperties) + if err != nil { + return err + } + di.DescendantInfoProperties = &descendantInfoProperties + } + } + } + + return nil +} + +// DescendantInfoProperties the generic properties of an descendant. +type DescendantInfoProperties struct { + // DisplayName - The friendly name of the management group. + DisplayName *string `json:"displayName,omitempty"` + Parent *DescendantParentGroupInfo `json:"parent,omitempty"` +} + +// DescendantListResult describes the result of the request to view descendants. +type DescendantListResult struct { + autorest.Response `json:"-"` + // Value - The list of descendants. + Value *[]DescendantInfo `json:"value,omitempty"` + // NextLink - READ-ONLY; The URL to use for getting the next set of results. + NextLink *string `json:"nextLink,omitempty"` +} + +// DescendantListResultIterator provides access to a complete listing of DescendantInfo values. +type DescendantListResultIterator struct { + i int + page DescendantListResultPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *DescendantListResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DescendantListResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *DescendantListResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter DescendantListResultIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter DescendantListResultIterator) Response() DescendantListResult { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter DescendantListResultIterator) Value() DescendantInfo { + if !iter.page.NotDone() { + return DescendantInfo{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the DescendantListResultIterator type. +func NewDescendantListResultIterator(page DescendantListResultPage) DescendantListResultIterator { + return DescendantListResultIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (dlr DescendantListResult) IsEmpty() bool { + return dlr.Value == nil || len(*dlr.Value) == 0 +} + +// descendantListResultPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (dlr DescendantListResult) descendantListResultPreparer(ctx context.Context) (*http.Request, error) { + if dlr.NextLink == nil || len(to.String(dlr.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(dlr.NextLink))) +} + +// DescendantListResultPage contains a page of DescendantInfo values. +type DescendantListResultPage struct { + fn func(context.Context, DescendantListResult) (DescendantListResult, error) + dlr DescendantListResult +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *DescendantListResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/DescendantListResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.dlr) + if err != nil { + return err + } + page.dlr = next + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *DescendantListResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page DescendantListResultPage) NotDone() bool { + return !page.dlr.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page DescendantListResultPage) Response() DescendantListResult { + return page.dlr +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page DescendantListResultPage) Values() []DescendantInfo { + if page.dlr.IsEmpty() { + return nil + } + return *page.dlr.Value +} + +// Creates a new instance of the DescendantListResultPage type. +func NewDescendantListResultPage(getNextPage func(context.Context, DescendantListResult) (DescendantListResult, error)) DescendantListResultPage { + return DescendantListResultPage{fn: getNextPage} +} + +// DescendantParentGroupInfo the ID of the parent management group. +type DescendantParentGroupInfo struct { + // ID - The fully qualified ID for the parent management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` +} + +// Details the details of a management group. +type Details struct { + // Version - The version number of the object. + Version *float64 `json:"version,omitempty"` + // UpdatedTime - The date and time when this object was last updated. + UpdatedTime *date.Time `json:"updatedTime,omitempty"` + // UpdatedBy - The identity of the principal or process that updated the object. + UpdatedBy *string `json:"updatedBy,omitempty"` + Parent *ParentGroupInfo `json:"parent,omitempty"` +} + +// EntityHierarchyItem the management group details for the hierarchy view. +type EntityHierarchyItem struct { + // ID - READ-ONLY; The fully qualified ID for the management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the management group. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + *EntityHierarchyItemProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for EntityHierarchyItem. +func (ehi EntityHierarchyItem) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if ehi.EntityHierarchyItemProperties != nil { + objectMap["properties"] = ehi.EntityHierarchyItemProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for EntityHierarchyItem struct. +func (ehi *EntityHierarchyItem) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + ehi.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + ehi.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + ehi.Name = &name + } + case "properties": + if v != nil { + var entityHierarchyItemProperties EntityHierarchyItemProperties + err = json.Unmarshal(*v, &entityHierarchyItemProperties) + if err != nil { + return err + } + ehi.EntityHierarchyItemProperties = &entityHierarchyItemProperties + } + } + } + + return nil +} + +// EntityHierarchyItemProperties the generic properties of a management group. +type EntityHierarchyItemProperties struct { + // DisplayName - The friendly name of the management group. + DisplayName *string `json:"displayName,omitempty"` + // Permissions - Possible values include: 'Permissions1Noaccess', 'Permissions1View', 'Permissions1Edit', 'Permissions1Delete' + Permissions Permissions1 `json:"permissions,omitempty"` + // Children - The list of children. + Children *[]EntityHierarchyItem `json:"children,omitempty"` +} + +// EntityInfo the entity. +type EntityInfo struct { + // ID - READ-ONLY; The fully qualified ID for the entity. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the entity. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + *EntityInfoProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for EntityInfo. +func (ei EntityInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if ei.EntityInfoProperties != nil { + objectMap["properties"] = ei.EntityInfoProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for EntityInfo struct. +func (ei *EntityInfo) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + ei.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + ei.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + ei.Name = &name + } + case "properties": + if v != nil { + var entityInfoProperties EntityInfoProperties + err = json.Unmarshal(*v, &entityInfoProperties) + if err != nil { + return err + } + ei.EntityInfoProperties = &entityInfoProperties + } + } + } + + return nil +} + +// EntityInfoProperties the generic properties of an entity. +type EntityInfoProperties struct { + // TenantID - The AAD Tenant ID associated with the entity. For example, 00000000-0000-0000-0000-000000000000 + TenantID *string `json:"tenantId,omitempty"` + // DisplayName - The friendly name of the management group. + DisplayName *string `json:"displayName,omitempty"` + Parent *EntityParentGroupInfo `json:"parent,omitempty"` + // Permissions - Possible values include: 'PermissionsNoaccess', 'PermissionsView', 'PermissionsEdit', 'PermissionsDelete' + Permissions Permissions `json:"permissions,omitempty"` + // InheritedPermissions - Possible values include: 'Noaccess', 'View', 'Edit', 'Delete' + InheritedPermissions InheritedPermissions `json:"inheritedPermissions,omitempty"` + NumberOfDescendants *int32 `json:"numberOfDescendants,omitempty"` + // NumberOfChildren - Number of children is the number of Groups and Subscriptions that are exactly one level underneath the current Group. + NumberOfChildren *int32 `json:"numberOfChildren,omitempty"` + // NumberOfChildGroups - Number of children is the number of Groups that are exactly one level underneath the current Group. + NumberOfChildGroups *int32 `json:"numberOfChildGroups,omitempty"` + // ParentDisplayNameChain - The parent display name chain from the root group to the immediate parent + ParentDisplayNameChain *[]string `json:"parentDisplayNameChain,omitempty"` + // ParentNameChain - The parent name chain from the root group to the immediate parent + ParentNameChain *[]string `json:"parentNameChain,omitempty"` +} + +// EntityListResult describes the result of the request to view entities. +type EntityListResult struct { + autorest.Response `json:"-"` + // Value - The list of entities. + Value *[]EntityInfo `json:"value,omitempty"` + // Count - READ-ONLY; Total count of records that match the filter + Count *int32 `json:"count,omitempty"` + // NextLink - READ-ONLY; The URL to use for getting the next set of results. + NextLink *string `json:"nextLink,omitempty"` +} + +// EntityListResultIterator provides access to a complete listing of EntityInfo values. +type EntityListResultIterator struct { + i int + page EntityListResultPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *EntityListResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EntityListResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *EntityListResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter EntityListResultIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter EntityListResultIterator) Response() EntityListResult { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter EntityListResultIterator) Value() EntityInfo { + if !iter.page.NotDone() { + return EntityInfo{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the EntityListResultIterator type. +func NewEntityListResultIterator(page EntityListResultPage) EntityListResultIterator { + return EntityListResultIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (elr EntityListResult) IsEmpty() bool { + return elr.Value == nil || len(*elr.Value) == 0 +} + +// entityListResultPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (elr EntityListResult) entityListResultPreparer(ctx context.Context) (*http.Request, error) { + if elr.NextLink == nil || len(to.String(elr.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(elr.NextLink))) +} + +// EntityListResultPage contains a page of EntityInfo values. +type EntityListResultPage struct { + fn func(context.Context, EntityListResult) (EntityListResult, error) + elr EntityListResult +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *EntityListResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/EntityListResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.elr) + if err != nil { + return err + } + page.elr = next + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *EntityListResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page EntityListResultPage) NotDone() bool { + return !page.elr.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page EntityListResultPage) Response() EntityListResult { + return page.elr +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page EntityListResultPage) Values() []EntityInfo { + if page.elr.IsEmpty() { + return nil + } + return *page.elr.Value +} + +// Creates a new instance of the EntityListResultPage type. +func NewEntityListResultPage(getNextPage func(context.Context, EntityListResult) (EntityListResult, error)) EntityListResultPage { + return EntityListResultPage{fn: getNextPage} +} + +// EntityParentGroupInfo (Optional) The ID of the parent management group. +type EntityParentGroupInfo struct { + // ID - The fully qualified ID for the parent management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` +} + +// ErrorDetails the details of the error. +type ErrorDetails struct { + // Code - One of a server-defined set of error codes. + Code *string `json:"code,omitempty"` + // Message - A human-readable representation of the error. + Message *string `json:"message,omitempty"` + // Details - A human-readable representation of the error's details. + Details *string `json:"details,omitempty"` +} + +// ErrorResponse the error object. +type ErrorResponse struct { + Error *ErrorDetails `json:"error,omitempty"` +} + +// HierarchySettings settings defined at the Management Group scope. +type HierarchySettings struct { + autorest.Response `json:"-"` + // ID - READ-ONLY; The fully qualified ID for the settings object. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000/settings/default. + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups/settings. + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the object. In this case, default. + Name *string `json:"name,omitempty"` + *HierarchySettingsProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for HierarchySettings. +func (hs HierarchySettings) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if hs.HierarchySettingsProperties != nil { + objectMap["properties"] = hs.HierarchySettingsProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for HierarchySettings struct. +func (hs *HierarchySettings) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + hs.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + hs.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + hs.Name = &name + } + case "properties": + if v != nil { + var hierarchySettingsProperties HierarchySettingsProperties + err = json.Unmarshal(*v, &hierarchySettingsProperties) + if err != nil { + return err + } + hs.HierarchySettingsProperties = &hierarchySettingsProperties + } + } + } + + return nil +} + +// HierarchySettingsInfo the hierarchy settings resource. +type HierarchySettingsInfo struct { + // ID - READ-ONLY; The fully qualified ID for the settings object. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000/settings/default. + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups/settings. + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the object. In this case, default. + Name *string `json:"name,omitempty"` + *HierarchySettingsProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for HierarchySettingsInfo. +func (hsi HierarchySettingsInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if hsi.HierarchySettingsProperties != nil { + objectMap["properties"] = hsi.HierarchySettingsProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for HierarchySettingsInfo struct. +func (hsi *HierarchySettingsInfo) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + hsi.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + hsi.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + hsi.Name = &name + } + case "properties": + if v != nil { + var hierarchySettingsProperties HierarchySettingsProperties + err = json.Unmarshal(*v, &hierarchySettingsProperties) + if err != nil { + return err + } + hsi.HierarchySettingsProperties = &hierarchySettingsProperties + } + } + } + + return nil +} + +// HierarchySettingsList lists all hierarchy settings. +type HierarchySettingsList struct { + autorest.Response `json:"-"` + // Value - The list of hierarchy settings. + Value *[]HierarchySettingsInfo `json:"value,omitempty"` + // NextLink - READ-ONLY; The URL to use for getting the next set of results. + NextLink *string `json:"nextLink,omitempty"` +} + +// HierarchySettingsProperties the generic properties of hierarchy settings. +type HierarchySettingsProperties struct { + // TenantID - The AAD Tenant ID associated with the hierarchy settings. For example, 00000000-0000-0000-0000-000000000000 + TenantID *string `json:"tenantId,omitempty"` + // RequireAuthorizationForGroupCreation - Indicates whether RBAC access is required upon group creation under the root Management Group. If set to true, user will require Microsoft.Management/managementGroups/write action on the root Management Group scope in order to create new Groups directly under the root. This will prevent new users from creating new Management Groups, unless they are given access. + RequireAuthorizationForGroupCreation *bool `json:"requireAuthorizationForGroupCreation,omitempty"` + // DefaultManagementGroup - Settings that sets the default Management Group under which new subscriptions get added in this tenant. For example, /providers/Microsoft.Management/managementGroups/defaultGroup + DefaultManagementGroup *string `json:"defaultManagementGroup,omitempty"` +} + +// Info the management group resource. +type Info struct { + // ID - READ-ONLY; The fully qualified ID for the management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the management group. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + *InfoProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for Info. +func (i Info) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if i.InfoProperties != nil { + objectMap["properties"] = i.InfoProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for Info struct. +func (i *Info) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + i.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + i.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + i.Name = &name + } + case "properties": + if v != nil { + var infoProperties InfoProperties + err = json.Unmarshal(*v, &infoProperties) + if err != nil { + return err + } + i.InfoProperties = &infoProperties + } + } + } + + return nil +} + +// InfoProperties the generic properties of a management group. +type InfoProperties struct { + // TenantID - The AAD Tenant ID associated with the management group. For example, 00000000-0000-0000-0000-000000000000 + TenantID *string `json:"tenantId,omitempty"` + // DisplayName - The friendly name of the management group. + DisplayName *string `json:"displayName,omitempty"` +} + +// ListResult describes the result of the request to list management groups. +type ListResult struct { + autorest.Response `json:"-"` + // Value - The list of management groups. + Value *[]Info `json:"value,omitempty"` + // NextLink - READ-ONLY; The URL to use for getting the next set of results. + NextLink *string `json:"nextLink,omitempty"` +} + +// ListResultIterator provides access to a complete listing of Info values. +type ListResultIterator struct { + i int + page ListResultPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *ListResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ListResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *ListResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter ListResultIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter ListResultIterator) Response() ListResult { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter ListResultIterator) Value() Info { + if !iter.page.NotDone() { + return Info{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the ListResultIterator type. +func NewListResultIterator(page ListResultPage) ListResultIterator { + return ListResultIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (lr ListResult) IsEmpty() bool { + return lr.Value == nil || len(*lr.Value) == 0 +} + +// listResultPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (lr ListResult) listResultPreparer(ctx context.Context) (*http.Request, error) { + if lr.NextLink == nil || len(to.String(lr.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(lr.NextLink))) +} + +// ListResultPage contains a page of Info values. +type ListResultPage struct { + fn func(context.Context, ListResult) (ListResult, error) + lr ListResult +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *ListResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/ListResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.lr) + if err != nil { + return err + } + page.lr = next + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *ListResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page ListResultPage) NotDone() bool { + return !page.lr.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page ListResultPage) Response() ListResult { + return page.lr +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page ListResultPage) Values() []Info { + if page.lr.IsEmpty() { + return nil + } + return *page.lr.Value +} + +// Creates a new instance of the ListResultPage type. +func NewListResultPage(getNextPage func(context.Context, ListResult) (ListResult, error)) ListResultPage { + return ListResultPage{fn: getNextPage} +} + +// ManagementGroup the management group details. +type ManagementGroup struct { + autorest.Response `json:"-"` + // ID - READ-ONLY; The fully qualified ID for the management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the management group. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + *Properties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for ManagementGroup. +func (mg ManagementGroup) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if mg.Properties != nil { + objectMap["properties"] = mg.Properties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for ManagementGroup struct. +func (mg *ManagementGroup) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + mg.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + mg.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + mg.Name = &name + } + case "properties": + if v != nil { + var properties Properties + err = json.Unmarshal(*v, &properties) + if err != nil { + return err + } + mg.Properties = &properties + } + } + } + + return nil +} + +// Operation operation supported by the Microsoft.Management resource provider. +type Operation struct { + // Name - READ-ONLY; Operation name: {provider}/{resource}/{operation}. + Name *string `json:"name,omitempty"` + Display *OperationDisplayProperties `json:"display,omitempty"` +} + +// OperationDisplayProperties the object that represents the operation. +type OperationDisplayProperties struct { + // Provider - READ-ONLY; The name of the provider. + Provider *string `json:"provider,omitempty"` + // Resource - READ-ONLY; The resource on which the operation is performed. + Resource *string `json:"resource,omitempty"` + // Operation - READ-ONLY; The operation that can be performed. + Operation *string `json:"operation,omitempty"` + // Description - READ-ONLY; Operation description. + Description *string `json:"description,omitempty"` +} + +// OperationListResult describes the result of the request to list Microsoft.Management operations. +type OperationListResult struct { + autorest.Response `json:"-"` + // Value - READ-ONLY; List of operations supported by the Microsoft.Management resource provider. + Value *[]Operation `json:"value,omitempty"` + // NextLink - READ-ONLY; URL to get the next set of operation list results if there are any. + NextLink *string `json:"nextLink,omitempty"` +} + +// OperationListResultIterator provides access to a complete listing of Operation values. +type OperationListResultIterator struct { + i int + page OperationListResultPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *OperationListResultIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationListResultIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *OperationListResultIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter OperationListResultIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter OperationListResultIterator) Response() OperationListResult { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter OperationListResultIterator) Value() Operation { + if !iter.page.NotDone() { + return Operation{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the OperationListResultIterator type. +func NewOperationListResultIterator(page OperationListResultPage) OperationListResultIterator { + return OperationListResultIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (olr OperationListResult) IsEmpty() bool { + return olr.Value == nil || len(*olr.Value) == 0 +} + +// operationListResultPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (olr OperationListResult) operationListResultPreparer(ctx context.Context) (*http.Request, error) { + if olr.NextLink == nil || len(to.String(olr.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(olr.NextLink))) +} + +// OperationListResultPage contains a page of Operation values. +type OperationListResultPage struct { + fn func(context.Context, OperationListResult) (OperationListResult, error) + olr OperationListResult +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *OperationListResultPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationListResultPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.olr) + if err != nil { + return err + } + page.olr = next + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *OperationListResultPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page OperationListResultPage) NotDone() bool { + return !page.olr.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page OperationListResultPage) Response() OperationListResult { + return page.olr +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page OperationListResultPage) Values() []Operation { + if page.olr.IsEmpty() { + return nil + } + return *page.olr.Value +} + +// Creates a new instance of the OperationListResultPage type. +func NewOperationListResultPage(getNextPage func(context.Context, OperationListResult) (OperationListResult, error)) OperationListResultPage { + return OperationListResultPage{fn: getNextPage} +} + +// OperationResults the results of an asynchronous operation. +type OperationResults struct { + // ID - READ-ONLY; The fully qualified ID for the management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Type - READ-ONLY; The type of the resource. For example, Microsoft.Management/managementGroups + Type *string `json:"type,omitempty"` + // Name - READ-ONLY; The name of the management group. For example, 00000000-0000-0000-0000-000000000000 + Name *string `json:"name,omitempty"` + *InfoProperties `json:"properties,omitempty"` +} + +// MarshalJSON is the custom marshaler for OperationResults. +func (or OperationResults) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if or.InfoProperties != nil { + objectMap["properties"] = or.InfoProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for OperationResults struct. +func (or *OperationResults) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + or.ID = &ID + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + or.Type = &typeVar + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + or.Name = &name + } + case "properties": + if v != nil { + var infoProperties InfoProperties + err = json.Unmarshal(*v, &infoProperties) + if err != nil { + return err + } + or.InfoProperties = &infoProperties + } + } + } + + return nil +} + +// ParentGroupInfo (Optional) The ID of the parent management group. +type ParentGroupInfo struct { + // ID - The fully qualified ID for the parent management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ID *string `json:"id,omitempty"` + // Name - The name of the parent management group + Name *string `json:"name,omitempty"` + // DisplayName - The friendly name of the parent management group. + DisplayName *string `json:"displayName,omitempty"` +} + +// PatchManagementGroupRequest management group patch parameters. +type PatchManagementGroupRequest struct { + // DisplayName - The friendly name of the management group. + DisplayName *string `json:"displayName,omitempty"` + // ParentID - (Optional) The fully qualified ID for the parent management group. For example, /providers/Microsoft.Management/managementGroups/0000000-0000-0000-0000-000000000000 + ParentID *string `json:"parentId,omitempty"` +} + +// PathElement a path element of a management group ancestors. +type PathElement struct { + // Name - The name of the group. + Name *string `json:"name,omitempty"` + // DisplayName - The friendly name of the group. + DisplayName *string `json:"displayName,omitempty"` +} + +// Properties the generic properties of a management group. +type Properties struct { + // TenantID - The AAD Tenant ID associated with the management group. For example, 00000000-0000-0000-0000-000000000000 + TenantID *string `json:"tenantId,omitempty"` + // DisplayName - The friendly name of the management group. + DisplayName *string `json:"displayName,omitempty"` + // Roles - The role definitions associated with the management group. + Roles *[]string `json:"roles,omitempty"` + Details *Details `json:"details,omitempty"` + // Children - The list of children. + Children *[]ChildInfo `json:"children,omitempty"` + // Path - The path from the root to the current group. + Path *[]PathElement `json:"path,omitempty"` +} + +// SetObject ... +type SetObject struct { + autorest.Response `json:"-"` + Value interface{} `json:"value,omitempty"` +} + +// TenantBackfillStatusResult the tenant backfill status +type TenantBackfillStatusResult struct { + autorest.Response `json:"-"` + // TenantID - READ-ONLY; The AAD Tenant ID associated with the management group. For example, 00000000-0000-0000-0000-000000000000 + TenantID *string `json:"tenantId,omitempty"` + // Status - READ-ONLY; The status of the Tenant Backfill. Possible values include: 'NotStarted', 'NotStartedButGroupsExist', 'Started', 'Failed', 'Cancelled', 'Completed' + Status Status `json:"status,omitempty"` +} diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/operations.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/operations.go new file mode 100644 index 000000000000..893e8859531d --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/operations.go @@ -0,0 +1,149 @@ +package managementgroups + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// OperationsClient is the the Azure Management Groups API enables consolidation of multiple +// subscriptions/resources into an organizational hierarchy and centrally +// manage access control, policies, alerting and reporting for those resources. +type OperationsClient struct { + BaseClient +} + +// NewOperationsClient creates an instance of the OperationsClient client. +func NewOperationsClient(operationResultID string, skip *int32, top *int32, skiptoken string) OperationsClient { + return NewOperationsClientWithBaseURI(DefaultBaseURI, operationResultID, skip, top, skiptoken) +} + +// NewOperationsClientWithBaseURI creates an instance of the OperationsClient client using a custom endpoint. Use this +// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). +func NewOperationsClientWithBaseURI(baseURI string, operationResultID string, skip *int32, top *int32, skiptoken string) OperationsClient { + return OperationsClient{NewWithBaseURI(baseURI, operationResultID, skip, top, skiptoken)} +} + +// List lists all of the available Management REST API operations. +func (client OperationsClient) List(ctx context.Context) (result OperationListResultPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List") + defer func() { + sc := -1 + if result.olr.Response.Response != nil { + sc = result.olr.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.OperationsClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.olr.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "managementgroups.OperationsClient", "List", resp, "Failure sending request") + return + } + + result.olr, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.OperationsClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request, error) { + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.Management/operations"), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListSender sends the List request. The method will close the +// http.Response Body if it receives an error. +func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) { + return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) +} + +// ListResponder handles the response to the List request. The method always +// closes the http.Response Body. +func (client OperationsClient) ListResponder(resp *http.Response) (result OperationListResult, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listNextResults retrieves the next set of results, if any. +func (client OperationsClient) listNextResults(ctx context.Context, lastResults OperationListResult) (result OperationListResult, err error) { + req, err := lastResults.operationListResultPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "managementgroups.OperationsClient", "listNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "managementgroups.OperationsClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.OperationsClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client OperationsClient) ListComplete(ctx context.Context) (result OperationListResultIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.List(ctx) + return +} diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/subscriptions.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/subscriptions.go new file mode 100644 index 000000000000..9fbde6df38bf --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/subscriptions.go @@ -0,0 +1,208 @@ +package managementgroups + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// SubscriptionsClient is the the Azure Management Groups API enables consolidation of multiple +// subscriptions/resources into an organizational hierarchy and centrally +// manage access control, policies, alerting and reporting for those resources. +type SubscriptionsClient struct { + BaseClient +} + +// NewSubscriptionsClient creates an instance of the SubscriptionsClient client. +func NewSubscriptionsClient(operationResultID string, skip *int32, top *int32, skiptoken string) SubscriptionsClient { + return NewSubscriptionsClientWithBaseURI(DefaultBaseURI, operationResultID, skip, top, skiptoken) +} + +// NewSubscriptionsClientWithBaseURI creates an instance of the SubscriptionsClient client using a custom endpoint. +// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). +func NewSubscriptionsClientWithBaseURI(baseURI string, operationResultID string, skip *int32, top *int32, skiptoken string) SubscriptionsClient { + return SubscriptionsClient{NewWithBaseURI(baseURI, operationResultID, skip, top, skiptoken)} +} + +// Create associates existing subscription with the management group. +// Parameters: +// groupID - management Group ID. +// subscriptionID - subscription ID. +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client SubscriptionsClient) Create(ctx context.Context, groupID string, subscriptionID string, cacheControl string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/SubscriptionsClient.Create") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.CreatePreparer(ctx, groupID, subscriptionID, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.SubscriptionsClient", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "managementgroups.SubscriptionsClient", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.SubscriptionsClient", "Create", resp, "Failure responding to request") + } + + return +} + +// CreatePreparer prepares the Create request. +func (client SubscriptionsClient) CreatePreparer(ctx context.Context, groupID string, subscriptionID string, cacheControl string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + "subscriptionId": autorest.Encode("path", subscriptionID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/subscriptions/{subscriptionId}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CreateSender sends the Create request. The method will close the +// http.Response Body if it receives an error. +func (client SubscriptionsClient) CreateSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client SubscriptionsClient) CreateResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), + autorest.ByClosing()) + result.Response = resp + return +} + +// Delete de-associates subscription from the management group. +// Parameters: +// groupID - management Group ID. +// subscriptionID - subscription ID. +// cacheControl - indicates that the request shouldn't utilize any caches. +func (client SubscriptionsClient) Delete(ctx context.Context, groupID string, subscriptionID string, cacheControl string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/SubscriptionsClient.Delete") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.DeletePreparer(ctx, groupID, subscriptionID, cacheControl) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.SubscriptionsClient", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "managementgroups.SubscriptionsClient", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "managementgroups.SubscriptionsClient", "Delete", resp, "Failure responding to request") + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client SubscriptionsClient) DeletePreparer(ctx context.Context, groupID string, subscriptionID string, cacheControl string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "groupId": autorest.Encode("path", groupID), + "subscriptionId": autorest.Encode("path", subscriptionID), + } + + const APIVersion = "2020-02-01" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Management/managementGroups/{groupId}/subscriptions/{subscriptionId}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + if len(cacheControl) > 0 { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String(cacheControl))) + } else { + preparer = autorest.DecoratePreparer(preparer, + autorest.WithHeader("Cache-Control", autorest.String("no-cache"))) + } + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSender sends the Delete request. The method will close the +// http.Response Body if it receives an error. +func (client SubscriptionsClient) DeleteSender(req *http.Request) (*http.Response, error) { + return client.Send(req, azure.DoRetryWithRegistration(client.Client)) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client SubscriptionsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), + autorest.ByClosing()) + result.Response = resp + return +} diff --git a/services/preview/resources/mgmt/2020-02-01/managementgroups/version.go b/services/preview/resources/mgmt/2020-02-01/managementgroups/version.go new file mode 100644 index 000000000000..13a01f68bd40 --- /dev/null +++ b/services/preview/resources/mgmt/2020-02-01/managementgroups/version.go @@ -0,0 +1,30 @@ +package managementgroups + +import "github.com/Azure/azure-sdk-for-go/version" + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +// UserAgent returns the UserAgent string to use when sending http.Requests. +func UserAgent() string { + return "Azure-SDK-For-Go/" + version.Number + " managementgroups/2020-02-01" +} + +// Version returns the semantic version (see http://semver.org) of the client. +func Version() string { + return version.Number +}