functions/configuration/Import-PSFConfig.ps1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
function Import-PSFConfig
{
<#
 .SYNOPSIS
  Imports a json configuration file into the configuration system.
  
 .DESCRIPTION
  Imports a json configuration file into the configuration system.
  
 .PARAMETER Path
  The path to the json file to import.
  
 .PARAMETER ModuleName
  Import configuration items specific to a module from the default configuration paths.
  
 .PARAMETER ModuleVersion
  The configuration version of the module-settings to load.
  
 .PARAMETER Scope
  Where to import the module specific configuration items form.
  Only file-based scopes are supported for this.
  By default, all locations are queried, with user settings beating system settings.
  
 .PARAMETER IncludeFilter
  If specified, only elements with names that are similar (-like) to names in this list will be imported.
  
 .PARAMETER ExcludeFilter
  Elements that are similar (-like) to names in this list will not be imported.
  
 .PARAMETER Peek
  Rather than applying the setting, return the configuration items that would have been applied.
  
 .PARAMETER EnableException
  This parameters disables user-friendly warnings and enables the throwing of exceptions.
  This is less user friendly, but allows catching exceptions in calling scripts.
  
 .EXAMPLE
  PS C:\> Import-PSFConfig -Path '.\config.json'
   
  Imports the configuration stored in '.\config.json'
  
 .EXAMPLE
  PS C:\> Import-PSFConfig -ModuleName mymodule
  
  Imports all the module specific settings that have been persisted in any of the default file system paths.
#>

    [CmdletBinding(DefaultParameterSetName = "Path")]
    param (
        [Parameter(Mandatory = $true, ValueFromPipeline = $true, ParameterSetName = "Path")]
        [PsfValidateScript({ Test-Path $args[0] }, ErrorMessage = "Could not validate path. Make sure the file {0} exists!")]
        [string[]]
        $Path,
        
        [Parameter(ParameterSetName = "ModuleName", Mandatory = $true)]
        [string]
        $ModuleName,
        
        [Parameter(ParameterSetName = "ModuleName")]
        [int]
        $ModuleVersion = 1,
        
        [Parameter(ParameterSetName = "ModuleName")]
        [PSFramework.Configuration.ConfigScope]
        $Scope = "FileUserLocal, FileUserShared, FileSystem",
        
        [Parameter(ParameterSetName = "Path")]
        [string[]]
        $IncludeFilter,
        
        [Parameter(ParameterSetName = "Path")]
        [string[]]
        $ExcludeFilter,
        
        [Parameter(ParameterSetName = "Path")]
        [switch]
        $Peek,
        
        [switch]
        $EnableException
    )
    
    begin
    {
        Write-PSFMessage -Level InternalComment -Message "Bound parameters: $($PSBoundParameters.Keys -join ", ")" -Tag 'debug','start','param'
    }
    process
    {
        #region Explicit Path
        foreach ($item in $Path)
        {
            try { $data = Read-PsfConfigFile -Path $item -ErrorAction Stop }
            catch { Stop-PSFFunction -Message "Failed to import $item" -EnableException $EnableException -Tag 'fail', 'import' -ErrorRecord $_ -Continue -Target $item }
            
            :element foreach ($element in $data)
            {
                #region Exclude Filter
                foreach ($exclusion in $ExcludeFilter)
                {
                    if ($element.FullName -like $exclusion)
                    {
                        continue element
                    }
                }
                #endregion Exclude Filter
                
                #region Include Filter
                if ($IncludeFilter)
                {
                    $isIncluded = $false
                    foreach ($inclusion in $IncludeFilter)
                    {
                        if ($element.FullName -like $inclusion)
                        {
                            $isIncluded = $true
                            break
                        }
                    }
                    
                    if (-not $isIncluded) { continue }
                }
                #endregion Include Filter
                
                if ($Peek) { $element }
                else
                {
                    try
                    {
                        if (-not $element.KeepPersisted) { Set-PSFConfig -FullName $element.FullName -Value $element.Value -EnableException }
                        else { Set-PSFConfig -FullName $element.FullName -Value ([PSFramework.Configuration.ConfigurationHost]::ConvertFromPersistedValue($element.Value, $element.Type)) -EnableException }
                    }
                    catch
                    {
                        Stop-PSFFunction -Message "Failed to set '$($element.FullName)'" -ErrorRecord $_ -EnableException $EnableException -Tag 'fail', 'import' -Continue -Target $item
                    }
                }
            }
        }
        #endregion Explicit Path
        
        if ($ModuleName)
        {
            $data = Read-PsfConfigPersisted -Module $ModuleName -Scope $Scope -ModuleVersion $ModuleVersion
            
            foreach ($value in $data.Values)
            {
                if (-not $value.KeepPersisted) { Set-PSFConfig -FullName $value.FullName -Value $value.Value -EnableException:$EnableException}
                else { Set-PSFConfig -FullName $value.FullName -Value ([PSFramework.Configuration.ConfigurationHost]::ConvertFromPersistedValue($value.Value, $value.Type)) -EnableException:$EnableException }
            }
        }
    }
    end
    {
    
    }
}