It was just Saturday—it’s been a few weeks now, actually—that I wrote a post proclaiming to be back. Back to writing about PowerShell, that is. Why not take the first script I wrote in my new position and share it? It’s possible it has some concepts that might be helpful for readers.
The first thing I want to mention is that I hate writing scripts. Huh!? What I mean by that, is that I prefer to write functions. That didn’t happen my first time out in this position, as you’ll see, and I’m going to be okay with it. A one-off script may have a purpose. I stayed away from a function (and therefore a module [maybe], working with profile scripts [potentially], etc.). I’ll live with it.
Let’s break the script up into sections and explain what’s happening in each. Keep in mind that this isn’t perfect and there are places where I would make changes after having looked over this a couple of times. I’ll be sure to mention those toward the bottom of the post. Okay, let’s do this! I’ll put the script back together into a single, code block further below.
The beginning of the script creates two parameters: Properties and Output. Properties can accept multiple string values,—notice the []—and we’ll see that in the upcoming examples. Output can accept one string value of three predetermined values. Those are Console, GridView, and CsvFile; Console is the default parameter value.
Param (
[Parameter()]
[string[]]$Properties,
[Parameter()]
[ValidateSet('Console','GridView','CsvFile')]
[string]$Output = 'Console'
)
Next, we create a path to a flat file called userlist.txt. This file will contain Active Directory Display Names (DisplayName). By using the $PSScriptRoot variable, all we have to do is keep our script and the text file in the same location/folder in order for it to work correctly.
Once the $Path variable is set, we attempt to run a Get-Content command against the values in the file, storing these in the $Userlist variable. If for some reason the file isn’t in place, the script will make use of the catch block of our try-catch to indicate to the user that the file can’t be located.
$Path = "$PSScriptRoot\userlist.txt"
try {
$Userlist = Get-Content -Path $Path -ErrorAction Stop
} catch {
Write-Error -Message "Unable to locate $Path."
}
Following that, we set our $TotalProperties variable to three Active Directory user properties we know we want. Then, if any values have been passed in using the Properties parameter, we combine those with the three properties already in the $TotalProperties variable.
$TotalProperties = @('DisplayName','EmployeeNumber','SamAccountName')
if ($Properties) {
$TotalProperties = $TotalProperties + $Properties
}
Moving forward, we set up foreach language construct in order to loop through each user in the $Userlist variable. Remember, this variable was populated by our Get-Content command earlier. For each loop iteration, we are adding a PSCustomObject to our $Users—plural— variable. Normally, I wouldn’t store each value in a variable and instead just pump it out right there, but the script includes some output options that we’ll see next.
foreach ($User in $Userlist) {
$Users += [PSCustomObject]@(
Get-ADUser -Filter "DisplayName -eq '$User'" -Properties $TotalProperties |
Select-Object -Property $TotalProperties
)
}
Finally, we consider the output option the user either defaulted to, or didn’t. If they included the Output parameter with GridView, we pipe our $Users variable to OutGridView. If they included the Output parameter with CSVFile, we pipe out $Users variable to Export-Csv, saving them in a CSV file, and then open our saved CSV file. If they didn’t include the Output parameter, or they did with the Console value, then we display the results directly in the console. That’s it.
Switch ($Output) {
GridView {$Users | Out-GridView -Title Users}
CsvFile {
$Users.GetEnumerator() |
Export-Csv -NoTypeInformation -Path "$PSScriptRoot\$(Get-Date -Format FileDateTime -OutVariable NewFileOutput).csv"
Invoke-Item -Path "$PSScriptRoot\$NewFileOutput.csv"
}
Default {$Users | Format-Table -AutoSize}
}
Although I took the base code from someone’s previously written script, this really is still much of a 1.0.0 version. Knowing that, there are some changes I might make; it’s not perfect, but it’ll get the job done.
- While it’s not vital, I kind of wish I used a different variable name for
$Path- It’s a path, sure, but to a specific file
- Perhaps
$FilePath,$UserFile, or$UserFilePath- It could’ve been more specific
- Ensure properties passed in via the Properties parameter are valid for an Active Directory user
- If someone sends in properties that don’t exist for an Active Directory user, it’s going to cause problems
- Maybe check a known user, gather all the possible properties, and compare
- (Or) Maybe wrap some error checking without having to do any property compare operation
- If someone sends in properties that don’t exist for an Active Directory user, it’s going to cause problems
- Don’t use
Defaultin theSwitchlanguage construct- It’s not necessary, as the Output parameter will only accept three possible values
Defaultcould’ve been replaced withConsole
Here are a few examples followed by the full PowerShell code in a single, code block.
I’ve redacted information from each of these images. There’s something that’s vital to know about each, however. In front of the full path (all the images but the last one), is the & operator. This is called the invocation or call operator. It informs PowerShell that everything after it should be treated as a command and that it’s not just a long, string value.
This example invokes the script without any parameters, pulling in two users from the userlist.txt file.
This example invokes the script and includes two additional Active Directory properties, which are then also included in the output.
This example does the same as the first one, however, it opens the results using the Out-GridView cmdlet.
This one opens the results using whatever program—Excel in my case—is associated with CSV files. This option is saving the file to disk, so keep that in mind, as it has no cleanup features.
This final example is included to show that it works when you’re inside the same directory as the script and text file. It also includes multiple parameters being included at the same time. You might know you can do it, but my at-work audience may not have—I’m not sure. As we’re in the directory with the script, you can actually see the inclusion of the invocation operator.
And finally, all the code in a single code block.
Param (
[Parameter()]
[string[]]$Properties,
[Parameter()]
[ValidateSet('Console','GridView','CsvFile')]
[string]$Output = 'Console'
)
$Path = "$PSScriptRoot\userlist.txt"
try {
$Userlist = Get-Content -Path $Path -ErrorAction Stop
} catch {
Write-Error -Message "Unable to locate $Path."
}
$TotalProperties = @('DisplayName','EmployeeNumber','SamAccountName')
if ($Properties) {
$TotalProperties = $TotalProperties + $Properties
}
foreach ($User in $Userlist) {
$Users += [PSCustomObject]@(
Get-ADUser -Filter "DisplayName -eq '$User'" -Properties $TotalProperties |
Select-Object -Property $TotalProperties
)
}
Switch ($Output) {
GridView {$Users | Out-GridView -Title Users}
CsvFile {
$Users.GetEnumerator() |
Export-Csv -NoTypeInformation -Path "$PSScriptRoot\$(Get-Date -Format FileDateTime -OutVariable NewFileOutput).csv"
Invoke-Item -Path "$PSScriptRoot\$NewFileOutput.csv"
}
Default {$Users | Format-Table -AutoSize}
}
