PowerShell Scripts

Commented Issue: enable-mailbox overwrites AD mail attribute

rroman81 — Wed, 03 Sep 2008 21:51:24 GMT

Is there a way to prevent the enable-mailbox cmdlet from overwriting the [mail] field in Active Directory?
If not, why is this?
This AD field doesn't appear to be used by Exch2007,
Also, Enable-Mailbox is supposed to take the PrimarySmtpAddress
parameter, but it throws an exception.
I'm using powershell version 1 on win2003
Comments: ** Comment from web user: rroman81 **

I just tested on Ex2k7 SP1, it appears enable-mailbox does modify mail attribute based on the EAP but effectively removes the mailbox in policy participation and sets the PrimarySmtpAddress value to proxyAddresses multi-valued attribute. Are you following up on this issue somewhere else? I'd expect mail and proxyAddresses "SMTP:*" be synched based on exchange requirements.

New Post: Easily build XML file from a specific folder

Mike71 — Thu, 28 Aug 2008 07:58:50 GMT

#Mike71
#email: djmid71@gmail.com

echo "<?xml version=""1.0"" encoding='UTF-8'?>" >> c:\myfile.xml ; echo '<list>' >> c:\myfile.xml ;foreach( $file in get-childitem -exclude "xmlbuilder.ps1") {echo '<dir>' >> c:\myfile.xml; $file.name >> c:\myfile.xml ; echo '</dir>' >> c:\myfile.xml }; echo '</list>' >> c:\myfile.xml

"All Done!"
"Your xml is located on C:\"

New Post: Get-Tail

congling — Sun, 17 Aug 2008 17:21:17 GMT

#while($line = $reader.ReadLine())
# if the line is empty, it'll break. So need to determine if $line is null
while(($line = $reader.ReadLine()) -ne $null)
{
	$lines += ,$line
}

New Post: No Windows PowerShell Snap-ins are available for version 1

MikeNaho — Mon, 11 Aug 2008 14:11:24 GMT

For anyone else who has a question about this:
My problem was that I needed MSScript control (which will not run on x64) and Microsoft.Exchange.Management.PowerShell.Admin(which only runs on x64).

You CAN use the 32 bit Exchange Server 2007 demo. The demo application will cease to function after 120 days, but the component will continue to work.
So, in the case that you need to use a legacy component like I did, install the 32 bit version of exchange server admin tools and set target to x86.

New Post: No Windows PowerShell Snap-ins are available for version 1

MikeNaho — Sat, 09 Aug 2008 00:41:50 GMT

I can partially answer my own question:
I was attempting to compile the apps and copy the exe's and dll's over the existing ones created by the InstallShield setup.
That did not work.
By setting the executable application platform and its dependants to x64 seems to work just fine.

Next problem:

app A uses assembly C
app B uses assembly C

assembly C needs to run x64 because it handles Exchange 2007 with Microsoft.Exchange.Management.PowerShell.Admin.dll.

app B runs x64 and works.
app A has other assemblies that apparently do not work in x64.

Is there a Mixed Mode option? I know we can't run an x64 assembly from a x86bit app, so app A will have to be an x64.

When App A runs, I get System.ApplicationException: Unable to connect to ActiveDirectory: Retrieving the COM class factory for component with CLSID {...} failed due to the following error: 80040154

So, a com dependency assembly is not registered in x64.

Any ideas?

New Post: No Windows PowerShell Snap-ins are available for version 1

MikeNaho — Fri, 08 Aug 2008 15:48:57 GMT

Could somebody please give me some help here??

I have to load the snappin Microsoft.Exchange.Management.PowerShell.Admin on

both 32 and 64 bit machines.

I understand why it works on a 32 bit machine with Microsoft Exchange Server 2007 Mgmt tools. Using this solution

is only a very temporary fix, as it seems only to come as a 120 day demo, with no registration option. And doesn't provide a solution for our 64 bit os customers.

Our app was originally set as x86.

All dependency dll's have platform target set to 'use any'.

This worked on all platforms until I had to add Exchange 2007 support, where I needed to call the 64 bit Microsoft.Exchange.Management.PowerShell.Admin dll.

Unfortunately, as you know, in the 32 bit enviornment of our app, the 32 bit version of powershell is called, for which there is no Microsoft.Exchange.Management.PowerShell.Admin plugin, hence the error 'no windows powershell snap-ins are available for version 1'.

I changing Target Platform of the app to x64 with dependecy dll's set to 'Use Any'.

I did have partial success. I was able to create the powershell runspace and load the 64 bit exchange plugin. Yeah!

Howerver, after successive attempts, I am now unable to reproduce the previous success.

On the 64 bit os, I get an error while starting the app. I receive the 'System.BadImageFormatExceptin: Could not load file or assembly.... or one of its dependencies. An attempt was made to load a program with an incorrect format.

The assembly that handles all powershell functions is a dependency of the main app.

Do they both have to have target platform set to x64?

I don't really understand the rule here.
Will I have to create two seperate applications, one for x64 and the other for 32 bit os ?

Mike

New Post: No Windows PowerShell Snap-ins are available for version 1

MikeNaho — Mon, 04 Aug 2008 20:29:33 GMT

Maybe this is the proper place for this question.
I never receive any response to requests here.

Anyway, I get this error when running my c# application on a 64 bit os.
It appears that the 32 bit powershell is being invoked rather than the 64 bit.
This same error appear when I attempt to add snap-in Microsoft.Exchange.Management.PowerShell.Admin.
I know that its a 64 bit app, but I don't know how to make my c# app use the correct version.
I've set the platform to x86 and x64, as well as any cpu, but it does not work.
I still get the error, "No Windows PowerShell Snap-ins are available for version 1".

I would really appreciate some help with this, as we've invested alot of time and resources to using Powershell.

Created Issue: 64 bit OS error : No Windows PowerShell Snap-ins are available for version 1

MikeNaho — Mon, 04 Aug 2008 18:04:28 GMT

Does someone know how to solve this? I have a component (Platform target x86) which runs fine on 32 bit os, but it seems to be calling the 32 bit version of Powershell, causing the error: No Windows PowerShell Snap-ins are available for version 1.
thank you for any answers.
Mike

Created Issue: enable-mailbox overwrites AD mail attribute

MikeNaho — Tue, 22 Jul 2008 22:46:16 GMT

New Post: Remote Computers Inventory

Meiron — Mon, 07 Jul 2008 16:49:02 GMT

AndrewTearle wrote:
## Icon calls need to be valid ...

## Written for Version 1 ? Seems to crash CTP 2 when in search of File ...

Didn't checked it on CTP2 ...
Works greate in Version 1

New Post: Remote Computers Inventory

AndrewTearle — Sun, 29 Jun 2008 23:36:54 GMT

## Icon calls need to be valid ...

## Written for Version 1 ? Seems to crash CTP 2 when in search of File ...

New Post: Remote Computers Inventory

Meiron — Sat, 28 Jun 2008 18:51:38 GMT

# ========================================================
#
#    Script Information
#
#   Title:           Remote Computer Inventory
#   Author:           Assaf Miron
#   Originally created:   21/06/2008
#   Original path:       ComputerInventory.PS1
#   Description:       Collects Remote Computer Data Using WMI and Registry Access
#                       Outputs all information to a Data Grid Form and to a CSV Log File
#
# ========================================================

