Domain name patch example

program.go

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"sync"

	"github.com/Azure/azure-sdk-for-go/arm/graphrbac"
	"github.com/Azure/azure-sdk-for-go/arm/resources/subscriptions"
	"github.com/Azure/go-autorest/autorest"
	"github.com/Azure/go-autorest/autorest/azure"
)

const (
	clientID = "04b07795-8ddb-461a-bbee-02f9e1bf7b46" // This is the client ID for the Azure CLI. It was chosen for its public well-known status.
	// APIVersion is the version of the Graphrbac
	APIVersion = "1.6"

	// DefaultBaseURI is the default URI used for the service Graphrbac
	DefaultBaseURI = "https://graph.windows.net"
)

// These globals configure the sample's execution environment.
// They should never be written to throughout the rest of the sample.
var (
	environment   = azure.PublicCloud
	commonTokenID = environment.ActiveDirectoryEndpoint + "/common"
	endpoint      = environment.ResourceManagerEndpoint
	graphEndpoint = environment.GraphEndpoint
)

// Clients expose REST functionality.
var (
	autorestClient     = autorest.NewClientWithUserAgent("authExample")
	subscriptionClient = subscriptions.NewClient()
	tenantClient       = subscriptions.NewTenantsClient()
)

func main() {
	var oAuthConfig *azure.OAuthConfig
	var err error

	oAuthConfig, err = environment.OAuthConfigForTenant(commonTokenID)
	if err != nil {
		panic(err)
	}

	var authToken *azure.Token
	if authToken, err = authenticateUser(oAuthConfig, os.Stdout); err != nil {
		panic(err)
	}

	spt, err := azure.NewServicePrincipalTokenFromManualToken(*oAuthConfig, clientID, endpoint, *authToken)
	tenantClient.Authorizer = spt

	err = processTenants(tenantClient, func(t subscriptions.TenantIDDescription) error {
		fmt.Printf("Tenant ID: %s\n", *t.TenantID)
		tenantOAuthConfig, err := azure.PublicCloud.OAuthConfigForTenant(*t.TenantID)
		if err != nil {
			return err
		}

		tenantToken, err := azure.NewServicePrincipalTokenFromManualToken(*tenantOAuthConfig, clientID, endpoint, *authToken)
		if err != nil {
			return err
		}

		graphClient := NewObjectsClient(*t.TenantID)
		graphSpt, err := azure.NewServicePrincipalTokenFromManualToken(*oAuthConfig, clientID, graphEndpoint, *authToken)
		graphClient.Authorizer = graphSpt
		if err = graphSpt.Refresh(); err != nil {
			return err
		}

		result, _ := graphClient.GetDomain()
		fmt.Println("Tenant Name: ", (*result.Value)[0].Name)

		subscriptionClient.Authorizer = tenantToken
		if err = tenantToken.Refresh(); err != nil {
			return err
		}

		err = processSubscriptions(subscriptionClient, func(s subscriptions.Subscription) error {
			_, err := fmt.Printf("\t%s\n", *s.SubscriptionID)
			return err
		})

		return err
	})
	if err != nil {
		return
	}

	fmt.Println("Done.")
}

func authenticateUser(oAuthConfig *azure.OAuthConfig, output io.Writer) (*azure.Token, error) {
	var err error
	var deviceCode *azure.DeviceCode
	if deviceCode, err = azure.InitiateDeviceAuth(&autorestClient, *oAuthConfig, clientID, endpoint); err != nil {
		return nil, err
	}

	_, err = fmt.Fprintln(output, *deviceCode.Message)
	if err != nil {
		return nil, err
	}

	token, err := azure.WaitForUserCompletion(&autorestClient, deviceCode)
	if err != nil {
		return nil, err
	}

	return token, nil
}

