356 lines
14 KiB
PowerShell
356 lines
14 KiB
PowerShell
function Invoke-ConfigurationDataExpressionFunction {
|
|
[CmdletBinding()]
|
|
Param(
|
|
[Parameter(Mandatory=$true)]
|
|
[string]
|
|
$Name,
|
|
|
|
[AllowNull()]
|
|
[object[]]
|
|
$Arguments,
|
|
|
|
[Parameter(Mandatory=$true)]
|
|
$Context
|
|
)
|
|
|
|
$FunctionName = $Name.ToLowerInvariant()
|
|
|
|
switch($FunctionName){
|
|
"parameters" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return Resolve-ConfigurationDataParameter -Name ([string]$Arguments[0]) -Context $Context
|
|
}
|
|
"variables" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return Resolve-ConfigurationDataVariable -Name ([string]$Arguments[0]) -Context $Context
|
|
}
|
|
"reference" {
|
|
if($Arguments.Count -eq 1){
|
|
return Resolve-ConfigurationDataReference -Path ([string]$Arguments[0]) -Context $Context
|
|
}
|
|
|
|
if($Arguments.Count -eq 2){
|
|
return Resolve-ConfigurationDataReference -Path ([string]$Arguments[0]) -Property ([string]$Arguments[1]) -Context $Context
|
|
}
|
|
|
|
throw "Function [$Name] expects 1 or 2 arguments, but received [$($Arguments.Count)]."
|
|
}
|
|
"parentkey" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 0
|
|
|
|
$Path = @($Context.CurrentPath)
|
|
if($Path.Count -lt 2){
|
|
throw "Function [$Name] requires the expression to be nested inside a parent map."
|
|
}
|
|
|
|
return [string]$Path[$Path.Count - 2]
|
|
}
|
|
"credentialwithdomain" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
|
|
if(-not ($Arguments[0] -is [System.Management.Automation.PSCredential])){
|
|
throw "Function [$Name] expects a PSCredential as first argument."
|
|
}
|
|
|
|
return ConvertTo-ConfigurationDataDomainCredential -Credential ([System.Management.Automation.PSCredential]$Arguments[0]) -Domain ([string]$Arguments[1])
|
|
}
|
|
"firstnodenamewhere" {
|
|
if($Arguments.Count -ne 1 -and $Arguments.Count -ne 2){
|
|
throw "Function [$Name] expects 1 or 2 arguments, but received [$($Arguments.Count)]."
|
|
}
|
|
|
|
$PropertyName = [string]$Arguments[0]
|
|
if([string]::IsNullOrWhiteSpace($PropertyName)){
|
|
throw "Function [$Name] requires a non-empty node property name."
|
|
}
|
|
|
|
$ExpectedValue = $true
|
|
if($Arguments.Count -eq 2){
|
|
$ExpectedValue = $Arguments[1]
|
|
}
|
|
|
|
$AllNodes = $null
|
|
if($Context.ConfigurationData.ContainsKey("AllNodes")){
|
|
$AllNodes = $Context.ConfigurationData.AllNodes
|
|
}elseif($Context.ConfigurationData.ContainsKey("Resources") -and
|
|
$Context.ConfigurationData.Resources -is [System.Collections.IDictionary] -and
|
|
$Context.ConfigurationData.Resources.ContainsKey("AllNodes")){
|
|
$AllNodes = $Context.ConfigurationData.Resources.AllNodes
|
|
}
|
|
|
|
foreach($Node in @($AllNodes)){
|
|
if($null -eq $Node -or -not ($Node -is [System.Collections.IDictionary])){
|
|
continue
|
|
}
|
|
|
|
if(-not $Node.ContainsKey($PropertyName)){
|
|
continue
|
|
}
|
|
|
|
if($Node[$PropertyName] -ne $ExpectedValue){
|
|
continue
|
|
}
|
|
|
|
if(-not $Node.ContainsKey("NodeName") -or [string]::IsNullOrWhiteSpace([string]$Node.NodeName)){
|
|
throw "Function [$Name] matched a node by [$PropertyName], but the node does not define [NodeName]."
|
|
}
|
|
|
|
return [string]$Node.NodeName
|
|
}
|
|
|
|
return $null
|
|
}
|
|
"concat" {
|
|
return (@($Arguments) | ForEach-Object { [string]$_ }) -join ""
|
|
}
|
|
"format" {
|
|
Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return [string]::Format([string]$Arguments[0], @($Arguments | Select-Object -Skip 1))
|
|
}
|
|
"coalesce" {
|
|
foreach($Argument in @($Arguments)){
|
|
if($null -ne $Argument -and [string]$Argument -ne ""){
|
|
return $Argument
|
|
}
|
|
}
|
|
|
|
return $null
|
|
}
|
|
"defaultifempty" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
if(Test-ConfigurationDataValueIsEmpty -Value $Arguments[0]){
|
|
return $Arguments[1]
|
|
}
|
|
|
|
return $Arguments[0]
|
|
}
|
|
"if" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 3
|
|
if(ConvertTo-ConfigurationDataExpressionBoolean -Value $Arguments[0]){
|
|
return $Arguments[1]
|
|
}
|
|
|
|
return $Arguments[2]
|
|
}
|
|
"equals" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return $Arguments[0] -eq $Arguments[1]
|
|
}
|
|
"notequals" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return $Arguments[0] -ne $Arguments[1]
|
|
}
|
|
"and" {
|
|
Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
foreach($Argument in @($Arguments)){
|
|
if(-not (ConvertTo-ConfigurationDataExpressionBoolean -Value $Argument)){
|
|
return $false
|
|
}
|
|
}
|
|
|
|
return $true
|
|
}
|
|
"or" {
|
|
Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
foreach($Argument in @($Arguments)){
|
|
if(ConvertTo-ConfigurationDataExpressionBoolean -Value $Argument){
|
|
return $true
|
|
}
|
|
}
|
|
|
|
return $false
|
|
}
|
|
"not" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return -not (ConvertTo-ConfigurationDataExpressionBoolean -Value $Arguments[0])
|
|
}
|
|
"tolower" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return ([string]$Arguments[0]).ToLowerInvariant()
|
|
}
|
|
"toupper" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return ([string]$Arguments[0]).ToUpperInvariant()
|
|
}
|
|
"firstindexof" {
|
|
Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return $Arguments[0]
|
|
}
|
|
"lastindexof" {
|
|
Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return $Arguments[$Arguments.Count - 1]
|
|
}
|
|
"indexof" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return ([string]$Arguments[0])[([int]$Arguments[1])].ToString()
|
|
}
|
|
"substring" {
|
|
if($Arguments.Count -eq 2){
|
|
return ([string]$Arguments[0]).Substring([int]$Arguments[1])
|
|
}
|
|
|
|
if($Arguments.Count -eq 3){
|
|
return ([string]$Arguments[0]).Substring([int]$Arguments[1], [int]$Arguments[2])
|
|
}
|
|
|
|
throw "Function [$Name] expects 2 or 3 arguments, but received [$($Arguments.Count)]."
|
|
}
|
|
"replace" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 3
|
|
return ([string]$Arguments[0]).Replace([string]$Arguments[1], [string]$Arguments[2])
|
|
}
|
|
"sanitizeName" {
|
|
if($Arguments.Count -eq 1){
|
|
return ConvertTo-ConfigurationDataSafeName -Value ([string]$Arguments[0]) -Separator "_"
|
|
}
|
|
|
|
if($Arguments.Count -eq 2){
|
|
return ConvertTo-ConfigurationDataSafeName -Value ([string]$Arguments[0]) -Separator ([string]$Arguments[1])
|
|
}
|
|
|
|
throw "Function [$Name] expects 1 or 2 arguments, but received [$($Arguments.Count)]."
|
|
}
|
|
"normalizeseparator" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return Normalize-ConfigurationDataSeparator -Value ([string]$Arguments[0]) -Separator ([string]$Arguments[1])
|
|
}
|
|
"prefixifnotempty" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
if(Test-ConfigurationDataValueIsEmpty -Value $Arguments[0]){
|
|
return ""
|
|
}
|
|
|
|
return ([string]$Arguments[1]) + ([string]$Arguments[0])
|
|
}
|
|
"suffixifnotempty" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
if(Test-ConfigurationDataValueIsEmpty -Value $Arguments[0]){
|
|
return ""
|
|
}
|
|
|
|
return ([string]$Arguments[0]) + ([string]$Arguments[1])
|
|
}
|
|
"contains" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
if($Arguments[0] -is [System.Array] -and $Arguments[0] -isnot [string]){
|
|
return @($Arguments[0]) -contains $Arguments[1]
|
|
}
|
|
|
|
return ([string]$Arguments[0]).Contains([string]$Arguments[1])
|
|
}
|
|
"startswith" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return ([string]$Arguments[0]).StartsWith([string]$Arguments[1], [System.StringComparison]::OrdinalIgnoreCase)
|
|
}
|
|
"endswith" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return ([string]$Arguments[0]).EndsWith([string]$Arguments[1], [System.StringComparison]::OrdinalIgnoreCase)
|
|
}
|
|
"split" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return ,(([string]$Arguments[0]).Split([string[]]@([string]$Arguments[1]), [System.StringSplitOptions]::None))
|
|
}
|
|
"join" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return (@($Arguments[0]) | ForEach-Object { [string]$_ }) -join ([string]$Arguments[1])
|
|
}
|
|
"joinnotempty" {
|
|
Assert-ConfigurationDataExpressionMinimumArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
$Separator = [string]$Arguments[0]
|
|
$Items = @()
|
|
|
|
foreach($Argument in @($Arguments | Select-Object -Skip 1)){
|
|
foreach($Item in @($Argument)){
|
|
if($null -ne $Item -and -not [string]::IsNullOrWhiteSpace([string]$Item)){
|
|
$Items += [string]$Item
|
|
}
|
|
}
|
|
}
|
|
|
|
return $Items -join $Separator
|
|
}
|
|
"take" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return ,(@($Arguments[0]) | Select-Object -First ([int]$Arguments[1]))
|
|
}
|
|
"skip" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 2
|
|
return ,(@($Arguments[0]) | Select-Object -Skip ([int]$Arguments[1]))
|
|
}
|
|
"first" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return @($Arguments[0])[0]
|
|
}
|
|
"last" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
$Items = @($Arguments[0])
|
|
return $Items[$Items.Count - 1]
|
|
}
|
|
"unique" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return ,(@($Arguments[0]) | Select-Object -Unique)
|
|
}
|
|
"sort" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return ,(@($Arguments[0]) | Sort-Object)
|
|
}
|
|
"trim" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return ([string]$Arguments[0]).Trim()
|
|
}
|
|
"trimstart" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return ([string]$Arguments[0]).TrimStart()
|
|
}
|
|
"trimend" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
return ([string]$Arguments[0]).TrimEnd()
|
|
}
|
|
"padleft" {
|
|
if($Arguments.Count -eq 2){
|
|
return ([string]$Arguments[0]).PadLeft([int]$Arguments[1])
|
|
}
|
|
|
|
if($Arguments.Count -eq 3){
|
|
return ([string]$Arguments[0]).PadLeft([int]$Arguments[1], ([string]$Arguments[2])[0])
|
|
}
|
|
|
|
throw "Function [$Name] expects 2 or 3 arguments, but received [$($Arguments.Count)]."
|
|
}
|
|
"padright" {
|
|
if($Arguments.Count -eq 2){
|
|
return ([string]$Arguments[0]).PadRight([int]$Arguments[1])
|
|
}
|
|
|
|
if($Arguments.Count -eq 3){
|
|
return ([string]$Arguments[0]).PadRight([int]$Arguments[1], ([string]$Arguments[2])[0])
|
|
}
|
|
|
|
throw "Function [$Name] expects 2 or 3 arguments, but received [$($Arguments.Count)]."
|
|
}
|
|
"length" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
if($Arguments[0] -is [System.Array] -and $Arguments[0] -isnot [string]){
|
|
return @($Arguments[0]).Count
|
|
}
|
|
|
|
return ([string]$Arguments[0]).Length
|
|
}
|
|
"empty" {
|
|
Assert-ConfigurationDataExpressionArgumentCount -Name $Name -Arguments $Arguments -Count 1
|
|
if($null -eq $Arguments[0]){
|
|
return $true
|
|
}
|
|
|
|
if($Arguments[0] -is [System.Array] -and $Arguments[0] -isnot [string]){
|
|
return @($Arguments[0]).Count -eq 0
|
|
}
|
|
|
|
return [string]$Arguments[0] -eq ""
|
|
}
|
|
default {
|
|
throw "Unsupported configuration data expression function [$Name]."
|
|
}
|
|
}
|
|
}
|