Major amendments to this script I made, please review and feel free to use

[brt5586]

Good morning, I've had to make some quite major adjustments to this which I am using in a company I work for. I thought it would be good to share with yourself - I want to so thank you for this script as Microsoft's Azure Start/Stop V2 is great but managing multiple Logic App schedules is so tedious and feels like a step backwards so this way was my goal.

So amendments I've made are the following:

1. The script now supports time zones specified in the tag value such as 'AutoShutdownSchedule' : '[TIMEZONE] 19:00->08:00' such as [BST] / [IST] and will check schedules specified in that said time zone which helps with daylight savings. (It will default to the 'Default Time Zone' variable if not specified.
2. The script now supports use of specific-day schedules such as:
'17:00->19:00, Monday: 08:30->17:00, Tuesday: 09:30->19:00, Wednesday: 11:30->12:00, Friday: 00:00->08:00, Saturday, Sunday' which means:

> Turned off everyday between 17:00 and 19:00. Each day has their own set timeframe which overrides the daily timeframe whereas on Thursday it matches back to 17:00 and 19:00 and Saturday, Sun and December 25th shutdown all day.

This allows you to now specify specific days on the schedule where you may want a whole different time frame, the way the script sees these are by prioritising the specific-day schedule if that specific-day is the current day of the run time of the script, if it's Thursday for example in the above tag value it'll revert back to the 17:00->19:00 daily schedule.

I actually made the amendments above was to meet the requirements for the company I work for so thank you very much for the original script as it has inspired this newer version I've created, below:

param(
    [parameter(Mandatory = $false)]
    [String] $AzureCredentialName = "Use *Default Automation Credential* Asset",
    [parameter(Mandatory = $false)]
    [String] $AzureSubscriptionName = "Use *Default Azure Subscription* Variable Value",
    [parameter(Mandatory = $false)]
    [String] $AzureEnvironmentName = "Use *Default Azure Environment* Variable Value",
    [parameter(Mandatory = $false)]
    [String] $tz = "Use *Default Time Zone* Variable Value",
    [parameter(Mandatory = $false)]
    [bool] $Simulate = $false,
    [parameter(Mandatory = $false)]
    [bool] $Deallocate = $true
)

$VERSION = "3.9.7-Modified"
$script:DoNotStart = $false

# Hashtable for time zone abbreviation mapping
$timeZoneAbbreviations = @{
    # Africa
    'CAT'  = 'South Africa Standard Time';          # Central Africa Time
    'EAT'  = 'E. Africa Standard Time';             # East Africa Time
    'WAT'  = 'W. Central Africa Standard Time';     # West Africa Time

    # America
    'ADT'  = 'Atlantic Standard Time';              # Atlantic Daylight Time
    'AST'  = 'Atlantic Standard Time';              # Atlantic Standard Time
    'AKDT' = 'Alaskan Standard Time';               # Alaska Daylight Time
    'AKST' = 'Alaskan Standard Time';               # Alaska Standard Time
    'CDT'  = 'Central Standard Time';               # Central Daylight Time (US & Canada)
    'CST'  = 'Central Standard Time';               # Central Standard Time (US & Canada)
    'EDT'  = 'Eastern Standard Time';               # Eastern Daylight Time (US & Canada)
    'EST'  = 'Eastern Standard Time';               # Eastern Standard Time (US & Canada)
    'HST'  = 'Hawaiian Standard Time';              # Hawaii Standard Time
    'MDT'  = 'Mountain Standard Time';              # Mountain Daylight Time (US & Canada)
    'MST'  = 'Mountain Standard Time';              # Mountain Standard Time (US & Canada)
    'PDT'  = 'Pacific Standard Time';               # Pacific Daylight Time (US & Canada)
    'PST'  = 'Pacific Standard Time';               # Pacific Standard Time (US & Canada)
    'NST'  = 'Newfoundland Standard Time';          # Newfoundland Standard Time
    'NDT'  = 'Newfoundland Standard Time';          # Newfoundland Daylight Time

    # Asia
    'IST'  = 'India Standard Time';                 # India Standard Time
    'JST'  = 'Tokyo Standard Time';                 # Japan Standard Time
    'KST'  = 'Korea Standard Time';                 # Korea Standard Time
    'SGT'  = 'Singapore Standard Time';             # Singapore Time
    #'CST'  = 'China Standard Time';                 # China Standard Time (Ambiguous with US CST)
    'ICT'  = 'SE Asia Standard Time';               # Indochina Time

    # Australia
    'ACST' = 'Cen. Australia Standard Time';        # Australian Central Standard Time
    'ACDT' = 'Cen. Australia Standard Time';        # Australian Central Daylight Time
    'AEST' = 'E. Australia Standard Time';          # Australian Eastern Standard Time
    'AEDT' = 'AUS Eastern Standard Time';           # Australian Eastern Daylight Time
    'AWST' = 'W. Australia Standard Time';          # Australian Western Standard Time
    'AWDT' = 'W. Australia Standard Time';          # Australian Western Daylight Time

    # Europe
    'BST'  = 'GMT Standard Time';                   # British Summer Time (Handled by GMT Standard Time)
    'CET'  = 'Central European Standard Time';      # Central European Time
    'CEST' = 'Central European Standard Time';      # Central European Summer Time
    'EET'  = 'GTB Standard Time';                   # Eastern European Time
    'EEST' = 'GTB Standard Time';                   # Eastern European Summer Time
    'GMT'  = 'GMT Standard Time';                   # Greenwich Mean Time
    'WET'  = 'GMT Standard Time';                   # Western European Time
    'WEST' = 'GMT Standard Time';                   # Western European Summer Time
    'MSK'  = 'Russian Standard Time';               # Moscow Standard Time

    # Middle East
    'IRST' = 'Iran Standard Time';                  # Iran Standard Time
    'IDT'  = 'Israel Standard Time';                # Israel Daylight Time
    #'IST'  = 'Israel Standard Time';                # Israel Standard Time (Ambiguous with India Standard Time)
    #'AST'  = 'Arab Standard Time';                  # Arabian Standard Time

    # New Zealand
    'NZST' = 'New Zealand Standard Time';           # New Zealand Standard Time
    'NZDT' = 'New Zealand Standard Time';           # New Zealand Daylight Time

    # General
    'UTC'  = 'UTC';                                 # Coordinated Universal Time
    'UCT'  = 'UTC';                                 # Coordinated Universal Time

    # Additional Time Zones
    'ART'  = 'Egypt Standard Time';                 # Eastern European Time (Egypt)
    'PET'  = 'SA Pacific Standard Time';            # Peru Time
    'ECT'  = 'Central Europe Standard Time';        # European Central Time
    'MET'  = 'Middle East Standard Time';           # Middle East Time

    # Pacific Islands
    'FJT'  = 'Fiji Standard Time';                  # Fiji Time
    'WST'  = 'Samoa Standard Time';                 # Western Samoa Time

    # Handling Ambiguities
    # 'CST' is ambiguous: Could be 'Central Standard Time' (US) or 'China Standard Time'
    # 'IST' is ambiguous: Could be 'India Standard Time' or 'Israel Standard Time' or 'Irish Standard Time'
    # It's recommended to specify the full time zone ID in cases of ambiguity
}

# Define function to check current time against specified range
function CheckScheduleEntry ([string] $TimeRange, [DateTime] $CurrentTime) {
    # Initialise variables
    $rangeStart, $rangeEnd, $parsedDay = $null
    # $CurrentTime is already in the correct time zone
    $midnight = $CurrentTime.AddDays(1).Date

    try {
        $todayName = $CurrentTime.ToString('dddd')
        $yesterdayName = $CurrentTime.AddDays(-1).ToString('dddd')

        # Check for per-day entry
        if ($TimeRange -match '^(?<Day>[A-Za-z]+):\s*(?<TimeRange>.+)$') {
            $dayPart = $Matches['Day']
            $timeRangePart = $Matches['TimeRange']

            # Check if specified day matches today or yesterday
            $isToday = $dayPart -ieq $todayName
            $isYesterday = $dayPart -ieq $yesterdayName

            if ($isToday -or $isYesterday) {
                # Proceed to parse $timeRangePart
                $TimeRange = $timeRangePart

                # Parse as range if contains '->'
                if ($TimeRange -like "*->*") {
                    $timeRangeComponents = $TimeRange -split "->" | ForEach-Object { $_.Trim() }
                    if ($timeRangeComponents.Count -eq 2) {
                        # Adjust date based on whether it's today or yesterday
                        if ($isToday) {
                            $dateBase = $CurrentTime.ToString("yyyy-MM-dd")
                        }
                        else {
                            $dateBase = $CurrentTime.AddDays(-1).ToString("yyyy-MM-dd")
                        }

                        $rangeStart = Get-Date -Date ("$dateBase $($timeRangeComponents[0])")
                        $rangeEnd = Get-Date -Date ("$dateBase $($timeRangeComponents[1])")

                        # Check for crossing midnight
                        if ($rangeStart -gt $rangeEnd) {
                            $rangeEnd = $rangeEnd.AddDays(1)
                        }
                    }
                    else {
                        Write-Output "`tWARNING: Invalid time range format in per-day schedule. Expects valid .Net DateTime-formatted start time and end time separated by '->'"
                        return $null
                    }
                }
                else {
                    # Single time, e.g., '17:00'
                    if ($isToday) {
                        $dateBase = $CurrentTime.ToString("yyyy-MM-dd")
                    }
                    else {
                        $dateBase = $CurrentTime.AddDays(-1).ToString("yyyy-MM-dd")
                    }
                    $rangeStart = Get-Date -Date ("$dateBase $TimeRange")
                    $rangeEnd = $rangeStart.AddMinutes(30) # Only match this time
                }
            }
            else {
                # Today does not match dayPart, and dayPart does not match yesterday
                return $null
            }
        }
        else {
            # Parse as normal
            if ($TimeRange -like "*->*") {
                $timeRangeComponents = $TimeRange -split "->" | ForEach-Object { $_.Trim() }
                if ($timeRangeComponents.Count -eq 2) {
                    $rangeStart = Get-Date -Date ("$($CurrentTime.ToString("yyyy-MM-dd")) $($timeRangeComponents[0])")
                    $rangeEnd = Get-Date -Date ("$($CurrentTime.ToString("yyyy-MM-dd")) $($timeRangeComponents[1])")

                    # Check for crossing midnight
                    if ($rangeStart -gt $rangeEnd) {
                        # If current time is between the start of range and midnight tonight, interpret end time as tomorrow
                        if ($CurrentTime -ge $rangeStart -and $CurrentTime -lt $midnight) {
                            $rangeEnd = $rangeEnd.AddDays(1)
                        }
                        # Otherwise interpret start time as yesterday
                        else {
                            $rangeStart = $rangeStart.AddDays(-1)
                        }
                    }
                }
                else {
                    Write-Output "`tWARNING: Invalid time range format. Expects valid .Net DateTime-formatted start time and end time separated by '->'"
                    return $null
                }
            }
            # Otherwise attempt to parse as a full day entry, e.g. 'Monday' or 'December 25'
            else {
                # If specified as day of week, check if today
                if ([System.DayOfWeek]::GetNames([System.DayOfWeek]) -contains $TimeRange) {
                    $todayName = $CurrentTime.ToString('dddd')
                    if ($TimeRange -ieq $todayName) {
                        $parsedDay = Get-Date -Hour 0 -Minute 0 -Second 0 -Date $CurrentTime.Date
                    }
                    else {
                        # Skip detected day of week that isn't today
                        return $null
                    }
                }
                elseif ($TimeRange -match '^(([0-1]?[0-9]|[2][0-3]):([0-5][0-9])|([0-1]?[0-9](pm|am)))$') {
                    # Parse as time, e.g. '17:00' or '5pm'
                    $parsedDay = $null
                    $rangeStart = Get-Date -Date ("$($CurrentTime.ToString("yyyy-MM-dd")) $TimeRange")
                    $rangeEnd = $rangeStart.AddMinutes(30) # Only match this time
                }
                else {
                    # Otherwise attempt to parse as a date, e.g. 'December 25'
                    $parsedDay = Get-Date $TimeRange -ErrorAction SilentlyContinue
                    if ($null -ne $parsedDay) {
                        if ($parsedDay.Month -eq $CurrentTime.Month -and $parsedDay.Day -eq $CurrentTime.Day) {
                            $parsedDay = Get-Date -Hour 0 -Minute 0 -Second 0 -Date $CurrentTime.Date
                        }
                        else {
                            return $null
                        }
                    }
                    else {
                        # Invalid format
                        return $null
                    }
                }

                if ($null -ne $parsedDay) {
                    $rangeStart = $parsedDay # Defaults to midnight
                    $rangeEnd = $parsedDay.AddHours(23).AddMinutes(59).AddSeconds(59) # End of the same day
                }
            }
        }
    }
    catch {
        # Record any errors and return $null by default
        Write-Output "`tWARNING: Exception encountered while parsing time range. Details: $($_.Exception.Message). Check the syntax of entry, e.g. '<StartTime> -> <EndTime>', or days/dates like 'Sunday' and 'December 25'"
        return $null
    }

    # Check if current time falls within range
    if ($rangeStart -and $rangeEnd -and $CurrentTime -ge $rangeStart -and $CurrentTime -le $rangeEnd) {
        return $true
    }
    else {
        return $false
    }
} # End function CheckScheduleEntry

# Function to handle power state assertion for resource manager VMs
function AssertVirtualMachinePowerState {
    param(
        [Object] $VirtualMachine,
        [string] $RGName,
        [string] $DesiredState,
        [Object[]] $ResourceManagerVMList,
        [bool] $Simulate
    )

    $resourceManagerVM = $ResourceManagerVMList | Where-Object { $_.Name -eq $VirtualMachine.Name -and $_.ResourceGroupName -eq $RGName }
    AssertResourceManagerVirtualMachinePowerState -VirtualMachine $resourceManagerVM -DesiredState $DesiredState -Simulate $Simulate
}

# Function to handle power state assertion for resource manager VM
function AssertResourceManagerVirtualMachinePowerState {
    param(
        [Object] $VirtualMachine,
        [string] $DesiredState,
        [bool] $Simulate
    )

    # Get VM with current status
    $resourceManagerVM = Get-AzVM -ResourceGroupName $VirtualMachine.ResourceGroupName -Name $VirtualMachine.Name -Status
    $currentStatus = $resourceManagerVM.Statuses | Where-Object Code -Like "PowerState*"
    $currentStatus = $currentStatus.Code -replace "PowerState/", ""

    # If should be started and isn't, start VM
    if ($DesiredState -eq "Started" -and $currentStatus -notmatch "running") {
        if ($DoNotStart -eq $true) {
            Write-Output "[$($VirtualMachine.Name)]: This tag never starts VMs"
        }
        else {
            if ($Simulate) {
                Write-Output "[$($VirtualMachine.Name)]: SIMULATION -- Would have started VM. (No action taken)"
            }
            else {
                Write-Output "[$($VirtualMachine.Name)]: Starting VM"
                $resourceManagerVM | Start-AzVM -NoWait > $null
            }
        }
    }

    # If should be stopped and isn't, stop VM
    elseif ($DesiredState -eq "StoppedDeallocated" -and $currentStatus -ne "deallocated") {
        if ($Simulate) {
            Write-Output "[$($VirtualMachine.Name)]: SIMULATION -- Would have stopped VM. (No action taken)"
        }
        else {
            Write-Output "[$($VirtualMachine.Name)]: Stopping VM"
            $resourceManagerVM | Stop-AzVM -NoWait -Force > $null
        }
    }

    # Otherwise, current power state is correct
    else {
        Write-Output "[$($VirtualMachine.Name)]: Current power state [$currentStatus] is correct."
    }
}

# Function to deallocate the virtual machine that is stopped but not deallocated
function DeallocateVirtualMachine {
    param(
        [Object] $VirtualMachine,
        [bool] $Simulate,
        [bool] $Deallocate
    )
    # Get VM with current status
    $resourceManagerVM = Get-AzVM -ResourceGroupName $VirtualMachine.ResourceGroupName -Name $VirtualMachine.Name -Status
    $currentStatus = $resourceManagerVM.Statuses | Where-Object Code -Like "PowerState*"
    $currentStatus = $currentStatus.Code -replace "PowerState/", ""

    # If stopped but not deallocated, deallocate
    if ($currentStatus -eq 'stopped') {
        Write-Output "[$($VirtualMachine.Name)]: The virtual machine is stopped but not deallocated, charges still incurred"
        if ($Deallocate) {
            if ($Simulate) {
                Write-Output "[$($VirtualMachine.Name)]: SIMULATION -- Would have deallocated VM. (No action taken)"
            }
            else {
                Write-Output "[$($VirtualMachine.Name)]: Deallocating VM"
                $resourceManagerVM | Stop-AzVM -NoWait -Force > $null
            }
        }
        else {
            Write-Output "The setting Deallocate is set to False"
        }
    }
}

function ValidateScheduleList ($TimeRangeList) {
    $TagRange = 0
    $TagDay = 0
    $TagTime = 0
    $TagInvalid = 0
    $TagPerDay = 0
    $TimeRanges = @($TimeRangeList -split "," | ForEach-Object { $_.Trim() })
    foreach ($TimeRange in $TimeRanges) {
        try {
            if ($TimeRange -like '*->*') {
                if ($TimeRange -match '^[A-Za-z]+:\s*(.+)$') {
                    # This is a per-day entry
                    $TagPerDay += 1
                }
                else {
                    # Regular time range
                    $Divider = $TimeRange.IndexOf('->')
                    $Times = @($TimeRange.Substring(0, $Divider), $TimeRange.Substring($Divider + 2))
                    $InError = $false
                    foreach ($Time in $Times) {
                        if ($Time -notmatch '^(([0-1]?[0-9]|[2][0-3]):([0-5][0-9])|([0-1]?[0-9](pm|am)))$') {
                            $InError = $true
                        }
                    }
                    if ($InError) {
                        $TagInvalid += 1
                    }
                    else {
                        $TagRange += 1
                    }
                }
            }
            elseif ($TimeRange -match '^([A-Za-z]+):\s*(.+)$') {
                # This is a per-day entry
                $TagPerDay += 1
            }
            elseif ($TimeRange -match '^(([0-1]?[0-9]|[2][0-3]):([0-5][0-9])|([0-1]?[0-9](pm|am)))$') {
                $TagTime += 1
                $script:DoNotStart = $true
            }
            elseif ([System.DayOfWeek]::GetNames([System.DayOfWeek]) -contains $TimeRange) {
                $TagDay += 1
            }
            elseif (Get-Date $TimeRange -ErrorAction SilentlyContinue) {
                $TagDay += 1
            }
            else {
                $TagInvalid += 1
            }
        }
        catch {
            $TagInvalid += 1
        }
    }
    if ($TagInvalid -gt 0) {
        return "Invalid tag: '$TimeRangeList'"
    }
    elseif ($TagTime -gt 0 -and (($TagRange -gt 0) -or ($TagDay -gt 0) -or ($TagPerDay -gt 0))) {
        return "Time has to be alone in the tag: '$TimeRangeList'"
    }
    return 'OK'
}

# Main runbook content
try {
    # Store script start time
    $ScriptStartTime = Get-Date

    # Ensures you do not inherit an AzContext in your runbook
    Disable-AzContextAutosave -Scope Process
    # Retrieve time zone name from variable asset if not specified
    if ($tz -eq "Use *Default Time Zone* Variable Value") {
        $tz = Get-AutomationVariable -Name "Default Time Zone"
        if ($tz.length -gt 0) {
            Write-Output "Specified default time zone: [$tz]"
        }
        else {
            Write-Output "No time zone was specified, and no variable asset with name 'Default Time Zone' was found, will use UTC"
            $tz = 'UTC'
        }
    }

    Write-Output "Runbook started. Version: $VERSION"
    if ($Simulate) {
        Write-Output "*** Running in SIMULATE mode. No power actions will be taken. ***"
    }
    else {
        Write-Output "*** Running in LIVE mode. Schedules will be enforced. ***"
    }
    Write-Output "Default time zone is set to: $tz"

    # Retrieve subscription name from variable asset if not specified
    if ($AzureSubscriptionName -eq "Use *Default Azure Subscription* Variable Value") {
        $AzureSubscriptionName = Get-AutomationVariable -Name "Default Azure Subscription" -ErrorAction Ignore
        if ($AzureSubscriptionName.length -gt 0) {
            Write-Output "Specified subscription name/ID: [$AzureSubscriptionName]"
        }
    }

    # Retrieve Azure environment from variable if not specified
    if ($AzureEnvironmentName -eq "Use *Default Azure Environment* Variable Value") {
        $AzureEnvironmentName = Get-AutomationVariable -Name "Default Azure Environment" -ErrorAction Ignore
        if ($AzureEnvironmentName.length -gt 0) {
            Write-Output "Specified Azure Environment: [$AzureEnvironmentName]"
        }
        else {
            Write-Output "No Azure Environment was specified, and no variable asset with name 'Default Azure Environment' was found, will use AzureCloud"
            $AzureEnvironmentName = 'AzureCloud'
        }
    }
    # Retrieve credential

    $ManagedIdentityId = Get-AutomationVariable -Name "Managed Identity ID" -ErrorAction Ignore
    $RunAsConnection = Get-AutomationConnection -Name "AzureRunAsConnection" -ErrorAction Ignore
    if ($ManagedIdentityId -eq 'System') {
        Write-Output ("Logging in to Azure using the system managed identity...")
        if ($AzureSubscriptionName.Length -eq 0) {
            throw "No subscription indicated"
        }
        Connect-AzAccount -Identity -Subscription $AzureSubscriptionName -EnvironmentName $AzureEnvironmentName > $null
    }
    elseif ($ManagedIdentityId) {
        Write-Output "Logging in to Azure using the user managed identity..."
        if ($AzureSubscriptionName.Length -eq 0) {
            throw "No subscription indicated"
        }
        Connect-AzAccount -Identity -AccountId $ManagedIdentityId -Subscription $AzureSubscriptionName -EnvironmentName $AzureEnvironmentName > $null
    }
    elseif ($RunAsConnection) {
        Write-Output ("Logging in to Azure using the runas account...")
        Connect-AzAccount -ServicePrincipal `
            -TenantId $RunAsConnection.TenantId `
            -ApplicationId $RunAsConnection.ApplicationId `
            -CertificateThumbprint $RunAsConnection.CertificateThumbprint `
            -SubscriptionId $RunAsConnection.SubscriptionId `
            -EnvironmentName $AzureEnvironmentName > $null
    }
    else {
        Write-Output "Logging in to Azure using the supplied credentials"
        Write-Output "Specified credential asset name: [$AzureCredentialName]"
        if ($AzureCredentialName -eq "Use *Default Automation Credential* Asset") {
            # By default, look for "Default Automation Credential" asset
            $azureCredential = Get-AutomationPSCredential -Name "Default Automation Credential"
            if ($null -ne $azureCredential) {
                Write-Output "Attempting to authenticate as: [$($azureCredential.UserName)]"
            }
            else {
                throw "No runas account and no automation credential name was specified, and no credential asset with name 'Default Automation Credential' was found. Either specify a runas account, a stored credential name or define the default using a credential asset"
            }
        }
        else {
            # A different credential name was specified, attempt to load it
            $azureCredential = Get-AutomationPSCredential -Name $AzureCredentialName
            if ($null -eq $azureCredential) {
                throw "Failed to get credential with name [$AzureCredentialName]"
            }
        }

        # Connect to Azure using credential asset (AzureRM)
        if ($AzureSubscriptionName.Length -eq 0) {
            throw "No subscription indicated"
        }
        $account = Connect-AzAccount -Credential $azureCredential -SubscriptionName $AzureSubscriptionName -EnvironmentName $AzureEnvironmentName

        # Check for returned userID, indicating successful authentication
        if ($account.Context.Account.Id -eq $azureCredential.UserName) {
            Write-Output "Successfully authenticated as user: [$($azureCredential.UserName)]"
        }
        else {
            throw "Authentication failed for credential [$($azureCredential.UserName)]. Ensure a valid Azure Active Directory user account is specified which is configured as subscription owner (modern portal) on the target subscription. Verify you can log into the Azure portal using these credentials."
        }
    }

    # If subscription is set in variable, use that. Otherwise use subscription from the runas account
    if ($AzureSubscriptionName.length -gt 0) {
        $AzureSubscriptionId = (Get-AzSubscription -SubscriptionName $AzureSubscriptionName).Id
    }
    else {
        $AzureSubscriptionId = $RunAsConnection.SubscriptionId
    }
    Set-AzContext -SubscriptionId $AzureSubscriptionId > $null

    # Validate subscription
    $subscriptions = @(Get-AzSubscription | Where-Object { $_.Name -eq $AzureSubscriptionName -or $_.Id -eq $AzureSubscriptionName })
    if ($subscriptions.Count -eq 1) {
        # Set working subscription
        $targetSubscription = $subscriptions | Select-Object -First 1
        $targetSubscription | Select-AzSubscription > $null

        Write-Output "Working against subscription: $($targetSubscription.Name) ($($targetSubscription.SubscriptionId))"
    }
    else {
        if ($subscriptions.Count -eq 0) {
            throw "No accessible subscription found with name or ID [$AzureSubscriptionName]."
        }
        elseif ($subscriptions.Count -gt 1) {
            throw "More than one accessible subscription found with name or ID [$AzureSubscriptionName]. Please ensure your subscription names are unique, or specify the ID instead"
        }
    }

    # Get a list of all virtual machines in subscription
    $resourceManagerVMList = Get-AzVM | Sort-Object Name

    # Get resource groups that are tagged for automatic shutdown of resources
    $taggedResourceGroups = @(Get-AzResourceGroup | Where-Object { $_.Tags.Count -gt 0 -and $_.Tags.AutoShutdownSchedule })
    $taggedResourceGroupNames = @($taggedResourceGroups | Select-Object -ExpandProperty ResourceGroupName)
    Write-Output "Found [$($taggedResourceGroups.Count)] schedule-tagged resource groups in subscription"

    # For each VM, determine
    Write-Output "Processing [$($resourceManagerVMList.Count)] virtual machines found in subscription"
    foreach ($vm in $resourceManagerVMList) {
        $script:DoNotStart = $false
        # Deallocate all machines stopped and not deallocated, regardless of tags
        DeallocateVirtualMachine -VirtualMachine $vm -Simulate $Simulate -Deallocate $Deallocate

        $schedule = $null

        # Check for direct tag or group-inherited tag
        if ($vm.Tags -and $vm.Tags.AutoShutdownSchedule) {
            # VM has direct tag
            $schedule = $vm.Tags.AutoShutdownSchedule
            Write-Output "[$($vm.Name)]: Found direct VM schedule tag with value: $schedule"
        }
        elseif ($taggedResourceGroupNames -contains $vm.ResourceGroupName) {
            # VM belongs to a tagged resource group. Use the group tag
            $parentGroup = $taggedResourceGroups | Where-Object ResourceGroupName -EQ $vm.ResourceGroupName
            $schedule = $parentGroup.Tags.AutoShutdownSchedule
            Write-Output "[$($vm.Name)]: Found parent resource group schedule tag with value: $schedule"
        }
        else {
            # No direct or inherited tag. Skip this VM.
            Write-Output "[$($vm.Name)]: Not tagged for shutdown directly or via membership in a tagged resource group. Skipping this VM."
            continue
        }

        # Check that tag value was successfully obtained
        if ($null -eq $schedule) {
            Write-Output "[$($vm.Name)]: Failed to get tagged schedule for virtual machine. Skipping this VM."
            continue
        }

        # Extract time zone from schedule if specified
        $vmTimeZone = $null
        if ($schedule -match '^\[(.+?)\]\s*(.*)$') {
            $timeZoneString = $Matches[1]
            $schedule = $Matches[2].Trim()
            Write-Output "[$($vm.Name)]: Extracted time zone from schedule: $timeZoneString"

            # Map abbreviation to full time zone ID if necessary
            if ($timeZoneAbbreviations.ContainsKey($timeZoneString.ToUpper())) {
                $vmTimeZone = $timeZoneAbbreviations[$timeZoneString.ToUpper()]
            }
            else {
                $vmTimeZone = $timeZoneString
            }
        }
        else {
            $vmTimeZone = $tz  # Use default time zone
            Write-Output "[$($vm.Name)]: Using default time zone: $vmTimeZone"
        }

        # Validate the time zone
        try {
            $vmTimeZoneInfo = [System.TimeZoneInfo]::FindSystemTimeZoneById($vmTimeZone)
        }
        catch {
            Write-Error "[$($vm.Name)]: Invalid time zone ID: $vmTimeZone. Skipping this VM."
            continue
        }

        # Calculate the current time in the VM's time zone
        $tempTime = (Get-Date).ToUniversalTime()
        $CurrentTime = [System.TimeZoneInfo]::ConvertTimeFromUtc($tempTime, $vmTimeZoneInfo)

        $Result = ValidateScheduleList $schedule
        if ($Result -ne 'OK') {
            Write-Error "[$($vm.Name)]: $Result. Skipping this VM."
            continue
        }

        # Parse the ranges in the Tag value
        $timeRangeList = @($schedule -split "," | ForEach-Object { $_.Trim() })

        # Separate per-day entries and daily entries
        $perDayEntries = @()
        $dailyEntries = @()

        foreach ($entry in $timeRangeList) {
            if ($entry -match '^[A-Za-z]+:') {
                $perDayEntries += $entry
            }
            elseif ($entry -match '^[A-Za-z]+$') {
                $perDayEntries += $entry
            }
            else {
                $dailyEntries += $entry
            }
        }

        # Initialize variables
        $scheduleMatched = $false
        $matchedSchedule = $null

        # Identify per-day entries that apply to today
        $perDayEntriesForToday = @()
        $todayName = $CurrentTime.ToString('dddd')

        foreach ($entry in $perDayEntries) {
            if ($entry -match '^(?<Day>[A-Za-z]+):') {
                $dayPart = $Matches['Day']
                if ($dayPart -ieq $todayName) {
                    $perDayEntriesForToday += $entry
                }
            } elseif ($entry -match '^[A-Za-z]+$') {
                # Entries like 'Saturday' or 'Sunday'
                if ($entry -ieq $todayName) {
                    $perDayEntriesForToday += $entry
                }
            } elseif (Get-Date $entry -ErrorAction SilentlyContinue) {
                # Entries like 'December 25'
                $parsedDate = Get-Date $entry -ErrorAction SilentlyContinue
                if ($parsedDate.Month -eq $CurrentTime.Month -and $parsedDate.Day -eq $CurrentTime.Day) {
                    $perDayEntriesForToday += $entry
                }
            }
        }

        # Process per-day schedules
        if ($perDayEntriesForToday.Count -gt 0) {
            Write-Output "[$($vm.Name)]: Found per-day schedules for today. Processing per-day schedules."
            foreach ($entry in $perDayEntriesForToday) {
                if ((CheckScheduleEntry -TimeRange $entry -CurrentTime $CurrentTime) -eq $true) {
                    $scheduleMatched = $true
                    $matchedSchedule = $entry
                    break
                }
            }
            if ($scheduleMatched) {
                Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] matches per-day schedule [$matchedSchedule]"
                # Proceed to enforce the schedule
            } else {
                Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] does not match any per-day schedules for today."
                # Do not process daily schedules; move to next VM
                continue
            }
        } else {
            # No per-day schedules apply for today. Processing daily schedules.
            Write-Output "[$($vm.Name)]: No per-day schedules apply for today. Processing daily schedules."
            foreach ($entry in $dailyEntries) {
                if ((CheckScheduleEntry -TimeRange $entry -CurrentTime $CurrentTime) -eq $true) {
                    $scheduleMatched = $true
                    $matchedSchedule = $entry
                    break
                }
            }
            if ($scheduleMatched) {
                Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] matches daily schedule [$matchedSchedule]"
            } else {
                Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] does not match any schedules"
            }
        }

        # Enforce desired state based on result
        if ($scheduleMatched) {
            # Schedule is matched. Shut down the VM if it is running.
            Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] falls within the scheduled shutdown range [$matchedSchedule]"
            AssertVirtualMachinePowerState -VirtualMachine $vm -RGName $vm.ResourceGroupName -DesiredState "StoppedDeallocated" -ResourceManagerVMList $resourceManagerVMList -Simulate $Simulate
        }
        else {
            # If the tag consists of a single date, the machine should never be started
            try {
                if (Get-Date($schedule) -ErrorAction SilentlyContinue) {
                    Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] falls outside the scheduled shutdown range [$schedule], single time so not changing the state."
                }
                else {
                    Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] falls outside of all scheduled shutdown ranges."
                    AssertVirtualMachinePowerState -VirtualMachine $vm -RGName $vm.ResourceGroupName -DesiredState "Started" -ResourceManagerVMList $resourceManagerVMList -Simulate $Simulate
                }
            }
            catch {
                Write-Output "[$($vm.Name)]: Current time in $vmTimeZone [$CurrentTime] falls outside of all scheduled shutdown ranges."
                AssertVirtualMachinePowerState -VirtualMachine $vm -RGName $vm.ResourceGroupName -DesiredState "Started" -ResourceManagerVMList $resourceManagerVMList -Simulate $Simulate
            }
        }
    }
    Write-Output "Finished processing virtual machine schedules"
}
catch {
    $errorMessage = $_.Exception.Message
    $line = $_.InvocationInfo.ScriptLineNumber
    throw "Unexpected exception: $errorMessage at line $line"
}
finally {
    $ScriptEndTime = Get-Date
    $ScriptDuration = $ScriptEndTime - $ScriptStartTime
    Write-Output "Runbook finished (Duration: $(("{0:hh\:mm\:ss}" -f $ScriptDuration)))"
}