#region Constructor
# Import Assembly
[void][System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
[void][System.Reflection.Assembly]::LoadWithPartialName("System.Drawing")

# Log File where the results are Saved
$LogFile = "C:\Monitoring\Test-Monitor.csv"
# Check to see if the Log File Directory exists
If((Test-Path ($LogFile.Substring(0,$logFile.LastIndexof("\")))) -eq $False)
{
   # Create The Directory
   New-Item ($LogFile.Substring(0,$logFile.LastIndexof("\"))) -Type Directory
}
#endregion

#region Form Creation

#~~< Form1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$Form1 = New-Object System.Windows.Forms.Form
$Form1.AutoSize = $TRUE
$Form1.ClientSize = New-Object System.Drawing.Size(522, 404)
$Form1.StartPosition = [System.Windows.Forms.FormStartPosition]::CenterScreen
$Form1.Text = "Computer Inventory"
#~~< Panel1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$Panel1 = new-object System.Windows.Forms.Panel
$Panel1.Dock = [System.Windows.Forms.DockStyle]::Fill
$Panel1.Location = new-object System.Drawing.Point(0, 24)
$Panel1.Size = new-object System.Drawing.Size(522, 380)
$Panel1.TabIndex = 20
$Panel1.Text = ""
#~~< btnRun >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$btnRun = New-Object System.Windows.Forms.Button
$btnRun.Enabled = $FALSE
$btnRun.Location = New-Object System.Drawing.Point(431, 30)
$btnRun.Size = New-Object System.Drawing.Size(75, 23)
$btnRun.TabIndex = 2
$btnRun.Text = "Run"
$btnRun.UseVisualStyleBackColor = $TRUE
$btnRun.add_Click({ RunScript($btnRun) })
#~~< Label1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$Label1 = New-Object System.Windows.Forms.Label
$Label1.AutoSize = $TRUE
$Label1.Location = New-Object System.Drawing.Point(12, 33)
$Label1.Size = New-Object System.Drawing.Size(159, 13)
$Label1.TabIndex = 15
$Label1.Text = "File containing Computer Names"
#~~< TextBox1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$TextBox1 = New-Object System.Windows.Forms.TextBox
$TextBox1.Location = New-Object System.Drawing.Point(177, 30)
$TextBox1.Size = New-Object System.Drawing.Size(161, 20)
$TextBox1.TabIndex = 0
$TextBox1.Text = ""
#~~< btnBrowse >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$btnBrowse = New-Object System.Windows.Forms.Button
$btnBrowse.Location = New-Object System.Drawing.Point(347, 30)
$btnBrowse.Size = New-Object System.Drawing.Size(75, 23)
$btnBrowse.TabIndex = 1
$btnBrowse.Text = "Browse"
$btnBrowse.UseVisualStyleBackColor = $TRUE
$btnBrowse.add_Click({ BrowseFile($btnBrowse) })
#~~< DataGridView1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$DataGridView1 = new-object System.Windows.Forms.DataGridView
$DataGridView1.Anchor = ([System.Windows.Forms.AnchorStyles]([System.Windows.Forms.AnchorStyles]::Top -bor [System.Windows.Forms.AnchorStyles]::Bottom -bor [System.Windows.Forms.AnchorStyles]::Left -bor [System.Windows.Forms.AnchorStyles]::Right))
$DataGridView1.ColumnHeadersHeightSizeMode = [System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode]::AutoSize
$DataGridView1.Location = New-Object System.Drawing.Point(12, 59)
$DataGridView1.Size = New-Object System.Drawing.Size(497, 280)
$DataGridView1.TabIndex = 4
$DataGridView1.ClipboardCopyMode = [System.Windows.Forms.DataGridViewClipboardCopyMode]::Disable
$DataGridView1.Text = ""
#~~< ProgressBar1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$ProgressBar1 = New-Object System.Windows.Forms.ProgressBar
$ProgressBar1.Anchor = ([System.Windows.Forms.AnchorStyles] ([System.Windows.Forms.AnchorStyles]::Bottom -bor [System.Windows.Forms.AnchorStyles]::Left -bor [System.Windows.Forms.AnchorStyles]::Right ))
$ProgressBar1.Location = New-Object System.Drawing.Point(12, 345)
$ProgressBar1.Size = New-Object System.Drawing.Size(410, 23)
$ProgressBar1.TabIndex = 5
$ProgressBar1.Text = ""
#~~< btnExit >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$btnExit = New-Object System.Windows.Forms.Button
$btnExit.Anchor = ([System.Windows.Forms.AnchorStyles]([System.Windows.Forms.AnchorStyles]::Bottom -bor [System.Windows.Forms.AnchorStyles]::Right))
$btnExit.DialogResult = [System.Windows.Forms.DialogResult]::Cancel
$btnExit.Location = New-Object System.Drawing.Point(431, 345)
$btnExit.Size = New-Object System.Drawing.Size(78, 23)
$btnExit.TabIndex = 3
$btnExit.Text = "Exit"
$btnExit.UseVisualStyleBackColor = $TRUE
$btnExit.add_Click({ CloseForm($btnExit) })
#~~< MenuStrip1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$MenuStrip1 = new-object System.Windows.Forms.MenuStrip
$MenuStrip1.Location = new-object System.Drawing.Point(0, 0)
$MenuStrip1.Size = new-object System.Drawing.Size(292, 24)
$MenuStrip1.TabIndex = 6
$MenuStrip1.Text = "MenuStrip1"
#~~< FileToolStripMenuItem >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$FileToolStripMenuItem = new-object System.Windows.Forms.ToolStripMenuItem
$FileToolStripMenuItem.Size = new-object System.Drawing.Size(35, 20)
$FileToolStripMenuItem.Text = "File"
#~~< OpenLogFileToolStripMenuItem >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$OpenLogFileToolStripMenuItem = new-object System.Windows.Forms.ToolStripMenuItem
$OpenLogFileToolStripMenuItem.Size = new-object System.Drawing.Size(152, 22)
$OpenLogFileToolStripMenuItem.Text = "Open Log File"
$OpenLogFileToolStripMenuItem.add_Click({Open-file($OpenLogFileToolStripMenuItem)})
#~~< ExitToolStripMenuItem >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$ExitToolStripMenuItem = new-object System.Windows.Forms.ToolStripMenuItem
$ExitToolStripMenuItem.Size = new-object System.Drawing.Size(152, 22)
$ExitToolStripMenuItem.Text = "Exit"
$ExitToolStripMenuItem.add_Click({CloseForm($ExitToolStripMenuItem)})
$FileToolStripMenuItem.DropDownItems.AddRange([System.Windows.Forms.ToolStripItem[]](@($OpenLogFileToolStripMenuItem, $ExitToolStripMenuItem)))
#~~< HelpToolStripMenuItem >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$HelpToolStripMenuItem = new-object System.Windows.Forms.ToolStripMenuItem
$HelpToolStripMenuItem.Size = new-object System.Drawing.Size(40, 20)
$HelpToolStripMenuItem.Text = "Help"
#~~< AboutToolStripMenuItem >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$AboutToolStripMenuItem = new-object System.Windows.Forms.ToolStripMenuItem
$AboutToolStripMenuItem.Size = new-object System.Drawing.Size(152, 22)
$AboutToolStripMenuItem.Text = "About"
$AboutToolStripMenuItem.add_Click({Show-About($AboutToolStripMenuItem)})
#~~< HowToToolStripMenuItem >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$HowToToolStripMenuItem = new-object System.Windows.Forms.ToolStripMenuItem
$HowToToolStripMenuItem.Size = new-object System.Drawing.Size(152, 22)
$HowToToolStripMenuItem.Text = "How To?"
$HowToToolStripMenuItem.add_Click({Show-HowTo($HowToToolStripMenuItem)})
$HelpToolStripMenuItem.DropDownItems.AddRange([System.Windows.Forms.ToolStripItem[]](@($AboutToolStripMenuItem, $HowToToolStripMenuItem)))
$MenuStrip1.Items.AddRange([System.Windows.Forms.ToolStripItem[]](@($FileToolStripMenuItem, $HelpToolStripMenuItem)))
$Panel1.Controls.Add($MenuStrip1)
$Panel1.Controls.Add($btnRun)
$Panel1.Controls.Add($Label1)
$Panel1.Controls.Add($TextBox1)
$Panel1.Controls.Add($btnBrowse)
$Panel1.Controls.Add($ProgressBar1)
$Panel1.Controls.Add($btnExit)
$Panel1.Controls.Add($DataGridView1)
$Panel1.Controls.Add($Menu)
$Form1.Controls.Add($Panel1)
#~~< Ping1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$Ping1 = New-Object System.Net.NetworkInformation.Ping
#~~< OpenFileDialog1 >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$OpenFileDialog1 = New-Object System.Windows.Forms.OpenFileDialog
$OpenFileDialog1.Filter = "Text Files|*.txt|CSV Files|*.csv|All Files|*.*"
$OpenFileDialog1.InitialDirectory = "C:"
$OpenFileDialog1.Title = "Open Computers File"
#~~< objNotifyIcon >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$objNotifyIcon = New-Object System.Windows.Forms.NotifyIcon
# Assign an Icon and Icon Type For the NotifyIcon Object
$objNotifyIcon.Icon = "D:\Assaf\Scripts\Icons\XP\people15.ico"
$objNotifyIcon.BalloonTipIcon = "Info"

#endregion

#region Functions

function out-DataTable
# Function Creates a New Data Table that will be set as the Data Source of the Data Grid View
# Thanks to /\/\o\/\/ http:\\thePowerShellGuy.com
{
   $dt = New-Object Data.datatable
   $First = $TRUE

   foreach ($item in $Input)
   {
       $DR = $DT.NewRow()
       $Item.PsObject.get_properties() | foreach {
           if ($first)
           {
               $Col = New-Object Data.DataColumn
               $Col.ColumnName = $_.Name.ToString()
           $DT.Columns.Add($Col) }
           if ($_.value -eq $null)
           {
               $DR.Item($_.Name) = "[empty]"
           }
           elseif ($_.IsArray) {
               $DR.Item($_.Name) = [string]::Join($_.value, ";")
           }
           else
           {
               $DR.Item($_.Name) = $_.value
           }
       }
       $DT.Rows.Add($DR)
       $First = $FALSE
   }

   return @(, ( $dt ))

}

function Join-Data
# Function Joins arrays and Strings to a Single Object with Members
# I Used the same principle of the Out-DataTable and converted it to Join Objects into one
# Using the Add-Member cmdlet. the Function writes to a predefiend object named $DataObject
{
   param($objName="") # This parameter is used for objects that don't have member other than Length like Strings
   foreach ($item in $Input)
   {
       $Item.PsObject.get_properties() | foreach{
           if ($_.value -eq $null)
           {
               $DataObject | Add-Member noteproperty $_.Name "[empty]"
           }
           elseif ($_.IsArray) {
               $DataObject | Add-Member noteproperty $_.Name [string]::Join($_.value, ";")
           }
           elseif ($objName -ne "") {
               $DataObject | Add-Member noteproperty $objName $Item
           }
           else
           {
               $DataObject | Add-Member noteproperty $_.Name $_.value -Force
           }
       }
   }

   return @(,$DataObject)
}

function Get-Reg {
# Function Connects to a remote computer Registry using the Parameters it recievs
   param(
       $Hive,
       $Key,
       $Value,
       $RemoteComputer="." # If not enterd Local Computer is Selected
   )
   # Connect to Remote Computer Registry
   $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey($Hive, $RemoteComputer)
   # Open Remote Sub Key
   $regKey= $reg.OpenSubKey($Key)
   if($regKey.ValueCount -gt 0) # check if there are Values
   {$regKey.GetValue($Value)} # Return Value
}

function Get-WMIItem {
# Function Retreives a specific Item from a remote computer's WMI
   param(
       $Class,
       $RemoteComputer=".", # If not enterd Local Computer is Selected
       $Item,
       $Query="", # If not enterd an empty WMI SQL Query is Entered
       $Filter="" # If not enterd an empty Filter is Entered
   )
   if ($Query -eq "") # No Specific WMI SQL Query
   {
       # Execute WMI Query, Return only the Requsted Items
       gwmi -Class $Class -ComputerName $RemoteComputer -Filter $Filter -Property $Item | Select $Item
   }
   else # User Entered a WMI SQL Query
   {gwmi -ComputerName $RemoteComputer -Query $Query | select $Item}
}

function Show-NotifyIcon {
# Function Controls the Notification Icon
# Changes its Title and Text
   param(
       $Title,
       $Text
   )
       # Change Notify Icon Title
       $objNotifyIcon.BalloonTipTitle = $Title
       # Change Notify Icon Text
       $objNotifyIcon.BalloonTipText = $Text
       # Show Notify Icon for 10 Secs
       $objNotifyIcon.Visible = $TRUE
       $objNotifyIcon.ShowBalloonTip(10000)
}

#endregion

#region Event Loop

function Main
# Main Function, Runs the Form
{
   [System.Windows.Forms.Application]::EnableVisualStyles()
   [System.Windows.Forms.Application]::Run($Form1)
}

#endregion

#region Event Handlers

function BrowseFile($object)
# Function for Running the OpenFileDialog
# Used when Clicking on the Browse Button
{
   $OpenFileDialog1.showdialog()
   $TextBox1.Text = $OpenFileDialog1.FileName
   $btnRun.Enabled = $TRUE
}

function Open-File( $object ){
# Function Open the Log File
   if(Test-Path $LogFile){
       Invoke-Item $LogFile
   }
}

function Show-PopUp
# Function for Showing Custom Pop up Forms
{
   param(
       $PopupTitle,
       $PopupText
       )
#~~< PopupForm >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$PopupForm = New-Object System.Windows.Forms.Form
$PopupForm.ClientSize = New-Object System.Drawing.Size(381, 356)
$PopupForm.ControlBox = $false
$PopupForm.ShowInTaskbar = $false
$PopupForm.StartPosition = [System.Windows.Forms.FormStartPosition]::CenterParent
$PopupForm.Text = $PopupTitle
#~~< PopupColse >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$PopupColse = New-Object System.Windows.Forms.Button
$PopupColse.Anchor = ([System.Windows.Forms.AnchorStyles]([System.Windows.Forms.AnchorStyles]::Bottom -bor [System.Windows.Forms.AnchorStyles]::Left -bor [System.Windows.Forms.AnchorStyles]::Right))
$PopupColse.DialogResult = [System.Windows.Forms.DialogResult]::Cancel
$PopupColse.Location = New-Object System.Drawing.Point(137, 321)
$PopupColse.Size = New-Object System.Drawing.Size(104, 23)
$PopupColse.TabIndex = 0
$PopupColse.Text = "Close"
$PopupColse.UseVisualStyleBackColor = $true
$PopupForm.AcceptButton = $PopupColse
$PopupForm.CancelButton = $PopupColse
#~~< PopupHeader >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$PopupHeader = New-Object System.Windows.Forms.Label
$PopupHeader.Font = New-Object System.Drawing.Font("Calibri", 15.75, ([System.Drawing.FontStyle]([System.Drawing.FontStyle]::Bold -bor [System.Drawing.FontStyle]::Italic)), [System.Drawing.GraphicsUnit]::Point, ([System.Byte](0)))
$PopupHeader.Location = New-Object System.Drawing.Point(137, 9)
$PopupHeader.Size = New-Object System.Drawing.Size(104, 23)
$PopupHeader.TabIndex = 2
$PopupHeader.Text = $PopupTitle
$PopupHeader.TextAlign = [System.Drawing.ContentAlignment]::MiddleCenter
#~~< PopUpTextArea >~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
$PopUpTextArea = New-Object System.Windows.Forms.Label
$PopUpTextArea.Anchor = ([System.Windows.Forms.AnchorStyles]([System.Windows.Forms.AnchorStyles]::Top -bor [System.Windows.Forms.AnchorStyles]::Bottom -bor [System.Windows.Forms.AnchorStyles]::Left -bor [System.Windows.Forms.AnchorStyles]::Right))
$PopUpTextArea.Location = New-Object System.Drawing.Point(12, 15)
$PopUpTextArea.Size = New-Object System.Drawing.Size(357, 265)
$PopUpTextArea.TabIndex = 1
$PopUpTextArea.Text = $PopupText
$PopUpTextArea.TextAlign = [System.Drawing.ContentAlignment]::MiddleLeft
$PopupForm.Controls.Add($PopupHeader)
$PopupForm.Controls.Add($PopUpTextArea)
$PopupForm.Controls.Add($PopupColse)

# Show Form
$PopupForm.Add_Shown({$PopupForm.Activate()})
[void]$PopupForm.showdialog()

}

function Show-About( $object ){
# Function Opens the About Page
$AboutText = @("
Script Title:                Remote Computer Inventory`n
Script Author:              Assaf Miron`n
Script Description:         Collects Remote Computer Data Using WMI and Registry Access Outputs all information to a Data Grid Form and to a CSV Log File.`n

Log File Name:   $LogFile")

Show-Popup -PopupTitle "About" -PopupText $AboutText
}

function Show-HowTo( $object ){
# Function Opens the Help Page
$HowToText = @("
1. Click on the Browse Button and select a TXT or a CSV File Containing Computer Names`n
2. After File is Selected click on the Run Button.`n
3. You will see a Notify Icon with the Coresponding Text.`n
4. The Script has begon collecting Remote Computer Inventory!`n
`nWhen The script is Done you will see a Popup Message and all data will be presented in the DataGrid.`n
** Because Poweshell works only in MTA mode there is no Option Copying the Data off the DataGrid...`n
5. All Data will be Exported to a Log File Located Here: $LogFile")

Show-Popup -PopupTitle "How To?" -PopupText $HowToText
}

function CloseForm($object)
# Function End the Program
{
   $Form1.Close()
}

function RunScript($object)
# Function Runs the Program and starts collecting data
{
# Create an Array of Computers Enterd in the Input File
$arrComputers = Get-Content -path $textBox1.Text -encoding UTF8

# Create an Empty Array to Contain all The Data of all Scaned Computers
$AllComputerInfo = @()

# Init the Progress bar to it's Maximum Value
if(($arrComputers -is [array]) -eq $FALSE) { $ProgressBar1.Maximum = 1 }
else { $ProgressBar1.Maximum = $arrComputers.Count }
$ProgressBar1.Step = 1 # Define the Progress bar Step value

# Scan all Computers in the Array $arrComputers
foreach ($strComputer in $arrComputers)
   {
       # Uses the Ping Command to check if the Computer is Alive
       $Alive=""
       $Alive = $Ping1.Send($strComputer).Status
       if($Alive -eq "Success"){
       Show-NotifyIcon -Title "Retriving Computer Information" -Text "Scanning $strComputer For Hardware Data"

       # Collect Computer Details from Win32_computersystem Using WMI
       $ComputerDet = Get-WMIItem -Class "Win32_computersystem" -RemoteComputer $strComputer -Item Caption,Domain,SystemType,Manufacturer,Model,NumberOfProcessors,TotalPhysicalMemory,UserName

       if($ComputerDet.Caption.Length -gt 1) # Check to See if Any data was Collected at all
       {

#region Total Memory Formating
           # Check Total Physical Memory Size and Format it acourdingly
           if($ComputerDet.TotalPhysicalMemory -ge 1GB){
           $ComputerDet.TotalPhysicalMemory = ($ComputerDet.TotalPhysicalMemory/1GB).Tostring("# GB")} # Format to GB
           else {$ComputerDet.TotalPhysicalMemory = ($ComputerDet.TotalPhysicalMemory/1MB).Tostring("# MB")} # Format to MB
#endregion

#region CPU Name
           # Collect CPU Name Using WMI
           $CPUName = Get-WMIItem -Class "Win32_Processor" -RemoteComputer $strComputer -Item Name
           # CPU Names Can Contain Multiple Values, in Order to Insert Them into the DataGridView I Divde them to String with ";" Seperators
           $arrCPUNames = @()
           foreach($CPU in $CPUName){
               $arrCPUNames = $CPU.Name.Trim()+";"+$arrCPUNames # the Sting of the CPU Name has White Space in The Begining - Trim It
               }
#endregion

#region Operating System Data
           # Collect Operating System and Service Pack Information Usin WMI
           $OS = Get-WMIItem -Class "win32_operatingsystem" -RemoteComputer $strComputer -Item Caption,csdversion
#endregion

#region Chassis Type
           # Collect Machine Chassis Using WMI
           $ChassisType = Get-WMIItem -Class Win32_SystemEnclosure -RemoteComputer $strComputer -Item ChassisTypes
           # Select Machine Chassis
           switch ($ChassisType.ChassisTypes) {
                   1 {$ChassisType = "Other"}
                   2 {$ChassisType = "Unknown"}
                   3 {$ChassisType = "Desktop"}
                   4 {$ChassisType = "Low Profile Desktop"}
                   5 {$ChassisType = "Pizza Box"}
                   6 {$ChassisType = "Mini Tower"}
                   7 {$ChassisType = "Tower"}
                   8 {$ChassisType = "Portable"}
                   9 {$ChassisType = "Laptop"}
                   10 {$ChassisType = "Notebook"}
                   11 {$ChassisType = "Handheld"}
                   12 {$ChassisType = "Docking Station"}
                   13 {$ChassisType = "All-in-One"}
                   14 {$ChassisType = "Sub-Notebook"}
                   15 {$ChassisType = "Space Saving"}
                   16 {$ChassisType = "Lunch Box"}
                   17 {$ChassisType = "Main System Chassis"}
                   18 {$ChassisType = "Expansion Chassis"}
                   19 {$ChassisType = "Sub-Chassis"}
                   20 {$ChassisType = "Bus Expansion Chassis"}
                   21 {$ChassisType = "Peripheral Chassis"}
                   22 {$ChassisType = "Storage Chassis"}
                   23 {$ChassisType = "Rack Mount Chassis"}
                   24 {$ChassisType = "Sealed- PC"}
                   default {$ChassisType = "Unknown"}
               }
#endregion

#region Automatic Updates
           # Collect the Automatic Updates Options Using Registry Access
           $AUOptions = Get-Reg -Hive LocalMachine -Key "SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update" -Value "AUOptions"

           # Collect the Automatic Updates Install Day Using Registry Access
           $AUDay = Get-Reg -Hive LocalMachine -Key "SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update" -Value "ScheduledInstallDay"

           # Collect the Automatic Updates Install Time Using Registry Access
           $AUTime = Get-Reg -Hive LocalMachine -Key "SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update" -Value "ScheduledInstallTime"
           if($AUOptions -eq $null){ # Automatic Updates is defined in Group Policy
               $AUOptions = Get-Reg -Hive LocalMachine -Key "SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" -Value "AUOptions"
               $AUDay = Get-Reg -Hive LocalMachine -Key "SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" -Value "ScheduledInstallDay"
               $AUTime = Get-Reg -Hive LocalMachine -Key "SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU" -Value "ScheduledInstallTime"
               }
           switch ($AUOptions){ # Check Wich Automatic Update Option is Selected
               1 {$AUClient = "Automatic Updates is Turnd off."}
               2 {$AUClient = "Notify for download and notify for install "}
               3 {$AUClient = "Auto download and notify for install "}
               4 {
                   switch ($AUDay) # Check on What day the Automatic Update Installs
                   {
                   0 {$InstDay = "Every Day"}
                   1 {$InstDay = "Sunday"}
                   2 {$InstDay = "Monday"}
                   3 {$InstDay = "Tuesday"}
                   4 {$InstDay = "Wensday"}
                   5 {$InstDay = "Thursday"}
                   6 {$InstDay = "Friday"}
                   7 {$InstDay = "Saturday"}
                   }
                   # Check on What time the Automatic Update Installs
                   if ($AUTime -le 12) { $AUTime = $AUTime.ToString() + " AM" } else { $AUTime = ($AUTime -12) + " PM" }
                       $AUClient = "Auto download and schedule the install - "+$InstDay+" "+$AUTime}
               Defualt {"Automatic Updates is not Set."} # No setting Collected
           }
#endregion

#region Computer Total Health
           # Collect Avialable Memory with WMI
           $AvialableMem = Get-WMIItem -Class "Win32_PerfFormattedData_PerfOS_Memory" -RemoteComputer $strComputer -Item "AvailableMBytes"

           # Collect Disk Queue,Queue Length, Processor time Data Using WMI
           $DiskQueue = Get-WMIItem -Class "Win32_PerfFormattedData_PerfDisk_LogicalDisk" -RemoteComputer $strComputer -Item CurrentDiskQueueLength
           $QueueLength = Get-WMIItem -Class "Win32_PerfFormattedData_PerfNet_ServerWorkQueues" -RemoteComputer $strComputer -Item QueueLength
           $Processor = Get-WMIItem -Class "Win32_PerfFormattedData_PerfOS_Processor" -RemoteComputer $strComputer -Item PercentProcessorTime

           $intHealth = 0 # integer for Collecting Computer Total Health
           # Using the Avialable Memory to Check Computer Totla Health
           if($AvialableMem.AvailableMBytes -lt 4) { $intHealth += 1; $strHealth += "Low Free Memory;" }
           # Using Current Disk Queue Length to Check Computer Total Health
           if($DiskQueue.CurrentDiskQueueLength -gt 2) { $intHealth += 1; $strHealth += "High Disk Queue;" }
           # Using Queue Length to Check Computer Total Health
           if($QueueLength.QueueLength -gt 4) { $intHealth += 1; $strHealth += "Long Disk Queue;" }
           # Using Processor Time(%) to Check Computer Total Health
           if($Processor.PercentProcessorTime -gt 90) { $intHealth += 1; $strHealth += "Processor Usage Over 90%;" }
           # If the integer is Bigger than 1 so the computer is Unhealthy, Describe Computer Problems
           # Else The Computer is Healthy
           if($intHealth -gt 1) { $ComputerTotalHealth = "UnHealthy, " + $strHealth } else { $ComputerTotalHealth = "Healthy" }
#endregion

#region Avialable Memory Formating
           # Format Avialable Memory MB
           $AvialableMem.AvailableMBytes = $AvialableMem.AvailableMBytes.ToString("# MB")
#endregion

#region Disk Drive Info
           # Collect Disk Drive Information Using WMI
           $DriveInfo = Get-WMIItem -Class "Win32_LogicalDisk" -RemoteComputer $strComputer -Item Caption,Size,FreeSpace
           # Format Every Drive Size and Free Space
           foreach($DRSize in $DriveInfo)
               { # Check Object Size and Format Acourdingly
                   if($DRSize.Size -ge 1GB){
                   $DRSize.Size = ($DRSize.Size/1GB).ToString("# GB") } # Format to GB
                   else { $DRSize.Size = ($DRSize.Size/1MB).ToString("# MB") } # Format to MB
                   if($DRSize.FreeSpace -ge 1GB){
                   $DRSize.FreeSpace = ($DRSize.FreeSpace/1GB).ToString("# GB") } # Format to GB
                   else { $DRSize.FreeSpace = ($DRSize.FreeSpace/1MB).ToString("# MB") } # Format to MB
               }
           # Disk Drives Can Contain Multiple Values, in Order to Insert Them into the DataGridView I divide them to Strings with ";" Seperators
           $arrDiskDrives = @()
           $arrDiskSize = @()
           $arrDiskFreeSpace = @()
           foreach($Drive in $DriveInfo){
               $arrDiskDrives = $Drive.Caption+";"+$arrDiskDrives
               $arrDiskSize = $Drive.Size+";"+$arrDiskSize
               $arrDiskFreeSpace = $Drive.FreeSpace+";"+$arrDiskFreeSpace
               }
#endregion

#region IP Addresses
           # Collect IPAddresses Using WMI, Filter only Enabled IPs
           $IPAddress = Get-WmiItem -Class "Win32_NetworkAdapterConfiguration" -Filter "IPEnabled = True" -RemoteComputer $strComputer -Item IPAddress
           # IPAddress Can Contain Multiple Values, in Order to Insert Them into the DataGridView I divide them to Strings with ";" Seperators
           $arrIPAddress = @()
           foreach($IP in $IPAddress){
               $arrIPAddress = $IP.IPAddress[0]+";"+$arrIPAddress
               }
#endregion

#region Time Zone
           # Collect Time Zone Information Using WMI
           $TimeZone = Get-WMIItem -Class "Win32_TimeZone" -RemoteComputer $strComputer -Item Bias,StandardName
           $TimeZone.Bias = $TimeZone.Bias/60
#endregion

#region System Restore Status
           # Collect System Restore Information Using Remote Registry
           $SysRestoreStatus = Get-Reg -Hive LocalMachine -RemoteComputer $strComputer -Key "SOFTWARE\Microsoft\Windows NT\CurrentVersion\SystemRestore" -Value "DisableSR"
           if ($SysRestoreStatus -eq 0) { $SysRestoreStatus = "Enabled" } else { $SysRestoreStatus = "Disabled" }
#endregion

#region Offline Files Status
           # Collect Offline Files Information Using Remote Registry
           $OfflineFolStatus = Get-Reg -Hive LocalMachine -RemoteComputer $strComputer -Key "SOFTWARE\Microsoft\Windows\CurrentVersion\NetCache" -Value "Enabled"
           if ($OfflineFolStatus -eq 1) { $OfflineFolStatus = "Enabled" } else { $OfflineFolStatus = "Disabled" }
#endregion

#region Printers
           # Collect Printers Information Using WMI
           $Printers = Get-WMIItem -Class "Win32_Printer" -RemoteComputer $strComputer -Item Name,PortName,Caption
           # Printers Contain Multiple Values, in Order to Insert Them into the DataGridView I divide them to Strings with ";" Seperators
           $arrPrinters = @()
           foreach($Printer in $Printers){
               $arrPrinters = $Printer.Name+"("+$Printer.PortName+");"+$arrPrinters
               }
#endregion

#region BIOS Serial Number
           # Collect BIOS Serial Number Using WMI
           $BIOSSN = Get-WMIItem -Class "Win32_Bios" -RemoteComputer $strComputer -Item SerialNumber
#endregion

#region Network Drives
           # Collect Network Drives Using WMI
           $NetDrives = Get-WMIItem -Query "Select * From Win32_LogicalDisk Where DriveType = 4" -RemoteComputer $strComputer -Item DeviceID,ProviderName
           # Network Drives Contain Multiple Values, in Order to Insert Them into the DataGridView I divide them to Strings with ";" Seperators
           $arrNetDrives = @()
           foreach($NetDrive in $NetDrives){
               $arrNetDrives = $NetDrive.DeviceID+"("+$NetDrive.ProviderName+");"+$arrNetDrives
               }
#endregion

#region Anti-Virus Client Data
           # Collect Anti-Virus Info Using Remote Registry
           $AVParentServer = Get-Reg -Hive LocalMachine -RemoteComputer $strComputer -Key "SOFTWARE\Intel\LANDesk\VirusProtect6\CurrentVersion" -Value "Parent"
           # Read the Anti-Virus Virus Definition File and Format it to an actual Date
           $VirusDefFile = "C:\Program Files\Common Files\Symantec Shared\VirusDefs\definfo.dat"
           If(Test-Path $VirusDefFile){
               $AVDefs = Get-Content $VirusDefFile | where { $_ -match "CurDefs" }
               $AVDefs = $AVDefs.Substring(8)
               $AVDefs = [datetime]($AVDefs.Substring(5,1) + "/" + $AVDefs.Substring(6,2) + "/" + $AVDefs.substring(0,4))
           }
           Else { $AVDefs = "" }
#endregion

#region Operating Systems Hotfixes
           # Collect all Hotfix Information Using WMI
           $HotFixes = Get-WMIItem -Class "Win32_QuickFixEngineering" -RemoteComputer $strComputer -Item Description,HotFixID,ServicePackInEffect
           # HotFixes Contain Multiple Values, in Order to Insert Them into the DataGridView I divide them to Strings with ";" Seperators
           $arrHotFixes = @()
           foreach($Fix in $HotFixes){
               if($Fix.Description -eq ""){
                   if($Fix.HotFixID -eq "File 1"){   $arrHotFixes = $Fix.ServicePackInEffect+";"+$arrHotFixes }
                   else { $arrHotFixes =$Fix.HotFixID+";"+$arrHotFixes }
               }
               else { $arrHotFixes = $Fix.Description+";"+$arrHotFixes }
           }
#endRegion

#region Remote Desktop Status
           # Collect Remote Desktop Protocol Status Using Remote Registry
           $RDPStatus = Get-Reg -Hive LocalMachine -remoteComputer $strComputer -Key "SYSTEM\CurrentControlSet\Control\Terminal Server" -Value "fAllowToGetHelp"
           if($RDPStatus -eq 0) {$RDPStatus = "Enabled" } else {$RDPStatus = "Disabled" }
#endregion

#region Remote Assistance Status
           # Collect Remote Assistance Status Using Remote Registry
           $RAStatus = Get-Reg -Hive LocalMachine -remoteComputer $strComputer -Key "SYSTEM\CurrentControlSet\Control\Terminal Server" -Value "fDenyTSConnections"
           if($RAStatus -eq 1) {$RAStatus = "Enabled" } else {$RAStatus = "Disabled" }
#endregion

           # Change the Notify Icon to Show Exporting Text
           Show-NotifyIcon -Text "Exporting $strComputer Information" -Title "Exporting..."

#region Check the Null Valued Paramters
           # If one of the Parameters are Null, Enter Space (looks better in the Table)
           if($ComputerDet -eq $Null){ $ComputerDet = " " }
           if($ChassisType -eq $Null){ $ChassisType = " " }
           if($BIOSSN -eq $Null){ $BIOSSN = " " }
           if($CPUName -eq $Null){ $CPUName = " " }
           if($AvialableMem -eq $Null){ $AvialableMem = " " }
           if($OS -eq $Null){ $OS = " " }
           if($SP -eq $Null){ $SP = " " }
           if($IPAddress -eq $Null){ $IPAddress = " " }
           if($HotFixes -eq $Null){ $HotFixes = " " }
           if($arrDiskDrives -eq $Null){ $arrDiskDrives=" " }
           if($arrDiskFreeSpace -eq $Null){ $arrDiskFreeSpace=" " }
           if($arrDiskSize -eq $Null){ $arrDiskSize=" " }
           if($RDPStatus -eq $Null){ $RDPStatus = " " }
           if($RAStatus -eq $Null){ $RAStatus = " " }
           if($AUClient -eq $Null){ $AUClient = " " }
           if($AVParentServer -eq $Null){ $AVParentServer = " " }
           if($AVDefs -eq $Null){ $AVDefs = " " }
           if($Printers -eq $Null){ $Printers = " " }
           if($ComputerTotalHealth -eq $Null){ $ComputerTotalHealth = " " }
#endregion

#region Creating the Data Object - $DataObject
           # Create an Empty psObject, $DataObjcet - Used by this Name in the Join-Data Function
           $DataObject = New-Object psobject

           # Join all the Data to the DataObject
           $ComputerDet | Join-Data # Contians Multiple Values, No need to Define a Name
           $ChassisType | Join-Data -objName "Chassis Type" # String with no Values - Define a Name
           $BIOSSN | Join-Data # Contians Multiple Values, No need to Define a Name
           $CPUName | Join-Data # Contians Multiple Values, No need to Define a Name
           $AvialableMem | Join-Data # Contians Multiple Values, No need to Define a Name
           $OS.Caption | Join-Data -objName "Operating System" # Contians Multiple Values, Caption Value canot be overwritten - Define a Name to a certian Value
           $OS.CsdVersion | Join-Data -objName "Service Pack" # String with no Values - Define a Name
           $arrIPAddress | Join-Data -objName "IP Addresses" # String with no Values - Define a Name
           $arrHotFixes | Join-Data -objName "HotFixes" # String with no Values - Define a Name
           $arrDiskDrives | Join-Data -objName "Disk Drives" # String with no Values - Define a Name
           $arrDiskSize | Join-Data -objName "Disk Size" # String with no Values - Define a Name
           $arrDiskFreeSpace | Join-Data -objName "Disk Free Space" # String with no Values - Define a Name
           $arrNetDrives | Join-Data -objName "Network Disks" # String with no Values - Define a Name
           $RDPStatus.ToString() | Join-Data -objName "Remote Desktop" # String with no Values - Define a Name
           $RAStatus.ToString() | Join-Data -objName "Remote Assistance" # String with no Values - Define a Name
           $AUClient | Join-Data -objName "Automatic Updates" # String with no Values - Define a Name
           $AVParentServer | Join-Data -objName "Anti-Virus Server" # String with no Values - Define a Name
           $AVDefs | Join-Data -objName "Anti-Virus Defs" # String with no Values - Define a Name
           $arrPrinters | Join-Data -objName "Printers" # String with no Values - Define a Name
           $ComputerTotalHealth | Join-Data -objName "Computer Totla Health" # String with no Values - Define a Name
#endregion

#region Exporting data
           $AllComputerInfo += $DataObject
           # Export the DataObject to the DataGridView Using the out-DataTable
           $DataTable = $AllComputerInfo | out-dataTable

           # Define Data Grid's Data Source to the DataTable we Created
           $DataGridView1.DataSource = $DataTable.psObject.baseobject
           $DataGridView1.Refresh() # Refresh the Table View in order to View the new lines

           # Export all the Data to the Log File
           $AllComputerInfo | Export-Csv -Encoding OEM -Path $LogFile
#endregion
       }
       }
       else { # No Ping to Computer
           $objNotifyIcon.BalloonTipIcon = "Error"
           Write-Warning "No Ping to $strComputer.`nNo Data was Collected"
           Show-NotifyIcon -Title "$strComputer is not avialable" -Text "No Ping to $strComputer.`n`tNo Data was Collected"
           $objNotifyIcon.BalloonTipIcon = "Info"
          }
       $ProgressBar1.PerformStep()
      }

#region Finishing - Script is Done

# Assign an Icon and Icon Type For the NotifyIcon Object
$objNotifyIcon.Icon = "D:\Assaf\Scripts\Icons\XP\people5.ico"
$objNotifyIcon.BalloonTipIcon = "Info"

# Show Notify Icon with Finishing Text
$objNotifyIcon.BalloonTipText = "Done!`nFile Saved in "+$LogFile
$objNotifyIcon.Visible = $TRUE
$objNotifyIcon.ShowBalloonTip(10000)

# Pop Up a Message box
$MSGObject = new-object -comobject wscript.shell
$MSGResult = $MSGObject.popup("Script Has Finished Running!",0,"I'm Done",0)

# Set to False so that the Notify Icon will Disapear after the Script is Done
$objNotifyIcon.Visible = $FALSE

#endregion
}

Main # This call must remain below all other event functions

#endregion

NEW POST: Use PS and ImgBurn to burn a set of ISO's.

89iroc — Tue, 27 May 2008 23:56:24 GMT

Read about it at my blog!

Or below:

Have you ever had a list of .ISO's that you needed to burn but were tired of setting each iso to burn individually. I often have this problem when I need to burn for instance the 5 iso's that vista shipped with. Below is a useful powershell script that will scan a directory or directories, find the ISO file, and ship it to ImgBurn. I have it setup so that it deletes the image. All you have to do is wait for the drive to eject your dvd.



function burn()

{

#get the files and ship them to burn-file

dir -recurse -include *.iso -path c:\,d:\,e:\ | foreach { burn-file $_.FullName }

}



function burn-file($filename)

{

#call img burn with the nessessary arguments

. "c:\Program Files\ImgBurn\ImgBurn.exe" /mode ISOWRITE /WAITFORMEDIA /start /close /DELETEIMAGE /EJECT /SRC $filename

#Wait for IMGBURN to finish (right now you can only have one open at a time)

while ( (get-process | where{$_.ProcessName -eq "ImgBurn"}) -ne $null)

{

#sleep for a bit to let the processor work on burning

Start-Sleep –s 10

#tell the user what file you are still working on

"waiting for $filename to complete"

}



}



#call the burn function

burn

NEW POST: Create .zip archive from command-line

Eduardo_M — Wed, 14 May 2008 14:41:48 GMT

The script below creates and populates a .zip from command line, using Windows Shell Automation. No extra packages are needed.
Everytime script is started, a new .zip archive is created. Append files to archive is not implemented.

<><>

            # Name: zip.ps1 

            # Author: Eduardo_M 

            # Created: 05/12/2008 

            

            param([string]$zipfilename=$(throw "ZIP archive name needed!"), 

            [string]$filetozip=$(throw "Supply the file(s) to compress (wildcards accepted)")) 

            trap [Exception] {break;} 

            

            #empyt zip file contents 

            $emptyzipfile=80,75,5,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0; 

            

            #create a new file with $ZIPFILENAME and copy the above array into it 

            $fmode = [System.IO.FileMode]::Create; 

            $zipfile = new-object -type System.IO.FileStream $zipfilename, $fmode; 

            $zipfile.Write($emptyzipfile,0,22); 

            $zipfile.Flush(); 

            $zipfile.Close(); 

            

            #open the new zip file as folder from Windows Shell Application 

            $shell=new-object -comobject Shell.Application; 

            $foldername=(ls $zipfile.Name).FullName; 

            $zipfolder=$shell.Namespace($foldername); 

            

            #Iterate files to zip, copying them to zip folder. 

            #In the process, the shell compress them 

            Write-Host "Compressing:"; 

            ls $filetozip| 

               foreach{ 

                  ("`t"+$_.fullname); 

                  $zipfolder.copyhere($_.fullname,20); 

                  [System.Threading.Thread]::Sleep(250); 

               } 

            $shell=$null; 

            $zipfolder=$null; </>

Example:
zip.ps1 test.zip afile.txt

NEW POST: GPO Scripting Setting in detail

junester — Wed, 26 Mar 2008 20:06:51 GMT

Looking for a script to dump all the setting from a GPO into a text file or can be able to be read. I do not want to export the GPO into either a XML or HTML file. Would like to do reporting on all GPOs in my environment for example how many GPOs are using proxy setting and what is in it or how many gpos are using restricted groups and what type of groups. The only thing I can find out there is dumping the GPOs to a XML or HTML.

NEW POST: How to access Pipe.Input from a script?

IgorMoochnick — Fri, 08 Feb 2008 20:35:28 GMT

I've integrated the PS into my project and trying to invoke a script, but, before hand, I'd like to populate a new pipeline with some data so the script can process it, but, after writing it to the pipeline, I can't access it from the script. How do I do this?

Here is the host code snippet:

foreach (PSObject obj in InputPipeline)
{
pipeline.Input.Write(obj);
}
pipeline.Input.Close();

OutputPipeline = pipeline.Invoke();

foreach (PSObject result in OutputPipeline)
{
// .... Do stuff here
}

And this is the list of different command permutations I've tried to run (let's say I want just to print the input items):

$input | % "data: $_"
% "data: $_"
"data: $_"

Nothing worked. Any ideas?

UPDATED WIKI: WMI

rsiddaw — Mon, 28 May 2007 13:46:54 GMT

WMI

Windows Management Instrumentation – WMI – is a powerful method of obtaining information about your systems. A WMI call can be executed on your local system or on a remote system (assuming that you have the correct level of permissions and that a firewall or some other device doesn't stop you). There are a mass of VBScripts available on the Microsoft TechNet Script Center most of which are concerned with retrieving information from one or more Windows systems.

One thing to be aware of with WMI is that it is evolving. WMI functionality is available in Windows Vista for instance that is not available in earlier versions. Full information on WMI is available in the WMI SDK at http://msdn2.microsoft.com/en-us/library/aa394582.aspx. WMI is organised as classes within namespaces. The default namespace is root\cimv2. This will be used unless stated otherwise.

PowerShell has excellent WMI support via the Get-WMIObject cmdlet. In order to see the scope of WMI try typing the following.

Get-WMIObject –list

You will see a very long list of WMI classes scrolling by. To make the list more manageable try –

Get-WMIObject –list | Where{$_.Name -like "*OperatingSystem*"}

Which will return a list of the classes containing "OperatingSystem" in their name. Win32_OperatingSystem looks like it could be interesting .

Get-WMIObject –class Win32_OperatingSystem

On its own doesn't seem to return much. Time to fall back on the Swiss army knife of PowerShell – get-member

Get-WMIObject -Class Win32_OperatingSystem | Get-Member

Now that's much better – lots of interesting properties become available now. Get-WMIObject has a –property parameter that lets you select which properties to display. Alternatively a Select-Object could be used. Lets just see how much we can do within Get-WMIObject.

Get-WMIObject -Class Win32_OperatingSystem -property TotalVirtualMemorySize, FreeVirtualmemory, LastBootUpTime

The TotalVirtualMemorySize and, FreeVirtualmemory properties are returned as kilobytes. The LastBootUpTime is in WMI date format. To convert it to a more readable format the .NET System.Management.ManagementDateTimeConverter can be used.

PS> $t = Get-WMIObject -Class Win32_OperatingSystem | Select LastBootUpTime 
PS> $t 
 
LastBootUpTime 
 
-------------- 
 
20070406072653.500000+060

When converted to a more readable format we get this.

PS> Get-WMIObject -Class Win32_OperatingSystem -property LastBootUpTime | foreach 
{[System.Management.ManagementDateTimeConverter]::ToDateTime($_.LastBootUpTime)} 
 
 
06 April 2007 07:26:53

The PowerShell Community extensions contain scripts that can be included in the pipeline for performing this calculation. It would be a simple matter to include the calculation in a cmdlet that was written to access this information.

One very useful addition to the WMI capability are scriptmethods for converting between the WMI time format and the "normal" data time format. These can be viewed as follows:

 
PS> $w1 = Get-WmiObject -class Win32_OperatingSystem
PS> $w1 | Get-Member
 
   TypeName: System.Management.ManagementObject#root\cimv2\Win32_OperatingSystem
Name                                      MemberType   Definition
----                                      ----------   ----------
Reboot                                    Method       System.Management.ManagementBaseObject Reboot()
SetDateTime                               Method       System.Management.ManagementBaseObject SetDateTime(System.Str...
Shutdown                                  Method       System.Management.ManagementBaseObject Shutdown()
Win32Shutdown                             Method       System.Management.ManagementBaseObject Win32Shutdown(System.I...
Win32ShutdownTracker                      Method       System.Management.ManagementBaseObject Win32ShutdownTracker(S...
 
etc etc
 
ConvertFromDateTime                       ScriptMethod System.Object ConvertFromDateTime();
ConvertToDateTime                         ScriptMethod System.Object ConvertToDateTime();
Delete                                    ScriptMethod System.Object Delete();
GetType                                   ScriptMethod System.Object GetType();
Put                                       ScriptMethod System.Object Put();

To get the LastBootUpTime

 
PS> $w1.ConvertToDateTime($w1.LastBootUpTime)
08 April 2007 10:05:35

WMI contains a wealth of information about your systems. The information returned from WMI is the sort that lends itself to be displayed by PowerGadgets or PowerGUI.

WMI Objects

A number of changes were made to the handling of WMI in PowerShell RC2 among them the introduction of the WMI accelarators including WMIClass which allows us to create a WMI instance

 
$w = [WMIClass]"Win32_OperatingSystem"
$w
$w | Get-Member
 
   TypeName: System.Management.ManagementClass#ROOT\cimv2\Win32_OperatingSystem
Name                   MemberType    Definition
----                   ----------    ----------
Name                   AliasProperty Name = __Class
__CLASS                Property      System.String __CLASS {get;set;}
__DERIVATION           Property      System.String[] __DERIVATION {get;set;}
__DYNASTY              Property      System.String __DYNASTY {get;set;}
__GENUS                Property      System.Int32 __GENUS {get;set;}
__NAMESPACE            Property      System.String __NAMESPACE {get;set;}
__PATH                 Property      System.String __PATH {get;set;}
__PROPERTY_COUNT       Property      System.Int32 __PROPERTY_COUNT {get;set;}
__RELPATH              Property      System.String __RELPATH {get;set;}
__SERVER               Property      System.String __SERVER {get;set;}
__SUPERCLASS           Property      System.String __SUPERCLASS {get;set;}
ConvertFromDateTime    ScriptMethod  System.Object ConvertFromDateTime();
ConvertToDateTime      ScriptMethod  System.Object ConvertToDateTime();
CreateInstance         ScriptMethod  System.Object CreateInstance();
Delete                 ScriptMethod  System.Object Delete();
GetRelatedClasses      ScriptMethod  System.Object GetRelatedClasses();
GetRelationshipClasses ScriptMethod  System.Object GetRelationshipClasses();
GetType                ScriptMethod  System.Object GetType();
Put                    ScriptMethod  System.Object Put();

What we get returned is an new WMI object that represents the Operating System but does not populate the values with those of the operating system on the machine.

 
$w.psbase.properties

will return a list of the properties that matches with those shown by Get-Member on $w1 earlier. All the examples I have found show WMIClass being used to instantiate a new object rather than access what is currently happening e.g.

 
$c = [WMIClass]"Win32_Process"
$c.Create("calc.exe")

will create a new process and start calc.exe in that process.

PowerShell and WMI make a very powerful, and in some cases, frightening combination. One of the parameters on the Get-WMIObject cmdlet is –filter. This allows a WMI Query Language WQL syntax clause to be used to further tighten the search. For example

$s = Get-WmiObject -class Win32_Service 
 
$s

Will return a list of services including the startmode and the current state i.e. if it is running or not. Note that Get-Service does not return the startmode.

This can be narrowed down to a particular service like this

PS> $s = Get-WmiObject -class Win32_Service -filter 'Name = "BITS"' 
 
PS> $s 
  
 
ExitCode : 0 
 
Name : BITS 
 
ProcessId : 1100 
 
StartMode : Auto 
 
State : Running 
 
Status : OK

Note that the startmode is set to auto

$s | get-member

Returns a number of methods including

PauseService
ResumeService
StartService
StopService
Together with a long list of properties e.g.

PS> $s.Description 
 
 
Transfers files in the background using idle network bandwidth. If the service is disabled, then any applications that 
depend on BITS, such as Windows Update or MSN Explorer, will be unable to automatically download programs and other information. 
 
PS>

Looking at the list of cmdlets with service as the noun you will no doubt recognise that the methods I listed above are available as cmdlets. This is where WMI gets a bit frightening

$s.stopservice() 
 
$s = Get-WmiObject -class Win32_Service -filter 'Name = "BITS"' 
 
$s 
 
ExitCode : 0 
 
Name : BITS 
 
ProcessId : 0 
 
StartMode : Auto 
 
State : Stopped 
 
Status : OK

Note that we have to refresh the object to see that the service has stopped. If you are running on Vista you will need to start PowerShell as the administrator. Using the WMI methods like this THERE IS NO WHATIF or CONFIRM options like you get with stop-service. This is where it is frightening – be very careful with WMI methods you do not have a safety net.

Querying WMI – WMISEARCHER.

This uses WMI Query Language – WQL – which is a subset of SQL to query WMI providers.

The following is a fairly standard activity using Get-Process

PS> Get-Process | Where{$_.Handles -gt 1000} 
 
  
 
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName 
 
------- ------ ----- ----- ----- ------ -- ----------- 
 
1162 37 82432 96292 286 60.48 1056 iexplore 
 
1337 50 31184 32124 169 1000 svchost 
 
1039 29 57072 90364 295 21.63 856 WINWORD 
 
1222 29 47876 36356 206 114.13 3780 wlmail

It is possible to return similar information using WMI directly.

$query = [WMISEARCHER] 'Select * from Win32_Process where Handlecount > 1000' 
 
$query.get()

This will return a lot of data.

In order to cut down the data returned then we can use

PS> $query.get() | Sort Handlecount | Format-Table Handlecount, WS, VM, Name -auto 
 
  
 
Handlecount WS VM Name 
 
----------- -- -- ---- 
 
1270 35749888 227962880 wlmail.exe 
 
1285 76976128 321593344 iexplore.exe 
 
1385 24543232 179179520 svchost.exe

By using get-process and WMISEARCHER we have two ways to find what we are looking for – this shows how flexible PowerShell can be. Other alternatives include piping the data into powerGadgets for display or using PowerGUI to display in a grid.

Further details on using WQL can be found here - http://msdn2.microsoft.com/en-us/library/aa392902.aspx

UPDATED WIKI: WMI

rsiddaw — Mon, 28 May 2007 13:45:18 GMT

WMI

Get-WMIObject –list

You will see a very long list of WMI classes scrolling by. To make the list more manageable try –

Get-WMIObject –list | Where{$_.Name -like "*OperatingSystem*"}

Which will return a list of the classes containing "OperatingSystem" in their name. Win32_OperatingSystem looks like it could be interesting .

Get-WMIObject –class Win32_OperatingSystem

On its own doesn't seem to return much. Time to fall back on the Swiss army knife of PowerShell – get-member

Get-WMIObject -Class Win32_OperatingSystem | Get-Member

Get-WMIObject -Class Win32_OperatingSystem -property TotalVirtualMemorySize, FreeVirtualmemory, LastBootUpTime

PS> $t = Get-WMIObject -Class Win32_OperatingSystem | Select LastBootUpTime 
PS> $t 
 
LastBootUpTime 
 
-------------- 
 
20070406072653.500000+060

When converted to a more readable format we get this.

PS> Get-WMIObject -Class Win32_OperatingSystem -property LastBootUpTime | foreach 
{[System.Management.ManagementDateTimeConverter]::ToDateTime($_.LastBootUpTime)} 
 
 
06 April 2007 07:26:53

 
PS> $w1 = Get-WmiObject -class Win32_OperatingSystem
PS> $w1 | Get-Member
 
   TypeName: System.Management.ManagementObject#root\cimv2\Win32_OperatingSystem
Name                                      MemberType   Definition
----                                      ----------   ----------
Reboot                                    Method       System.Management.ManagementBaseObject Reboot()
SetDateTime                               Method       System.Management.ManagementBaseObject SetDateTime(System.Str...
Shutdown                                  Method       System.Management.ManagementBaseObject Shutdown()
Win32Shutdown                             Method       System.Management.ManagementBaseObject Win32Shutdown(System.I...
Win32ShutdownTracker                      Method       System.Management.ManagementBaseObject Win32ShutdownTracker(S...
 
etc etc
 
ConvertFromDateTime                       ScriptMethod System.Object ConvertFromDateTime();
ConvertToDateTime                         ScriptMethod System.Object ConvertToDateTime();
Delete                                    ScriptMethod System.Object Delete();
GetType                                   ScriptMethod System.Object GetType();
Put                                       ScriptMethod System.Object Put();

To get the LastBootUpTime

 
PS> $w1.ConvertToDateTime($w1.LastBootUpTime)
08 April 2007 10:05:35

WMI contains a wealth of information about your systems. The information returned from WMI is the sort that lends itself to be displayed by PowerGadgets or PowerGUI.

A number of changes were made to the handling of WMI in PowerShell RC2 among them the introduction of the WMI accelarators including WMIClass

 
$w = [WMIClass]"Win32_OperatingSystem"
$w
$w | Get-Member
 
   TypeName: System.Management.ManagementClass#ROOT\cimv2\Win32_OperatingSystem
Name                   MemberType    Definition
----                   ----------    ----------
Name                   AliasProperty Name = __Class
__CLASS                Property      System.String __CLASS {get;set;}
__DERIVATION           Property      System.String[] __DERIVATION {get;set;}
__DYNASTY              Property      System.String __DYNASTY {get;set;}
__GENUS                Property      System.Int32 __GENUS {get;set;}
__NAMESPACE            Property      System.String __NAMESPACE {get;set;}
__PATH                 Property      System.String __PATH {get;set;}
__PROPERTY_COUNT       Property      System.Int32 __PROPERTY_COUNT {get;set;}
__RELPATH              Property      System.String __RELPATH {get;set;}
__SERVER               Property      System.String __SERVER {get;set;}
__SUPERCLASS           Property      System.String __SUPERCLASS {get;set;}
ConvertFromDateTime    ScriptMethod  System.Object ConvertFromDateTime();
ConvertToDateTime      ScriptMethod  System.Object ConvertToDateTime();
CreateInstance         ScriptMethod  System.Object CreateInstance();
Delete                 ScriptMethod  System.Object Delete();
GetRelatedClasses      ScriptMethod  System.Object GetRelatedClasses();
GetRelationshipClasses ScriptMethod  System.Object GetRelationshipClasses();
GetType                ScriptMethod  System.Object GetType();
Put                    ScriptMethod  System.Object Put();

What we get returned is an new WMI object that represents the Operating System but does not populate the values with those of the operating system on the machine.

 
$w.psbase.properties

 
$c = [WMIClass]"Win32_Process"
$c.Create("calc.exe")

$s = Get-WmiObject -class Win32_Service 
 
$s

PS> $s = Get-WmiObject -class Win32_Service -filter 'Name = "BITS"' 
 
PS> $s 
  
 
ExitCode : 0 
 
Name : BITS 
 
ProcessId : 1100 
 
StartMode : Auto 
 
State : Running 
 
Status : OK

Note that the startmode is set to auto

$s | get-member

Returns a number of methods including

PauseService
ResumeService
StartService
StopService
Together with a long list of properties e.g.

PS> $s.Description 
 
 
Transfers files in the background using idle network bandwidth. If the service is disabled, then any applications that 
depend on BITS, such as Windows Update or MSN Explorer, will be unable to automatically download programs and other information. 
 
PS>

Looking at the list of cmdlets with service as the noun you will no doubt recognise that the methods I listed above are available as cmdlets. This is where WMI gets a bit frightening

$s.stopservice() 
 
$s = Get-WmiObject -class Win32_Service -filter 'Name = "BITS"' 
 
$s 
 
ExitCode : 0 
 
Name : BITS 
 
ProcessId : 0 
 
StartMode : Auto 
 
State : Stopped 
 
Status : OK

Querying WMI – WMISEARCHER.

This uses WMI Query Language – WQL – which is a subset of SQL to query WMI providers.

The following is a fairly standard activity using Get-Process

PS> Get-Process | Where{$_.Handles -gt 1000} 
 
  
 
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName 
 
------- ------ ----- ----- ----- ------ -- ----------- 
 
1162 37 82432 96292 286 60.48 1056 iexplore 
 
1337 50 31184 32124 169 1000 svchost 
 
1039 29 57072 90364 295 21.63 856 WINWORD 
 
1222 29 47876 36356 206 114.13 3780 wlmail

It is possible to return similar information using WMI directly.

$query = [WMISEARCHER] 'Select * from Win32_Process where Handlecount > 1000' 
 
$query.get()

This will return a lot of data.

In order to cut down the data returned then we can use

PS> $query.get() | Sort Handlecount | Format-Table Handlecount, WS, VM, Name -auto 
 
  
 
Handlecount WS VM Name 
 
----------- -- -- ---- 
 
1270 35749888 227962880 wlmail.exe 
 
1285 76976128 321593344 iexplore.exe 
 
1385 24543232 179179520 svchost.exe