Framework/Abstracts/FileOutputBase.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
156
157
158
159
160
161
Set-StrictMode -Version Latest 
class FileOutputBase: ListenerBase
{
    static [string] $ETCFolderPath = "Etc";

    [string] $FilePath = "";
    [string] $FolderPath = "";
    #[string] $BasePath = "";
    hidden [string[]] $BasePaths = @();
    
    FileOutputBase()
    {   
        [Helpers]::AbstractClass($this, [FileOutputBase]);
    }     

    hidden [void] AddBasePath([string] $path)
    {
        if(-not [string]::IsNullOrWhiteSpace($path))
        {
            $path = $global:ExecutionContext.InvokeCommand.ExpandString($path);
            if(Test-Path -Path $path)
            {
                $this.BasePaths += $path;
            }
        }
    }

    [void] SetRunIdentifier([AzSKRootEventArgument] $arguments)
    {
        ([ListenerBase]$this).SetRunIdentifier($arguments);

        $this.AddBasePath([ConfigurationManager]::GetAzSKSettings().OutputFolderPath);
        $this.AddBasePath([ConfigurationManager]::GetAzSKConfigData().OutputFolderPath);
        $this.AddBasePath([Constants]::AzSKLogFolderPath);
    }

    hidden [string] CalculateFolderPath([SubscriptionContext] $context, [string] $subFolderPath, [int] $pathIndex)
    {
        $outputPath = "";
        if($context -and (-not [string]::IsNullOrWhiteSpace($context.SubscriptionName)) -and (-not [string]::IsNullOrWhiteSpace($context.SubscriptionId)))
        {
            $isDefaultPath = $false;
            if($pathIndex -lt $this.BasePaths.Count)
            {
                $basePath = $this.BasePaths.Item($pathIndex);
            }
            else
            {
                $isDefaultPath = $true;
                $basePath = [Constants]::AzSKLogFolderPath;
            }

            if (-not $basePath.EndsWith("\")) {
                $basePath += "\";
            }

            $outputPath = $basePath + [Constants]::AzSKModuleName + "Logs\"

            $sanitizedPath = [Helpers]::SanitizeFolderName($context.SubscriptionName);
            if ([string]::IsNullOrEmpty($sanitizedPath)) {
                $sanitizedPath = $context.SubscriptionId;
            }

            $runPath = $this.RunIdentifier;
            $commandMetadata = $this.GetCommandMetadata();

            if($commandMetadata)
            {
                $runPath += "_" + $commandMetadata.ShortName;
            }

            if ([string]::IsNullOrEmpty($sanitizedPath)) {
                $outputPath += ("Default\{0}\" -f $runPath);            
            }
            else {
                $outputPath += ("Sub_{0}\{1}\" -f $sanitizedPath, $runPath);            
            }

            if (-not [string]::IsNullOrEmpty($subFolderPath)) {
                $sanitizedPath = [Helpers]::SanitizeFolderName($subFolderPath);
                if (-not [string]::IsNullOrEmpty($sanitizedPath)) {
                    $outputPath += ("{0}\" -f $sanitizedPath);            
                }   
            }

            if(-not (Test-Path $outputPath))
            {
                try
                {
                    mkdir -Path $outputPath -ErrorAction Stop | Out-Null
                }
                catch
                {
                    $outputPath = "";
                    if(-not $isDefaultPath)
                    {
                        $outputPath = $this.CalculateFolderPath($context, $subFolderPath, $pathIndex + 1);
                    }
                }
            }
        }
        return $outputPath;
    }

    [string] CalculateFolderPath([SubscriptionContext] $context, [string] $subFolderPath)
    {
        return $this.CalculateFolderPath($context, $subFolderPath, 0);
    }

    [string] CalculateFolderPath([SubscriptionContext] $context)
    {
        return $this.CalculateFolderPath($context, "");
    }

    [void] SetFolderPath([SubscriptionContext] $context)
    {
        $this.SetFolderPath($context, "");
    }

    [void] SetFolderPath([SubscriptionContext] $context, [string] $subFolderPath)
    {
        $this.FolderPath = $this.CalculateFolderPath($context, $subFolderPath);
    }

    [string] CalculateFilePath([SubscriptionContext] $context, [string] $fileName)
    {
        return $this.CalculateFilePath($context, "", $fileName);
    }

    [string] CalculateFilePath([SubscriptionContext] $context, [string] $subFolderPath, [string] $fileName)
    {
        $outputPath = "";
        $this.SetFolderPath($context, $subFolderPath); 
        if ([string]::IsNullOrEmpty($this.FolderPath)) {
            return $outputPath;
        }

        $outputPath = $this.FolderPath;
        if (-not $outputPath.EndsWith("\")) {
            $outputPath += "\";
        }
        if ([string]::IsNullOrEmpty($fileName)) {
            $outputPath += $(Get-Date -format "yyyyMMdd_HHmmss") + ".LOG";
        }
        else {
            $outputPath += $fileName;            
        }
        return $outputPath;
    }

    [void] SetFilePath([SubscriptionContext] $context, [string] $fileName)
    {
        $this.SetFilePath($context, "", $fileName);
    }

    [void] SetFilePath([SubscriptionContext] $context, [string] $subFolderPath, [string] $fileName)
    {
        $this.FilePath = $this.CalculateFilePath($context, $subFolderPath, $fileName);
    }
}