Subscription Creation via Aliases

def begin_create(alias_name: str, body: Union[PutAliasRequest, IO], **kwargs) -> LROPoller[SubscriptionAliasResponse]:
    """
    Create Alias Subscription (Long Running Operation).
    
    Args:
        alias_name (str): The alias name for the subscription
        body (PutAliasRequest): Alias creation request with subscription details
        
    Returns:
        LROPoller[SubscriptionAliasResponse]: Long-running operation poller yielding alias response
    """

from azure.identity import DefaultAzureCredential
from azure.mgmt.subscription import SubscriptionClient
from azure.mgmt.subscription.models import (
    PutAliasRequest,
    PutAliasRequestProperties,
    PutAliasRequestAdditionalProperties,
    Workload
)

credential = DefaultAzureCredential()
client = SubscriptionClient(credential)

alias_name = "my-subscription-alias"

# Create alias properties
additional_properties = PutAliasRequestAdditionalProperties(
    management_group_id="/providers/Microsoft.Management/managementGroups/my-mg",
    tags={"Environment": "Production", "CostCenter": "12345"}
)

properties = PutAliasRequestProperties(
    display_name="My New Enterprise Subscription",
    billing_scope="/subscriptions/00000000-0000-0000-0000-000000000000/billingProfiles/ABCD-EFGH-12345678",
    workload=Workload.PRODUCTION,
    additional_properties=additional_properties
)

alias_request = PutAliasRequest(properties=properties)

try:
    # Start the long-running operation
    poller = client.alias.begin_create(alias_name, alias_request)
    print(f"Subscription creation initiated with alias: {alias_name}")
    print("Waiting for completion...")
    
    # Wait for completion (this may take several minutes)
    result = poller.result()
    
    print(f"Subscription created successfully!")
    print(f"Alias ID: {result.id}")
    print(f"Subscription ID: {result.properties.subscription_id}")
    print(f"Provisioning State: {result.properties.provisioning_state}")
    
except Exception as e:
    print(f"Failed to create subscription: {e}")

def get(alias_name: str, **kwargs) -> SubscriptionAliasResponse:
    """
    Get Alias Subscription.
    
    Args:
        alias_name (str): The alias name to retrieve
        
    Returns:
        SubscriptionAliasResponse: Alias information and status
    """

alias_name = "my-subscription-alias"

try:
    alias_info = client.alias.get(alias_name)
    
    print(f"Alias Name: {alias_info.name}")
    print(f"Alias ID: {alias_info.id}")
    print(f"Type: {alias_info.type}")
    
    properties = alias_info.properties
    if properties:
        print(f"Display Name: {properties.display_name}")
        print(f"Subscription ID: {properties.subscription_id}")
        print(f"Provisioning State: {properties.provisioning_state}")
        print(f"Accept Ownership State: {properties.accept_ownership_state}")
        print(f"Billing Scope: {properties.billing_scope}")
        print(f"Workload: {properties.workload}")
        
        if properties.tags:
            print("Tags:")
            for key, value in properties.tags.items():
                print(f"  {key}: {value}")
                
except Exception as e:
    print(f"Failed to get alias information: {e}")

def delete(alias_name: str, **kwargs) -> None:
    """
    Delete Alias.
    
    Args:
        alias_name (str): The alias name to delete
        
    Returns:
        None
    """

alias_name = "my-subscription-alias"

try:
    client.alias.delete(alias_name)
    print(f"Successfully deleted alias: {alias_name}")
    
    # Verify deletion by trying to get the alias
    try:
        client.alias.get(alias_name)
        print("Warning: Alias still exists after deletion")
    except Exception:
        print("Alias successfully removed")
        
except Exception as e:
    print(f"Failed to delete alias: {e}")

def list(**kwargs) -> SubscriptionAliasListResult:
    """
    List Alias Subscription.
    
    Returns:
        SubscriptionAliasListResult: List of all subscription aliases
    """

try:
    aliases_result = client.alias.list()
    aliases = aliases_result.value
    
    print(f"Found {len(aliases)} subscription aliases:")
    
    for alias in aliases:
        print(f"Name: {alias.name}")
        print(f"ID: {alias.id}")
        
        if alias.properties:
            print(f"  Display Name: {alias.properties.display_name}")
            print(f"  Subscription ID: {alias.properties.subscription_id}")
            print(f"  State: {alias.properties.provisioning_state}")
        print("---")
        
except Exception as e:
    print(f"Failed to list aliases: {e}")

import time
from azure.core.exceptions import HttpResponseError

