Azure Mgmt Apicenter Dotnet

using Azure.Identity;using Azure.ResourceManager;using Azure.ResourceManager.ApiCenter;
// Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>var credential = new DefaultAzureCredential(    DefaultAzureCredential.DefaultEnvironmentVariableName);// Or use a specific credential directly in production:// See https://learn.microsoft.com/dotnet/api/overview/azure/identity-readme?view=azure-dotnet#credential-classes// var credential = new ManagedIdentityCredential();ArmClient client = new ArmClient(credential);

using Azure.ResourceManager.ApiCenter;using Azure.ResourceManager.ApiCenter.Models;
ResourceGroupResource resourceGroup = await client    .GetDefaultSubscriptionAsync()    .Result    .GetResourceGroupAsync("my-resource-group");
ApiCenterServiceCollection services = resourceGroup.GetApiCenterServices();
ApiCenterServiceData data = new ApiCenterServiceData(AzureLocation.EastUS){    Identity = new ManagedServiceIdentity(ManagedServiceIdentityType.SystemAssigned)};
ArmOperation<ApiCenterServiceResource> operation = await services    .CreateOrUpdateAsync(WaitUntil.Completed, "my-api-center", data);
ApiCenterServiceResource service = operation.Value;

ApiCenterWorkspaceCollection workspaces = service.GetApiCenterWorkspaces();
ApiCenterWorkspaceData workspaceData = new ApiCenterWorkspaceData{    Title = "Engineering APIs",    Description = "APIs owned by the engineering team"};
ArmOperation<ApiCenterWorkspaceResource> operation = await workspaces    .CreateOrUpdateAsync(WaitUntil.Completed, "engineering", workspaceData);
ApiCenterWorkspaceResource workspace = operation.Value;

ApiCenterApiCollection apis = workspace.GetApiCenterApis();
ApiCenterApiData apiData = new ApiCenterApiData{    Title = "Orders API",    Description = "API for managing customer orders",    Kind = ApiKind.Rest,    LifecycleStage = ApiLifecycleStage.Production,    TermsOfService = new ApiTermsOfService    {        Uri = new Uri("https://example.com/terms")    },    ExternalDocumentation =     {        new ApiExternalDocumentation        {            Title = "Documentation",            Uri = new Uri("https://docs.example.com/orders")        }    },    Contacts =    {        new ApiContact        {            Name = "API Support",            Email = "[email protected]"        }    }};
// Add custom metadataapiData.CustomProperties = BinaryData.FromObjectAsJson(new{    team = "orders-team",    costCenter = "CC-1234"});
ArmOperation<ApiCenterApiResource> operation = await apis    .CreateOrUpdateAsync(WaitUntil.Completed, "orders-api", apiData);
ApiCenterApiResource api = operation.Value;

ApiCenterApiVersionCollection versions = api.GetApiCenterApiVersions();
ApiCenterApiVersionData versionData = new ApiCenterApiVersionData{    Title = "v1.0.0",    LifecycleStage = ApiLifecycleStage.Production};
ArmOperation<ApiCenterApiVersionResource> operation = await versions    .CreateOrUpdateAsync(WaitUntil.Completed, "v1-0-0", versionData);
ApiCenterApiVersionResource version = operation.Value;

ApiCenterApiDefinitionCollection definitions = version.GetApiCenterApiDefinitions();
ApiCenterApiDefinitionData definitionData = new ApiCenterApiDefinitionData{    Title = "OpenAPI Specification",    Description = "Orders API OpenAPI 3.0 definition"};
ArmOperation<ApiCenterApiDefinitionResource> operation = await definitions    .CreateOrUpdateAsync(WaitUntil.Completed, "openapi", definitionData);
ApiCenterApiDefinitionResource definition = operation.Value;
// Import specificationstring openApiSpec = await File.ReadAllTextAsync("orders-api.yaml");
ApiSpecImportContent importContent = new ApiSpecImportContent{    Format = ApiSpecImportSourceFormat.Inline,    Value = openApiSpec,    Specification = new ApiSpecImportSpecification    {        Name = "openapi",        Version = "3.0.1"    }};
await definition.ImportSpecificationAsync(WaitUntil.Completed, importContent);

ApiCenterApiDefinitionResource definition = await client    .GetApiCenterApiDefinitionResource(definitionResourceId)    .GetAsync();
ArmOperation<ApiSpecExportResult> operation = await definition    .ExportSpecificationAsync(WaitUntil.Completed);
ApiSpecExportResult result = operation.Value;
// result.Format - e.g., "inline"// result.Value - the specification content

