armvisualstudio

package module
v0.6.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 24, 2023 License: MIT Imports: 12 Imported by: 1

README

Azure Visual Studio Module for Go

PkgGoDev

The armvisualstudio module provides operations for working with Azure Visual Studio.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Visual Studio module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Visual Studio. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Visual Studio module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armvisualstudio.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armvisualstudio.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewProjectsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Visual Studio label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountResource 

type AccountResource struct {
	// Resource location.
	Location *string

	// Resource properties.
	Properties map[string]*string

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Unique identifier of the resource.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

AccountResource - The response to an account resource GET request.

func (AccountResource) MarshalJSON 

func (a AccountResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccountResource.

func (*AccountResource) UnmarshalJSON added in v0.5.0 

func (a *AccountResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccountResource.

type AccountResourceListResult 

type AccountResourceListResult struct {
	// Array of resource details.
	Value []*AccountResource
}

AccountResourceListResult - The response to an account resource list GET request.

func (AccountResourceListResult) MarshalJSON 

func (a AccountResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccountResourceListResult.

func (*AccountResourceListResult) UnmarshalJSON added in v0.5.0 

func (a *AccountResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccountResourceListResult.

type AccountResourceRequest 

type AccountResourceRequest struct {
	// The account name.
	AccountName *string

	// The Azure instance location.
	Location *string

	// The type of the operation.
	OperationType *AccountResourceRequestOperationType

	// The custom properties of the resource.
	Properties map[string]*string

	// The custom tags of the resource.
	Tags map[string]*string
}

AccountResourceRequest - The body of a PUT request to modify a Visual Studio account resource.

func (AccountResourceRequest) MarshalJSON 

func (a AccountResourceRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccountResourceRequest.

func (*AccountResourceRequest) UnmarshalJSON added in v0.5.0 

func (a *AccountResourceRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccountResourceRequest.

type AccountResourceRequestOperationType 

type AccountResourceRequestOperationType string

AccountResourceRequestOperationType - The type of the operation. 

const (
	AccountResourceRequestOperationTypeCreate  AccountResourceRequestOperationType = "create"
	AccountResourceRequestOperationTypeLink    AccountResourceRequestOperationType = "link"
	AccountResourceRequestOperationTypeUnknown AccountResourceRequestOperationType = "unknown"
	AccountResourceRequestOperationTypeUpdate  AccountResourceRequestOperationType = "update"
)

func PossibleAccountResourceRequestOperationTypeValues 

func PossibleAccountResourceRequestOperationTypeValues() []AccountResourceRequestOperationType

PossibleAccountResourceRequestOperationTypeValues returns the possible values for the AccountResourceRequestOperationType const type.

type AccountTagRequest 

type AccountTagRequest struct {
	// The custom tags of the resource.
	Tags map[string]*string
}

AccountTagRequest - The body of a Patch request to add tags to a Visual Studio account resource.

func (AccountTagRequest) MarshalJSON 

func (a AccountTagRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccountTagRequest.

func (*AccountTagRequest) UnmarshalJSON added in v0.5.0 

func (a *AccountTagRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccountTagRequest.

type AccountsClient 

type AccountsClient struct {
	// contains filtered or unexported fields
}

AccountsClient contains the methods for the Accounts group. Don't use this type directly, use NewAccountsClient() instead.

func NewAccountsClient 

func NewAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AccountsClient, error)

NewAccountsClient creates a new instance of AccountsClient with the specified values.

  • subscriptionID - The Azure subscription identifier.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AccountsClient) CheckNameAvailability 

func (client *AccountsClient) CheckNameAvailability(ctx context.Context, body CheckNameAvailabilityParameter, options *AccountsClientCheckNameAvailabilityOptions) (AccountsClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Checks if the specified Visual Studio Team Services account name is available. Resource name can be either an account name or an account name and PUID. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • body - Parameters describing the name to check availability for.
  • options - AccountsClientCheckNameAvailabilityOptions contains the optional parameters for the AccountsClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/CheckNameAvailability.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().CheckNameAvailability(ctx, armvisualstudio.CheckNameAvailabilityParameter{
		ResourceName: to.Ptr("ExampleName"),
		ResourceType: to.Ptr("Account"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.CheckNameAvailabilityResult = armvisualstudio.CheckNameAvailabilityResult{
	// 	NameAvailable: to.Ptr(true),
	// }
}

Output:

func (*AccountsClient) CreateOrUpdate 

func (client *AccountsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, body AccountResourceRequest, options *AccountsClientCreateOrUpdateOptions) (AccountsClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates a Visual Studio Team Services account resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • resourceName - Name of the resource.
  • body - The request data.
  • options - AccountsClientCreateOrUpdateOptions contains the optional parameters for the AccountsClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/CreateResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().CreateOrUpdate(ctx, "VS-Example-Group", "Example", armvisualstudio.AccountResourceRequest{
		AccountName:   to.Ptr("Example"),
		Location:      to.Ptr("Central US"),
		OperationType: to.Ptr(armvisualstudio.AccountResourceRequestOperationTypeCreate),
		Properties:    map[string]*string{},
		Tags:          map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.AccountResource = armvisualstudio.AccountResource{
	// 	Name: to.Ptr("VS-Example-Group"),
	// 	Type: to.Ptr("Microsoft.VisualStudio/account"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/Example"),
	// 	Location: to.Ptr("Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: map[string]*string{
	// 		"AccountURL": to.Ptr(""),
	// 	},
	// }
}

Output:

func (*AccountsClient) Delete 

func (client *AccountsClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, options *AccountsClientDeleteOptions) (AccountsClientDeleteResponse, error)

Delete - Deletes a Visual Studio Team Services account resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • resourceName - Name of the resource.
  • options - AccountsClientDeleteOptions contains the optional parameters for the AccountsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/DeleteResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewAccountsClient().Delete(ctx, "VS-Example-Group", "Example", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*AccountsClient) Get 

func (client *AccountsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, options *AccountsClientGetOptions) (AccountsClientGetResponse, error)

Get - Gets the Visual Studio Team Services account resource details. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • resourceName - Name of the resource.
  • options - AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().Get(ctx, "VS-Example-Group", "Example", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.AccountResource = armvisualstudio.AccountResource{
	// 	Name: to.Ptr("VS-Example-Group"),
	// 	Type: to.Ptr("Microsoft.VisualStudio/account"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/Example"),
	// 	Location: to.Ptr("Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: map[string]*string{
	// 		"AccountURL": to.Ptr(""),
	// 	},
	// }
}

Output:

func (*AccountsClient) ListByResourceGroup 

func (client *AccountsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string, options *AccountsClientListByResourceGroupOptions) (AccountsClientListByResourceGroupResponse, error)

ListByResourceGroup - Gets all Visual Studio Team Services account resources under the resource group linked to the specified Azure subscription. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • options - AccountsClientListByResourceGroupOptions contains the optional parameters for the AccountsClient.ListByResourceGroup method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetResources_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().ListByResourceGroup(ctx, "VS-Example-Group", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.AccountResourceListResult = armvisualstudio.AccountResourceListResult{
	// 	Value: []*armvisualstudio.AccountResource{
	// 		{
	// 			Name: to.Ptr("VS-Example-Group"),
	// 			Type: to.Ptr("Microsoft.VisualStudio/account"),
	// 			ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/Example"),
	// 			Location: to.Ptr("Central US"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: map[string]*string{
	// 				"AccountURL": to.Ptr(""),
	// 			},
	// 	}},
	// }
}

Output:

func (*AccountsClient) Update 

func (client *AccountsClient) Update(ctx context.Context, resourceGroupName string, resourceName string, body AccountTagRequest, options *AccountsClientUpdateOptions) (AccountsClientUpdateResponse, error)

Update - Updates tags for Visual Studio Team Services account resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • resourceName - Name of the resource.
  • body - The request data.
  • options - AccountsClientUpdateOptions contains the optional parameters for the AccountsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/UpdateTags.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccountsClient().Update(ctx, "VS-Example-Group", "Example", armvisualstudio.AccountTagRequest{
		Tags: map[string]*string{
			"tag1": to.Ptr("value1"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.AccountResource = armvisualstudio.AccountResource{
	// 	Name: to.Ptr("VS-Example-Group"),
	// 	Type: to.Ptr("Microsoft.VisualStudio/account"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/Example"),
	// 	Location: to.Ptr("Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: map[string]*string{
	// 		"AccountURL": to.Ptr(""),
	// 	},
	// }
}

Output:

type AccountsClientCheckNameAvailabilityOptions added in v0.2.0 

type AccountsClientCheckNameAvailabilityOptions struct {
}

AccountsClientCheckNameAvailabilityOptions contains the optional parameters for the AccountsClient.CheckNameAvailability method.

type AccountsClientCheckNameAvailabilityResponse added in v0.2.0 

type AccountsClientCheckNameAvailabilityResponse struct {
	// The response to a name availability request.
	CheckNameAvailabilityResult
}

AccountsClientCheckNameAvailabilityResponse contains the response from method AccountsClient.CheckNameAvailability.

type AccountsClientCreateOrUpdateOptions added in v0.2.0 

type AccountsClientCreateOrUpdateOptions struct {
}

AccountsClientCreateOrUpdateOptions contains the optional parameters for the AccountsClient.CreateOrUpdate method.

type AccountsClientCreateOrUpdateResponse added in v0.2.0 

type AccountsClientCreateOrUpdateResponse struct {
	// The response to an account resource GET request.
	AccountResource
}

AccountsClientCreateOrUpdateResponse contains the response from method AccountsClient.CreateOrUpdate.

type AccountsClientDeleteOptions added in v0.2.0 

type AccountsClientDeleteOptions struct {
}

AccountsClientDeleteOptions contains the optional parameters for the AccountsClient.Delete method.

type AccountsClientDeleteResponse added in v0.2.0 

type AccountsClientDeleteResponse struct {
}

AccountsClientDeleteResponse contains the response from method AccountsClient.Delete.

type AccountsClientGetOptions added in v0.2.0 

type AccountsClientGetOptions struct {
}

AccountsClientGetOptions contains the optional parameters for the AccountsClient.Get method.

type AccountsClientGetResponse added in v0.2.0 

type AccountsClientGetResponse struct {
	// The response to an account resource GET request.
	AccountResource
}

AccountsClientGetResponse contains the response from method AccountsClient.Get.

type AccountsClientListByResourceGroupOptions added in v0.2.0 

type AccountsClientListByResourceGroupOptions struct {
}

AccountsClientListByResourceGroupOptions contains the optional parameters for the AccountsClient.ListByResourceGroup method.

type AccountsClientListByResourceGroupResponse added in v0.2.0 

type AccountsClientListByResourceGroupResponse struct {
	// The response to an account resource list GET request.
	AccountResourceListResult
}

AccountsClientListByResourceGroupResponse contains the response from method AccountsClient.ListByResourceGroup.

type AccountsClientUpdateOptions added in v0.2.0 

type AccountsClientUpdateOptions struct {
}

AccountsClientUpdateOptions contains the optional parameters for the AccountsClient.Update method.

type AccountsClientUpdateResponse added in v0.2.0 

type AccountsClientUpdateResponse struct {
	// The response to an account resource GET request.
	AccountResource
}

AccountsClientUpdateResponse contains the response from method AccountsClient.Update.

type CheckNameAvailabilityParameter 

type CheckNameAvailabilityParameter struct {
	// The name of the resource to check availability for.
	ResourceName *string

	// The type of resource to check availability for.
	ResourceType *string
}

CheckNameAvailabilityParameter - The body of a POST request to check name availability.

func (CheckNameAvailabilityParameter) MarshalJSON added in v0.5.0 

func (c CheckNameAvailabilityParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityParameter.

func (*CheckNameAvailabilityParameter) UnmarshalJSON added in v0.5.0 

func (c *CheckNameAvailabilityParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityParameter.

type CheckNameAvailabilityResult 

type CheckNameAvailabilityResult struct {
	// The message describing the detailed reason.
	Message *string

	// The value which indicates whether the provided name is available.
	NameAvailable *bool
}

CheckNameAvailabilityResult - The response to a name availability request.

func (CheckNameAvailabilityResult) MarshalJSON added in v0.5.0 

func (c CheckNameAvailabilityResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityResult.

func (*CheckNameAvailabilityResult) UnmarshalJSON added in v0.5.0 

func (c *CheckNameAvailabilityResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityResult.

type ClientFactory added in v0.5.0 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory added in v0.5.0 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - The Azure subscription identifier.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAccountsClient added in v0.5.0 

func (c *ClientFactory) NewAccountsClient() *AccountsClient

NewAccountsClient creates a new instance of AccountsClient.

func (*ClientFactory) NewExtensionsClient added in v0.5.0 

func (c *ClientFactory) NewExtensionsClient() *ExtensionsClient

NewExtensionsClient creates a new instance of ExtensionsClient.

func (*ClientFactory) NewOperationsClient added in v0.5.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewProjectsClient added in v0.5.0 

func (c *ClientFactory) NewProjectsClient() *ProjectsClient

NewProjectsClient creates a new instance of ProjectsClient.

type ExtensionResource 

type ExtensionResource struct {
	// Resource location.
	Location *string

	// The extension plan that was purchased.
	Plan *ExtensionResourcePlan

	// Resource properties.
	Properties map[string]*string

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Unique identifier of the resource.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ExtensionResource - The response to an extension resource GET request.

func (ExtensionResource) MarshalJSON 

func (e ExtensionResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExtensionResource.

func (*ExtensionResource) UnmarshalJSON added in v0.5.0 

func (e *ExtensionResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionResource.

type ExtensionResourceListResult 

type ExtensionResourceListResult struct {
	// Array of extension resource details.
	Value []*ExtensionResource
}

ExtensionResourceListResult - The response to an extension resource list GET request.

func (ExtensionResourceListResult) MarshalJSON 

func (e ExtensionResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExtensionResourceListResult.

func (*ExtensionResourceListResult) UnmarshalJSON added in v0.5.0 

func (e *ExtensionResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionResourceListResult.

type ExtensionResourcePlan 

type ExtensionResourcePlan struct {
	// Name of the plan.
	Name *string

	// Product name.
	Product *string

	// Optional: the promotion code associated with the plan.
	PromotionCode *string

	// Name of the extension publisher.
	Publisher *string

	// A string that uniquely identifies the plan version.
	Version *string
}

ExtensionResourcePlan - Plan data for an extension resource.

func (ExtensionResourcePlan) MarshalJSON added in v0.5.0 

func (e ExtensionResourcePlan) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExtensionResourcePlan.

func (*ExtensionResourcePlan) UnmarshalJSON added in v0.5.0 

func (e *ExtensionResourcePlan) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionResourcePlan.

type ExtensionResourceRequest 

type ExtensionResourceRequest struct {
	// The Azure region of the Visual Studio account associated with this request (i.e 'southcentralus'.)
	Location *string

	// Extended information about the plan being purchased for this extension resource.
	Plan *ExtensionResourcePlan

	// A dictionary of extended properties. This property is currently unused.
	Properties map[string]*string

	// A dictionary of user-defined tags to be stored with the extension resource.
	Tags map[string]*string
}

ExtensionResourceRequest - The body of an extension resource PUT request.

func (ExtensionResourceRequest) MarshalJSON 

func (e ExtensionResourceRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExtensionResourceRequest.

func (*ExtensionResourceRequest) UnmarshalJSON added in v0.5.0 

func (e *ExtensionResourceRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionResourceRequest.

type ExtensionsClient 

type ExtensionsClient struct {
	// contains filtered or unexported fields
}

ExtensionsClient contains the methods for the Extensions group. Don't use this type directly, use NewExtensionsClient() instead.

func NewExtensionsClient 

func NewExtensionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ExtensionsClient, error)

NewExtensionsClient creates a new instance of ExtensionsClient with the specified values.

  • subscriptionID - The Azure subscription identifier.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ExtensionsClient) Create 

func (client *ExtensionsClient) Create(ctx context.Context, resourceGroupName string, accountResourceName string, extensionResourceName string, body ExtensionResourceRequest, options *ExtensionsClientCreateOptions) (ExtensionsClientCreateResponse, error)

Create - Registers the extension with a Visual Studio Team Services account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • accountResourceName - The name of the Visual Studio Team Services account resource.
  • extensionResourceName - The name of the extension.
  • body - An object containing additional information related to the extension request.
  • options - ExtensionsClientCreateOptions contains the optional parameters for the ExtensionsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/CreateExtensionResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewExtensionsClient().Create(ctx, "VS-Example-Group", "ExampleAccount", "ms.example", armvisualstudio.ExtensionResourceRequest{
		Location: to.Ptr("Central US"),
		Plan: &armvisualstudio.ExtensionResourcePlan{
			Name:          to.Ptr("ExamplePlan"),
			Product:       to.Ptr("ExampleExtensionName"),
			PromotionCode: to.Ptr(""),
			Publisher:     to.Ptr("ExampleExtensionPublisher"),
			Version:       to.Ptr("1.0"),
		},
		Properties: map[string]*string{},
		Tags:       map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ExtensionResource = armvisualstudio.ExtensionResource{
	// 	Name: to.Ptr("ms.example"),
	// 	Type: to.Ptr("Microsoft.VisualStudio/account/extension"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/ExampleAccount/extension/ms.example"),
	// 	Location: to.Ptr("Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Plan: &armvisualstudio.ExtensionResourcePlan{
	// 		Name: to.Ptr("ExamplePlan"),
	// 		Product: to.Ptr("ExampleExtensionName"),
	// 		PromotionCode: to.Ptr(""),
	// 		Publisher: to.Ptr("ExampleExtensionPublisher"),
	// 		Version: to.Ptr("1.0"),
	// 	},
	// 	Properties: map[string]*string{
	// 	},
	// }
}

Output:

func (*ExtensionsClient) Delete 

func (client *ExtensionsClient) Delete(ctx context.Context, resourceGroupName string, accountResourceName string, extensionResourceName string, options *ExtensionsClientDeleteOptions) (ExtensionsClientDeleteResponse, error)

Delete - Removes an extension resource registration for a Visual Studio Team Services account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • accountResourceName - The name of the Visual Studio Team Services account resource.
  • extensionResourceName - The name of the extension.
  • options - ExtensionsClientDeleteOptions contains the optional parameters for the ExtensionsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/DeleteExtensionResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewExtensionsClient().Delete(ctx, "VS-Example-Group", "Example", "ms.example", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ExtensionsClient) Get 

func (client *ExtensionsClient) Get(ctx context.Context, resourceGroupName string, accountResourceName string, extensionResourceName string, options *ExtensionsClientGetOptions) (ExtensionsClientGetResponse, error)

Get - Gets the details of an extension associated with a Visual Studio Team Services account resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • accountResourceName - The name of the Visual Studio Team Services account resource.
  • extensionResourceName - The name of the extension.
  • options - ExtensionsClientGetOptions contains the optional parameters for the ExtensionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetExtensionResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewExtensionsClient().Get(ctx, "VS-Example-Group", "ExampleAccount", "ms.example", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ExtensionResource = armvisualstudio.ExtensionResource{
	// 	Name: to.Ptr("ms.example"),
	// 	Type: to.Ptr("Microsoft.VisualStudio/account/extension"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/ExampleAccount/extension/ms.example"),
	// 	Location: to.Ptr("Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Plan: &armvisualstudio.ExtensionResourcePlan{
	// 		Name: to.Ptr("ExamplePlan"),
	// 		Product: to.Ptr("ExampleExtensionName"),
	// 		PromotionCode: to.Ptr(""),
	// 		Publisher: to.Ptr("ExampleExtensionPublisher"),
	// 		Version: to.Ptr("1.0"),
	// 	},
	// 	Properties: map[string]*string{
	// 	},
	// }
}

Output:

func (*ExtensionsClient) ListByAccount 

func (client *ExtensionsClient) ListByAccount(ctx context.Context, resourceGroupName string, accountResourceName string, options *ExtensionsClientListByAccountOptions) (ExtensionsClientListByAccountResponse, error)

ListByAccount - Gets the details of the extension resources created within the resource group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • accountResourceName - The name of the Visual Studio Team Services account resource.
  • options - ExtensionsClientListByAccountOptions contains the optional parameters for the ExtensionsClient.ListByAccount method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetExtensionResources_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewExtensionsClient().ListByAccount(ctx, "VS-Example-Group", "ExampleAccount", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ExtensionResourceListResult = armvisualstudio.ExtensionResourceListResult{
	// 	Value: []*armvisualstudio.ExtensionResource{
	// 		{
	// 			Name: to.Ptr("ms.example"),
	// 			Type: to.Ptr("Microsoft.VisualStudio/account/extension"),
	// 			ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/ExampleAccount/extension/ms.example"),
	// 			Location: to.Ptr("Central US"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Plan: &armvisualstudio.ExtensionResourcePlan{
	// 				Name: to.Ptr("ExamplePlan"),
	// 				Product: to.Ptr("ExampleExtensionName"),
	// 				PromotionCode: to.Ptr(""),
	// 				Publisher: to.Ptr("ExampleExtensionPublisher"),
	// 				Version: to.Ptr("1.0"),
	// 			},
	// 			Properties: map[string]*string{
	// 			},
	// 	}},
	// }
}

Output:

func (*ExtensionsClient) Update 

func (client *ExtensionsClient) Update(ctx context.Context, resourceGroupName string, accountResourceName string, extensionResourceName string, body ExtensionResourceRequest, options *ExtensionsClientUpdateOptions) (ExtensionsClientUpdateResponse, error)

Update - Updates an existing extension registration for the Visual Studio Team Services account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • accountResourceName - The name of the Visual Studio Team Services account resource.
  • extensionResourceName - The name of the extension.
  • body - An object containing additional information related to the extension request.
  • options - ExtensionsClientUpdateOptions contains the optional parameters for the ExtensionsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/UpdateExtensionResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewExtensionsClient().Update(ctx, "VS-Example-Group", "ExampleAccount", "Example", armvisualstudio.ExtensionResourceRequest{
		Location: to.Ptr("Central US"),
		Plan: &armvisualstudio.ExtensionResourcePlan{
			Name:          to.Ptr("ExamplePlan"),
			Product:       to.Ptr("ExampleExtensionName"),
			PromotionCode: to.Ptr(""),
			Publisher:     to.Ptr("ExampleExtensionPublisher"),
			Version:       to.Ptr("1.0"),
		},
		Properties: map[string]*string{},
		Tags:       map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ExtensionResource = armvisualstudio.ExtensionResource{
	// 	Name: to.Ptr("ms.example"),
	// 	Type: to.Ptr("Microsoft.VisualStudio/account/extension"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/ExampleAccount/extension/ms.example"),
	// 	Location: to.Ptr("Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Plan: &armvisualstudio.ExtensionResourcePlan{
	// 		Name: to.Ptr("ExamplePlan"),
	// 		Product: to.Ptr("ExampleExtensionName"),
	// 		PromotionCode: to.Ptr(""),
	// 		Publisher: to.Ptr("ExampleExtensionPublisher"),
	// 		Version: to.Ptr("1.0"),
	// 	},
	// 	Properties: map[string]*string{
	// 	},
	// }
}

Output:

type ExtensionsClientCreateOptions added in v0.2.0 

type ExtensionsClientCreateOptions struct {
}

ExtensionsClientCreateOptions contains the optional parameters for the ExtensionsClient.Create method.

type ExtensionsClientCreateResponse added in v0.2.0 

type ExtensionsClientCreateResponse struct {
	// The response to an extension resource GET request.
	ExtensionResource
}

ExtensionsClientCreateResponse contains the response from method ExtensionsClient.Create.

type ExtensionsClientDeleteOptions added in v0.2.0 

type ExtensionsClientDeleteOptions struct {
}

ExtensionsClientDeleteOptions contains the optional parameters for the ExtensionsClient.Delete method.

type ExtensionsClientDeleteResponse added in v0.2.0 

type ExtensionsClientDeleteResponse struct {
}

ExtensionsClientDeleteResponse contains the response from method ExtensionsClient.Delete.

type ExtensionsClientGetOptions added in v0.2.0 

type ExtensionsClientGetOptions struct {
}

ExtensionsClientGetOptions contains the optional parameters for the ExtensionsClient.Get method.

type ExtensionsClientGetResponse added in v0.2.0 

type ExtensionsClientGetResponse struct {
	// The response to an extension resource GET request.
	ExtensionResource
}

ExtensionsClientGetResponse contains the response from method ExtensionsClient.Get.

type ExtensionsClientListByAccountOptions added in v0.2.0 

type ExtensionsClientListByAccountOptions struct {
}

ExtensionsClientListByAccountOptions contains the optional parameters for the ExtensionsClient.ListByAccount method.

type ExtensionsClientListByAccountResponse added in v0.2.0 

type ExtensionsClientListByAccountResponse struct {
	// The response to an extension resource list GET request.
	ExtensionResourceListResult
}

ExtensionsClientListByAccountResponse contains the response from method ExtensionsClient.ListByAccount.

type ExtensionsClientUpdateOptions added in v0.2.0 

type ExtensionsClientUpdateOptions struct {
}

ExtensionsClientUpdateOptions contains the optional parameters for the ExtensionsClient.Update method.

type ExtensionsClientUpdateResponse added in v0.2.0 

type ExtensionsClientUpdateResponse struct {
	// The response to an extension resource GET request.
	ExtensionResource
}

ExtensionsClientUpdateResponse contains the response from method ExtensionsClient.Update.

type Operation 

type Operation struct {
	// The properties of the resource operation.
	Display *OperationProperties

	// The name of the resource operation.
	Name *string
}

Operation - Properties of an operation supported by the resource provider.

func (Operation) MarshalJSON added in v0.5.0 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON added in v0.5.0 

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationListResult 

type OperationListResult struct {
	// A list of operations supported by a resource provider.
	Value []*Operation
}

OperationListResult - Container for a list of operations supported by a resource provider.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON added in v0.5.0 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationProperties 

type OperationProperties struct {
	// The description of the resource operation.
	Description *string

	// The operation name.
	Operation *string

	// The provider name.
	Provider *string

	// The resource name.
	Resource *string
}

OperationProperties - Properties of an operation supported by the resource provider.

func (OperationProperties) MarshalJSON added in v0.5.0 

func (o OperationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationProperties.

func (*OperationProperties) UnmarshalJSON added in v0.5.0 

func (o *OperationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationProperties.

type OperationsClient 

type OperationsClient struct {
	// contains filtered or unexported fields
}

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) List 

func (client *OperationsClient) List(ctx context.Context, options *OperationsClientListOptions) (OperationsClientListResponse, error)

List - Gets the details of all operations possible on the Microsoft.VisualStudio resource provider. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOperationsClient().List(ctx, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OperationListResult = armvisualstudio.OperationListResult{
	// 	Value: []*armvisualstudio.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Account/Write"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Set Account"),
	// 				Operation: to.Ptr("Creates or updates the Account"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Account"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Account/Delete"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Delete Account"),
	// 				Operation: to.Ptr("Deletes the Account"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Account"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Account/Read"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Read Account"),
	// 				Operation: to.Ptr("Reads the Account"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Account"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Project/Write"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Set Project"),
	// 				Operation: to.Ptr("Creates or updates the Project"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Project"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Project/Delete"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Delete Project"),
	// 				Operation: to.Ptr("Deletes the Project"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Project"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Project/Read"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Read Project"),
	// 				Operation: to.Ptr("Reads the Project"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Project"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Extension/Write"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Set Extension"),
	// 				Operation: to.Ptr("Creates or updates the Extension"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Extension"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Extension/Delete"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Delete Extension"),
	// 				Operation: to.Ptr("Deletes the Extension"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Extension"),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.VisualStudio/Extension/Read"),
	// 			Display: &armvisualstudio.OperationProperties{
	// 				Description: to.Ptr("Read Extension"),
	// 				Operation: to.Ptr("Reads the Extension"),
	// 				Provider: to.Ptr("Visual Studio"),
	// 				Resource: to.Ptr("Extension"),
	// 			},
	// 	}},
	// }
}

Output:

type OperationsClientListOptions added in v0.2.0 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.

type OperationsClientListResponse added in v0.2.0 

type OperationsClientListResponse struct {
	// Container for a list of operations supported by a resource provider.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.List.

type ProjectResource 

type ProjectResource struct {
	// Resource location.
	Location *string

	// Key/value pair of resource properties.
	Properties map[string]*string

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Unique identifier of the resource.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

ProjectResource - A Visual Studio Team Services project resource.

func (ProjectResource) MarshalJSON 

func (p ProjectResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProjectResource.

func (*ProjectResource) UnmarshalJSON added in v0.5.0 

func (p *ProjectResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProjectResource.

type ProjectResourceListResult 

type ProjectResourceListResult struct {
	// List of project resource details.
	Value []*ProjectResource
}

ProjectResourceListResult - The response to a request to list Team Services project resources in a resource group/account.

func (ProjectResourceListResult) MarshalJSON 

func (p ProjectResourceListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProjectResourceListResult.

func (*ProjectResourceListResult) UnmarshalJSON added in v0.5.0 

func (p *ProjectResourceListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProjectResourceListResult.

type ProjectsClient 

type ProjectsClient struct {
	// contains filtered or unexported fields
}

ProjectsClient contains the methods for the Projects group. Don't use this type directly, use NewProjectsClient() instead.

func NewProjectsClient 

func NewProjectsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ProjectsClient, error)

NewProjectsClient creates a new instance of ProjectsClient with the specified values.

  • subscriptionID - The Azure subscription identifier.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ProjectsClient) BeginCreate 

func (client *ProjectsClient) BeginCreate(ctx context.Context, resourceGroupName string, rootResourceName string, resourceName string, body ProjectResource, options *ProjectsClientBeginCreateOptions) (*runtime.Poller[ProjectsClientCreateResponse], error)

BeginCreate - Creates a Team Services project in the collection with the specified name. 'VersionControlOption' and 'ProcessTemplateId' must be specified in the resource properties. Valid values for VersionControlOption: Git, Tfvc. Valid values for ProcessTemplateId: 6B724908-EF14-45CF-84F8-768B5384DA45, ADCC42AB-9882-485E-A3ED-7678F01F66BC, 27450541-8E31-4150-9947-DC59F998FC01 (these IDs correspond to Scrum, Agile, and CMMI process templates). If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • rootResourceName - Name of the Team Services account.
  • resourceName - Name of the Team Services project.
  • body - The request data.
  • options - ProjectsClientBeginCreateOptions contains the optional parameters for the ProjectsClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/CreateProjectResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewProjectsClient().BeginCreate(ctx, "VS-Example-Group", "ExampleAccount", "ExampleProject", armvisualstudio.ProjectResource{
		Name:     to.Ptr("ExampleProject"),
		Type:     to.Ptr("Microsoft.VisualStudio/account/project"),
		ID:       to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/ExampleAccount/project/ExampleProject"),
		Location: to.Ptr("Central US"),
		Tags:     map[string]*string{},
		Properties: map[string]*string{
			"ProcessTemplateId":    to.Ptr("6B724908-EF14-45CF-84F8-768B5384DA45"),
			"VersionControlOption": to.Ptr("Git"),
		},
	}, &armvisualstudio.ProjectsClientBeginCreateOptions{Validating: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ProjectResource = armvisualstudio.ProjectResource{
	// 	Name: to.Ptr("ExampleProject"),
	// 	Type: to.Ptr("microsoft.visualstudio/account/project"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/microsoft.visualstudio/account/ExampleAccount/project/ExampleProject"),
	// 	Location: to.Ptr("North Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: map[string]*string{
	// 		"AzureResourceName": to.Ptr("ExampleProject"),
	// 		"TfsUniqueIdentifier": to.Ptr("vstfs:///Classification/TeamProject/7a4e6ba5-35bf-4667-86a4-9b598a88fa25"),
	// 	},
	// }
}

Output:

func (*ProjectsClient) Get 

func (client *ProjectsClient) Get(ctx context.Context, resourceGroupName string, rootResourceName string, resourceName string, options *ProjectsClientGetOptions) (ProjectsClientGetResponse, error)

Get - Gets the details of a Team Services project resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • rootResourceName - Name of the Team Services account.
  • resourceName - Name of the Team Services project.
  • options - ProjectsClientGetOptions contains the optional parameters for the ProjectsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetProjectResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewProjectsClient().Get(ctx, "VS-Example-Group", "ExampleAccount", "ExampleProject", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ProjectResource = armvisualstudio.ProjectResource{
	// 	Name: to.Ptr("ExampleProject"),
	// 	Type: to.Ptr("microsoft.visualstudio/account/project"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/microsoft.visualstudio/account/ExampleAccount/project/ExampleProject"),
	// 	Location: to.Ptr("North Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: map[string]*string{
	// 		"AzureResourceName": to.Ptr("ExampleProject"),
	// 		"TfsUniqueIdentifier": to.Ptr("vstfs:///Classification/TeamProject/7a4e6ba5-35bf-4667-86a4-9b598a88fa25"),
	// 	},
	// }
}

Output:

func (*ProjectsClient) GetJobStatus 

func (client *ProjectsClient) GetJobStatus(ctx context.Context, resourceGroupName string, rootResourceName string, resourceName string, subContainerName string, operation string, options *ProjectsClientGetJobStatusOptions) (ProjectsClientGetJobStatusResponse, error)

GetJobStatus - Gets the status of the project resource creation job. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • rootResourceName - Name of the Team Services account.
  • resourceName - Name of the Team Services project.
  • subContainerName - This parameter should be set to the resourceName.
  • operation - The operation type. The only supported value is 'put'.
  • options - ProjectsClientGetJobStatusOptions contains the optional parameters for the ProjectsClient.GetJobStatus method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetProjectJobStatus.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewProjectsClient().GetJobStatus(ctx, "VS-Example-Group", "ExampleAccount", "ExampleProject", "ExampleProject", "put", &armvisualstudio.ProjectsClientGetJobStatusOptions{JobID: to.Ptr("126167d2-d710-4b5d-80a8-a1d58717142d")})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ProjectResource = armvisualstudio.ProjectResource{
	// 	Name: to.Ptr("ExampleProject"),
	// 	Type: to.Ptr("microsoft.visualstudio/account/project"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/microsoft.visualstudio/account/ExampleAccount/project/ExampleProject"),
	// 	Location: to.Ptr("North Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: map[string]*string{
	// 		"AzureResourceName": to.Ptr("ExampleProject"),
	// 		"TfsUniqueIdentifier": to.Ptr("vstfs:///Classification/TeamProject/7a4e6ba5-35bf-4667-86a4-9b598a88fa25"),
	// 	},
	// }
}

Output:

func (*ProjectsClient) ListByResourceGroup 

func (client *ProjectsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string, rootResourceName string, options *ProjectsClientListByResourceGroupOptions) (ProjectsClientListByResourceGroupResponse, error)

ListByResourceGroup - Gets all Visual Studio Team Services project resources created in the specified Team Services account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • rootResourceName - Name of the Team Services account.
  • options - ProjectsClientListByResourceGroupOptions contains the optional parameters for the ProjectsClient.ListByResourceGroup method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/GetProjectResources_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewProjectsClient().ListByResourceGroup(ctx, "VS-Example-Group", "ExampleAccount", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ProjectResourceListResult = armvisualstudio.ProjectResourceListResult{
	// 	Value: []*armvisualstudio.ProjectResource{
	// 		{
	// 			Name: to.Ptr("ExampleProject"),
	// 			Type: to.Ptr("Microsoft.VisualStudio/account/project"),
	// 			ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/Microsoft.VisualStudio/account/ExampleAccount/project/ExampleProject"),
	// 			Location: to.Ptr("Central US"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: map[string]*string{
	// 				"AzureResourceName": to.Ptr("ExampleProject"),
	// 				"TfsUniqueIdentifier": to.Ptr("vstfs:///Classification/TeamProject/d921d601-0600-4e45-8600-3914ffc8811a"),
	// 			},
	// 	}},
	// }
}

Output:

func (*ProjectsClient) Update 

func (client *ProjectsClient) Update(ctx context.Context, resourceGroupName string, rootResourceName string, resourceName string, body ProjectResource, options *ProjectsClientUpdateOptions) (ProjectsClientUpdateResponse, error)

Update - Updates the tags of the specified Team Services project. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2014-04-01-preview

  • resourceGroupName - Name of the resource group within the Azure subscription.
  • rootResourceName - Name of the Team Services account.
  • resourceName - Name of the Team Services project.
  • body - The request data.
  • options - ProjectsClientUpdateOptions contains the optional parameters for the ProjectsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/d55b8005f05b040b852c15e74a0f3e36494a15e1/specification/visualstudio/resource-manager/Microsoft.VisualStudio/preview/2014-04-01-preview/examples/UpdateProjectResource.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/visualstudio/armvisualstudio"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armvisualstudio.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewProjectsClient().Update(ctx, "VS-Example-Group", "ExampleAccount", "ExampleProject", armvisualstudio.ProjectResource{
		Name:       to.Ptr("ms.example"),
		Type:       to.Ptr("Microsoft.VisualStudio/account/extension"),
		ID:         to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/microsoft.visualstudio/account/ExampleAccount/project/ExampleProject"),
		Location:   to.Ptr("Central US"),
		Tags:       map[string]*string{},
		Properties: map[string]*string{},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ProjectResource = armvisualstudio.ProjectResource{
	// 	Name: to.Ptr("ExampleProject"),
	// 	Type: to.Ptr("microsoft.visualstudio/account/project"),
	// 	ID: to.Ptr("/subscriptions/0de7f055-dbea-498d-8e9e-da287eedca90/resourceGroups/VS-Example-Group/providers/microsoft.visualstudio/account/ExampleAccount/project/ExampleProject"),
	// 	Location: to.Ptr("North Central US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: map[string]*string{
	// 		"AzureResourceName": to.Ptr("ExampleProject"),
	// 		"TfsUniqueIdentifier": to.Ptr("vstfs:///Classification/TeamProject/7a4e6ba5-35bf-4667-86a4-9b598a88fa25"),
	// 	},
	// }
}

Output:

type ProjectsClientBeginCreateOptions added in v0.2.0 

type ProjectsClientBeginCreateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string

	// This parameter is ignored and should be set to an empty string.
	Validating *string
}

ProjectsClientBeginCreateOptions contains the optional parameters for the ProjectsClient.BeginCreate method.

type ProjectsClientCreateResponse added in v0.2.0 

type ProjectsClientCreateResponse struct {
	// A Visual Studio Team Services project resource.
	ProjectResource
}

ProjectsClientCreateResponse contains the response from method ProjectsClient.BeginCreate.

type ProjectsClientGetJobStatusOptions added in v0.2.0 

type ProjectsClientGetJobStatusOptions struct {
	// The job identifier.
	JobID *string
}

ProjectsClientGetJobStatusOptions contains the optional parameters for the ProjectsClient.GetJobStatus method.

type ProjectsClientGetJobStatusResponse added in v0.2.0 

type ProjectsClientGetJobStatusResponse struct {
	// A Visual Studio Team Services project resource.
	ProjectResource
}

ProjectsClientGetJobStatusResponse contains the response from method ProjectsClient.GetJobStatus.

type ProjectsClientGetOptions added in v0.2.0 

type ProjectsClientGetOptions struct {
}

ProjectsClientGetOptions contains the optional parameters for the ProjectsClient.Get method.

type ProjectsClientGetResponse added in v0.2.0 

type ProjectsClientGetResponse struct {
	// A Visual Studio Team Services project resource.
	ProjectResource
}

ProjectsClientGetResponse contains the response from method ProjectsClient.Get.

type ProjectsClientListByResourceGroupOptions added in v0.2.0 

type ProjectsClientListByResourceGroupOptions struct {
}

ProjectsClientListByResourceGroupOptions contains the optional parameters for the ProjectsClient.ListByResourceGroup method.

type ProjectsClientListByResourceGroupResponse added in v0.2.0 

type ProjectsClientListByResourceGroupResponse struct {
	// The response to a request to list Team Services project resources in a resource group/account.
	ProjectResourceListResult
}

ProjectsClientListByResourceGroupResponse contains the response from method ProjectsClient.ListByResourceGroup.

type ProjectsClientUpdateOptions added in v0.2.0 

type ProjectsClientUpdateOptions struct {
}

ProjectsClientUpdateOptions contains the optional parameters for the ProjectsClient.Update method.

type ProjectsClientUpdateResponse added in v0.2.0 

type ProjectsClientUpdateResponse struct {
	// A Visual Studio Team Services project resource.
	ProjectResource
}

ProjectsClientUpdateResponse contains the response from method ProjectsClient.Update.

type Resource 

type Resource struct {
	// Resource location.
	Location *string

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Unique identifier of the resource.
	ID *string

	// READ-ONLY; Resource name.
	Name *string

	// READ-ONLY; Resource type.
	Type *string
}

Resource - A generic Azure Resource Manager resource.

func (Resource) MarshalJSON 

func (r Resource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON added in v0.5.0 

func (r *Resource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.