def monitor_subscription_creation(client, alias_name, poller):
    """Monitor subscription creation with periodic status updates."""
    while not poller.done():
        try:
            # Check current alias status
            alias_info = client.alias.get(alias_name)
            properties = alias_info.properties
            
            if properties:
                print(f"Provisioning State: {properties.provisioning_state}")
                print(f"Accept Ownership State: {properties.accept_ownership_state}")
                
                if properties.subscription_id:
                    print(f"Subscription ID: {properties.subscription_id}")
            
            # Wait before next check
            time.sleep(30)
            
        except HttpResponseError as e:
            if e.status_code == 404:
                print("Alias no longer found - may have been cleaned up")
                break
            else:
                print(f"Error checking status: {e}")
        
        except KeyboardInterrupt:
            print("Monitoring interrupted. Creation continues in background.")
            break
    
    return poller.done()

# Usage
poller = client.alias.begin_create(alias_name, alias_request)
success = monitor_subscription_creation(client, alias_name, poller)
if success:
    final_result = poller.result()
    print(f"Final subscription ID: {final_result.properties.subscription_id}")

def create_multiple_subscriptions(client, subscription_configs):
    """Create multiple subscriptions concurrently."""
    pollers = []
    
    for config in subscription_configs:
        alias_name = config["alias_name"]
        alias_request = config["request"]
        
        try:
            poller = client.alias.begin_create(alias_name, alias_request)
            pollers.append((alias_name, poller))
            print(f"Started creation for: {alias_name}")
        except Exception as e:
            print(f"Failed to start creation for {alias_name}: {e}")
    
    # Monitor all creations
    completed = []
    for alias_name, poller in pollers:
        try:
            result = poller.result()  # Wait for completion
            completed.append({
                "alias_name": alias_name,
                "subscription_id": result.properties.subscription_id,
                "status": "Success"
            })
        except Exception as e:
            completed.append({
                "alias_name": alias_name,
                "status": f"Failed: {e}"
            })
    
    return completed

from azure.core.exceptions import HttpResponseError

def handle_alias_errors(operation_name: str, func, *args, **kwargs):
    """Generic error handler for alias operations."""
    try:
        return func(*args, **kwargs)
    except HttpResponseError as e:
        if e.status_code == 409:
            print(f"{operation_name}: Alias already exists or conflict with existing resource")
        elif e.status_code == 400:
            print(f"{operation_name}: Bad request - check billing scope and parameters")
        elif e.status_code == 403:
            print(f"{operation_name}: Insufficient permissions for subscription creation")
        elif e.status_code == 404:
            print(f"{operation_name}: Alias not found")
        else:
            print(f"{operation_name}: Error {e.status_code} - {e.message}")
        raise
    except Exception as e:
        print(f"{operation_name}: Unexpected error - {e}")
        raise

class PutAliasRequest:
    """Request object for creating subscription alias."""
    properties: PutAliasRequestProperties  # Alias creation properties

class PutAliasRequestProperties:
    """Properties for alias creation request."""
    display_name: str  # Display name for the subscription (optional)
    billing_scope: str  # Billing scope for the subscription (optional)
    workload: Union[str, Workload]  # Workload type (optional)
    additional_properties: PutAliasRequestAdditionalProperties  # Additional settings (optional)

class PutAliasRequestAdditionalProperties:
    """Additional properties for alias creation."""
    management_group_id: str  # Management group to place subscription (optional)
    subscription_tenant_id: str  # Tenant ID for subscription (optional)
    subscription_owner_id: str  # Owner ID for subscription (optional)
    tags: Dict[str, str]  # Tags to apply to subscription (optional)

class SubscriptionAliasResponse:
    """Response from alias operations."""
    id: str  # Alias resource ID
    name: str  # Alias name
    type: str  # Resource type
    properties: SubscriptionAliasResponseProperties  # Alias properties
    system_data: SystemData  # System metadata

class SubscriptionAliasResponseProperties:
    """Properties of subscription alias response."""
    subscription_id: str  # Associated subscription ID
    display_name: str  # Display name of subscription
    provisioning_state: Union[str, ProvisioningState]  # Current provisioning state
    accept_ownership_state: Union[str, AcceptOwnership]  # Current ownership state
    billing_scope: str  # Billing scope used
    workload: Union[str, Workload]  # Workload type
    management_group_id: str  # Management group placement
    subscription_owner_id: str  # Subscription owner
    tags: Dict[str, str]  # Applied tags
    created_time: str  # Creation timestamp

class SubscriptionAliasListResult:
    """Result of listing subscription aliases."""
    value: List[SubscriptionAliasResponse]  # List of aliases
    next_link: str  # URL for next page of results (optional)

class Workload(str, Enum):
    """The workload type of the subscription."""
    PRODUCTION = "Production"
    DEV_TEST = "DevTest"

class ProvisioningState(str, Enum):
    """The provisioning state of the resource."""
    ACCEPTED = "Accepted"
    SUCCEEDED = "Succeeded"
    FAILED = "Failed"

class AcceptOwnership(str, Enum):
    """The accept ownership state of the resource."""
    PENDING = "Pending"
    COMPLETED = "Completed"
    EXPIRED = "Expired"