ApiCenterEnvironmentCollection environments = workspace.GetApiCenterEnvironments();
ApiCenterEnvironmentData envData = new ApiCenterEnvironmentData{    Title = "Production",    Description = "Production environment",    Kind = ApiCenterEnvironmentKind.Production,    Server = new ApiCenterEnvironmentServer    {        ManagementPortalUris = { new Uri("https://portal.azure.com") }    },    Onboarding = new EnvironmentOnboardingModel    {        Instructions = "Contact platform team for access",        DeveloperPortalUris = { new Uri("https://developer.example.com") }    }};
ArmOperation<ApiCenterEnvironmentResource> operation = await environments    .CreateOrUpdateAsync(WaitUntil.Completed, "production", envData);

ApiCenterDeploymentCollection deployments = workspace.GetApiCenterDeployments();
// Get environment resource IDResourceIdentifier envResourceId = ApiCenterEnvironmentResource.CreateResourceIdentifier(    subscriptionId, resourceGroupName, serviceName, workspaceName, "production");
// Get API definition resource IDResourceIdentifier definitionResourceId = ApiCenterApiDefinitionResource.CreateResourceIdentifier(    subscriptionId, resourceGroupName, serviceName, workspaceName,     "orders-api", "v1-0-0", "openapi");
ApiCenterDeploymentData deploymentData = new ApiCenterDeploymentData{    Title = "Orders API - Production",    Description = "Production deployment of Orders API v1.0.0",    EnvironmentId = envResourceId,    DefinitionId = definitionResourceId,    State = ApiCenterDeploymentState.Active,    Server = new ApiCenterDeploymentServer    {        RuntimeUris = { new Uri("https://api.example.com/orders") }    }};
ArmOperation<ApiCenterDeploymentResource> operation = await deployments    .CreateOrUpdateAsync(WaitUntil.Completed, "orders-api-prod", deploymentData);

ApiCenterMetadataSchemaCollection schemas = service.GetApiCenterMetadataSchemas();
string jsonSchema = """{    "type": "object",    "properties": {        "team": {            "type": "string",            "title": "Owning Team"        },        "costCenter": {            "type": "string",            "title": "Cost Center"        },        "dataClassification": {            "type": "string",            "enum": ["public", "internal", "confidential"],            "title": "Data Classification"        }    },    "required": ["team"]}""";
ApiCenterMetadataSchemaData schemaData = new ApiCenterMetadataSchemaData{    Schema = jsonSchema,    AssignedTo =    {        new MetadataAssignment        {            Entity = MetadataAssignmentEntity.Api,            Required = true        }    }};
ArmOperation<ApiCenterMetadataSchemaResource> operation = await schemas    .CreateOrUpdateAsync(WaitUntil.Completed, "api-metadata", schemaData);

// List all APIs in a workspaceApiCenterWorkspaceResource workspace = await client    .GetApiCenterWorkspaceResource(workspaceResourceId)    .GetAsync();
await foreach (ApiCenterApiResource api in workspace.GetApiCenterApis()){    Console.WriteLine($"API: {api.Data.Title}");    Console.WriteLine($"  Kind: {api.Data.Kind}");    Console.WriteLine($"  Stage: {api.Data.LifecycleStage}");        // List versions    await foreach (ApiCenterApiVersionResource version in api.GetApiCenterApiVersions())    {        Console.WriteLine($"  Version: {version.Data.Title}");    }}
// List environmentsawait foreach (ApiCenterEnvironmentResource env in workspace.GetApiCenterEnvironments()){    Console.WriteLine($"Environment: {env.Data.Title} ({env.Data.Kind})");}
// List deploymentsawait foreach (ApiCenterDeploymentResource deployment in workspace.GetApiCenterDeployments()){    Console.WriteLine($"Deployment: {deployment.Data.Title}");    Console.WriteLine($"  State: {deployment.Data.State}");}

using Azure;
try{    ArmOperation<ApiCenterApiResource> operation = await apis        .CreateOrUpdateAsync(WaitUntil.Completed, "my-api", apiData);}catch (RequestFailedException ex) when (ex.Status == 409){    Console.WriteLine("API already exists with conflicting configuration");}catch (RequestFailedException ex) when (ex.Status == 400){    Console.WriteLine($"Invalid request: {ex.Message}");}catch (RequestFailedException ex){    Console.WriteLine($"Azure error: {ex.Status} - {ex.Message}");}