func processTenants(client subscriptions.TenantsClient, action func(subscriptions.TenantIDDescription) error) error {
	var result subscriptions.TenantListResult
	getNext := client.List
	var getNextUpdater sync.Once

	for {
		var err error
		result, err = getNext()
		if err != nil {
			return err
		} else if result.Value == nil {
			return nil
		}

		for _, tenant := range *result.Value {
			if err := action(tenant); err != nil {
				return err
			}
		}

		if result.NextLink == nil {
			break
		}
		getNextUpdater.Do(func() {
			getNext = func() (subscriptions.TenantListResult, error) {
				return client.ListNextResults(result)
			}
		})
	}
	return nil
}

func processSubscriptions(client subscriptions.Client, action func(subscriptions.Subscription) error) error {
	var result subscriptions.SubscriptionListResult
	getNext := client.List
	var getNextUpdater sync.Once

	for {
		var err error
		result, err = getNext()
		if err != nil {
			return err
		} else if result.Value == nil {
			return nil
		}

		for _, subscription := range *result.Value {
			action(subscription)
		}

		if result.NextLink == nil {
			break
		}
		getNextUpdater.Do(func() {
			getNext = func() (subscriptions.SubscriptionListResult, error) {
				return client.ListNextResults(result)
			}
		})
	}
	return nil
}

// DomainResponse is the List Disks operation response.
type DomainResponse struct {
	autorest.Response `json:"-"`
	Value             *[]Domain `json:"value,omitempty"`
	NextLink          *string   `json:"nextLink,omitempty"`
}

type Domain struct {
	Name string `json:"name,omitempty"`
}

// ObjectsClient is the the Graph RBAC Management Client
type MyObjectsClient struct {
	graphrbac.ManagementClient
}

// NewObjectsClient creates an instance of the ObjectsClient client.
func NewObjectsClient(tenantID string) MyObjectsClient {
	return MyObjectsClient(graphrbac.NewObjectsClientWithBaseURI(DefaultBaseURI, tenantID))
}

func NewObjectsClientWithBaseURI(baseURI string, tenantID string) MyObjectsClient {
	return MyObjectsClient{graphrbac.NewWithBaseURI(baseURI, tenantID)}
}

func (client MyObjectsClient) GetDomain() (result DomainResponse, err error) {
	req, err := client.GetDomainPreparer()
	if err != nil {
		return result, autorest.NewErrorWithError(err, "graphrbac.ObjectsClient", "GetDomain", nil, "Failure preparing request")
	}

	resp, err := client.GetDomainSender(req)
	if err != nil {
		result.Response = autorest.Response{Response: resp}
		return result, autorest.NewErrorWithError(err, "graphrbac.ObjectsClient", "GetDomain", resp, "Failure sending request")
	}

	result, err = client.GetDomainResponder(resp)
	if err != nil {
		err = autorest.NewErrorWithError(err, "graphrbac.ObjectsClient", "GetDomain", resp, "Failure responding to request")
	}

	return
}

func (client MyObjectsClient) GetDomainPreparer() (*http.Request, error) {
	pathParameters := map[string]interface{}{
		"tenantID": autorest.Encode("path", client.TenantID),
	}

	queryParameters := map[string]interface{}{
		"api-version": client.APIVersion,
	}

	preparer := autorest.CreatePreparer(
		autorest.AsGet(),
		autorest.WithBaseURL(client.BaseURI),
		autorest.WithPathParameters("/{tenantID}/domains", pathParameters),
		autorest.WithQueryParameters(queryParameters))
	return preparer.Prepare(&http.Request{})
}

// GetDomainSender fasfas
func (client MyObjectsClient) GetDomainSender(req *http.Request) (*http.Response, error) {
	return autorest.SendWithSender(client, req)
}

// GetDomainResponder fasdf
func (client MyObjectsClient) GetDomainResponder(resp *http.Response) (result DomainResponse, err error) {
	err = autorest.Respond(
		resp,
		client.ByInspecting(),
		azure.WithErrorUnlessStatusCode(http.StatusOK),
		autorest.ByUnmarshallingJSON(&result),
		autorest.ByClosing())
	return
}