I was very happy to have been asked to contribute.

Click On Link Below

Why Should I Learn PowerShell? Real World Example Saves the Day!

I even went as far to ensure this setting on the Exchange 2010 Server Side via Powershell.
Where * is the Default Domain.

Set-RemoteDomain -Identity:* -ContentType MimeText
Get-RemoteDomain -Identity:* | fl - will show the settings.

http://technet.microsoft.com/en-us/library/aa997857.aspx

After finding that the users were still able to select Format Text and change their text to both Rich Text and HTML I decided I had to dig deeper.

I found that I could manually change this feature while logging in with my account but this only affected my logon experience, not the other users.

With the New Message open click  File – Options

Click on Mail – Editor Options

Click on Customize Ribbon – Main Tabs from the drop down – Format Text – Format
Now you can remove Format and those options will no longer appear.

Notice that the Rich Text and HTML options are now gone and the default is Plain Text.

The next step was to reverse the settings placing the Format Text option back in place. Then I made a backup of the entire registry called B4.REG. I then made the changes listed above and once the settings were in place, I created another backup of the registry called Aftr.REG.
My plan was to use WINMerge to find where they change had occurred in the registry to help me find the control ID for the item that I wanted to disable via Group Policy shown below.

As you can see all I need is the Command Bar ID and I will be able to block it. There is even a link listed
http://officeredir.microsoft.com/r/rlidOffice14RibbonControlIDsO14?clid-1033

Thank You Microsoft!

But as you see this link offers no help whatso ever…  Thanks Microsoft… sigh

Working with the two REG files B4.REG and Aftr.REG showed me nothing of any use. I was not able to find a change in the registry that would show me the needed Command Bar ID’s. I also used Process Explorer and Process Monitor, but again nothing that indicated where this was located in the registry where I could manually change a setting.
After endless Google links that provided endless bad information, I came across a link for this app.

Built-in Control Scanner
You use Built-in Controls Scanner to find command bar names and built-in controls IDs.
http://www.add-in-express.com/products/commandbars-controls-ids.php

I installed this on one of my test machines and opened Outlook 2010 and started a new message then selected the Format Text tab.

I then stated the App with Outlook selected.

 THERE WAS MY ANSWER!

In Group Police I updated  -  User Configuration\Administrative Templates\Microsoft Outlook 2010\Disable Items in User Interface\Custom  I entered the Command Bar ID’s along with a description.

Enter the Command Bar ID’s here.  5564 and 5565

I ran Gpupdate /Force on the test machine and reopened Outlook 2010 and started a new email message.  As you can see, the Rich Text and HTML Text options are gone.  This will ensure that they users cannot use this option to bypass policy.

I hope this helps someone that has been trying to configure this setting.  If there is an easier way to do this please post the link here.

Active Directory Cmdlets in Windows PowerShell

Windows PowerShell™ is a task-based command-line shell and scripting language designed especially for system administration. This reference topic for the information technology (IT) professional introduces the 76 Windows PowerShell cmdlets that you can use to manage and administer the Active Directory® directory service and Active Directory Domain Services (AD DS).

http://technet.microsoft.com/en-us/library/ee617195.aspx

The purpose of this crossword was to hopefully introduce some reluctant Administrators to Powershell, especially those that administer Active Directory (AD).

You do not have to be a NASCAR or INDY racer to realize the benefits of being able to drive a car, so what are you waiting for when it comes to learning Powershell?  Powershell will be a mandatory requirement in the very near future, if it is not already in your area.

If you find that Powershell can (will) make your life much easier, then I would highly suggest these links to open your mind and your world to Powershell.

Mark Minasi – Mark Minasi is a senior contributing editor for Windows IT Pro, an MCSE, and the author of more than 30 books, including Mastering Windows Server 2008 R2 (Sybex). He writes and speaks around the world about Windows networking.
http://www.minasi.com/forum/default.asp

Find Users with Get-ADUser - http://www.windowsitpro.com/article/windows-power-tools/getaduser-determine-logged-141189

The Lonely Administrator – Jeffery Hicks

I am certified Microsoft professional, a Microsoft MVP and an IT veteran with almost 20 years of experience, much of it spent as an IT consultant specializing in Windows server technologies.   http://jdhitsolutions.com/blog/

As mentioned – Add WhatIf Support to Your PowerShell Scripts Posted on December 2, 2011 by Jeffery Hicks http://jdhitsolutions.com/blog/2011/12/add-whatif-support-to-your-powershell-scripts/

Concentrated Technology is the brainchild of IT gurus Don Jones and Greg Shields. We offer a number of different products and services, depending on which part of the IT industry you work in.   http://www.concentratedtech.com/

MSFT Scripting Guys – Ed Wilson
Ed is the Microsoft Scripting Guy. He is an expert on scripting technology such as PowerShell, VBScript and WMI. He is the author of over a dozen books.
http://www.scriptingguys.com

Claus Nielsen – Microsoft Powershell MVP

Blog: http://xipher.dk     Public Profile: http://dk.linkedin.com/pub/claus-nielsen/1/2ab/9b1

On the Group Policy / Powershell side of things Jeremy Moskowitz  and Darren Mar-Elia are a MUST reads.

I have included both the crossword puzzles and their answer keys.

AD Clean up with Powershell 1 of 4

AD Clean up with Powershell 1 of 4 KEY

AD Clean up with Powershell 2 of 4

AD Clean up with Powershell 2 of 4 KEY

AD Clean up with Powershell 3 of 4

AD Clean up with Powershell 3 of 4 KEY

AD Clean up with Powershell 4 of 4

AD Clean up with Powershell 4 of 4 KEY

]]> http://timbolton.net/2011/12/28/ad-clean-up-with-powershell-for-beginners/feed/ 0 0.000000 0.000000 0.000000 0.000000 jsclmedave http://timbolton.net/2011/12/15/276/ http://timbolton.net/2011/12/15/276/#comments Fri, 16 Dec 2011 00:15:03 +0000 Tim Bolton http://timbolton.wordpress.com/?p=276 ]]> I put together a Powershell for Beginners crossword puzzle.  I hope you enjoy it.  I even learned a thing or two while  putting it together.  I will be working on a Clean Up AD Version, thanks to my good friend Mark Minasi, soon.

I also want to thank Jeffery Hicks and Claus Nielsen for urging me to complete this little project.

PDF can be downloaded from link below.

Powershell for Beginners

Two new books to add today.  Once again Aidan Finn has released yet another book.

Mastering Windows 7 Deployment

The Great Mark Russinovich has written a thriller, a fictional novel using his experience and knowledge of IT:

Zero Day

“Arab terrorists, with the collusion of Osama bin Laden, are behind the attack, which is supposed to destroy Western civilization. A New York City law firm enlists cyber expert Jeff Aiken to track down a virus that has knocked out the company’s computer network. While working on this problem, Jeff uncovers the larger threat. With the help of “stunningly attractive” Daryl Haugen, an old friend who becomes his love interest, Jeff attempts to warn the authorities, but to little avail”.

You can pre-order the book now on Amazon.com in paper and for Kindle.  The expected RTM is March 15th, 2011.

I was asked about changing permissions from the root of a drive and all sub-folders.  My immediate reaction was to use the Microsoft tool that replaced cacls – icacls.  Apparently the person that came up with the new name  ”must” have just received their new iPad. <g>

I remembered a Technet article from a friend Gregg Shields – http://technet.microsoft.com/en-us/magazine/2009.07.geekofalltrades.aspx

“Setting permissions for the Marketing folder is slightly different. We use the same permissions flow for the Product folder as we did for the subfolders under Finance, but the Restricted folder will be treated a bit differently. Let’s suppose that folder contains highly secret documents that should be seen by only a very few individuals. Your first thought may be, “A-ha! Here, I’ll use the Deny permissions to prevent the wrong users from accessing this folder!”
But keep in mind that the Deny permissions is actually far too powerful a setting for most situations as it automatically overrides every other permission. Therefore, adding the Deny permission to the Marketing Users group for this folder means that any Restricted users who are also Marketing users would be shut out. A more appropriate solution here is to break the inheritance again and simply eliminate all permissions for the Marketing Users group. Thus, the three icacls command lines required to set the permissions for this structure are”http://support.microsoft.com/kb/943043

Icacls C:\Shared\Marketing /inheritance:r /grant:r “Finance Users”:(OI)(CI)R /grant:r “File Admins”:(OI)(CI)F

Icacls C:\Shared\Marketing\Product /grant:r “Product Users”:(OI)(CI)M

Icacls C:\Shared\Marketing\Restricted /inheritance:r /grant:r “File Admins”:(OI)(CI)F /grant:r “Restricted Users”:(OI)(CI)M

ALSO see -

The Icacls.exe utility that is included with Windows Server 2003 Service Pack 2 does not support the inheritance bit
Hotfix Download Available

Additionally, you can set the inheritance bit of files or folders by using the updated Icacls.exe utility together with the /inheritance parameter. For more information, see the following sample:
/inheritance:e|d|r
e – enables inheritance
d – disables inheritance and copy the ACEs
r – remove all inherited ACEs

So if you are asking yourself WHAT..?  Like I was, here is some more info on the topic.

“Tim asked me to comment on this question.

You’re on the right path. Funny, but I’m actually about to write a three-part series on icacls for TechTarget.

You need to break the inheritance (/inheritance:r) and then reset the new directly-applied permissions (/grant). The new perms then inherit down because you’re using (OI)(CI), which are “object inherit” and “container inherit”.

So, step one: Break inheritance. Step two: directly set new perm. Step three: Enable inheritance. What’s confusing is that these three steps are all being done in a single line.

Does this help?”

/Greg Shields, MVP – Terminal Services

Tips and Tricks for the Jack-of-all-Trades IT Professional

www.ConcentratedTech.com

The “single line” threw me for a but until I realized what he meant was.  In your single command line you need to break the inheritance first then you will apply the permissions you want to grant accordingly.

So for example -

Step 1 is the /inheritance:r

Step 2 is the /grant Domain\username

Step 3 is the (OI)(CI) F

Thus -

icacls pathname /inheritance:r /grant Domain\username (OI)(CI) F

F = full

If there are any other permissions that exist you could also remove those in the same command by using the :r switch after the grant command.

icacls pathname /inheritance:r /grant:r Domain\username (OI)(CI) F

Many Thanks to Gregg Shields.  I highly anticipate his to be released three-part series on icacls for TechTarget.

“We have a remote OCS Mediation server that contacts the OCS Front End Pool over a WAN link. I need that Mediation server to ping those front end servers periodically to verify that the WAN link is up. If the ping on two of the servers fails,  I need it to stop the OCS Mediation service on the mediation server until it can successfully ping the two front end server across the WAN again at which point it would then bring the Service on the Mediation server back up.”

With a LOT of assitance from Jeffery Hicks and Claus Thude Nielsen a simple script was created.

  In this example the Two Server that are being PINGED are “coredc01″ and “client1″.  The service being stopped and or started is “spooler”.

A scheduled task – set to run as a System Process - can be used to run the PS1 script.

I added this bit - 

powershell.exe -noexit C:\temp\restart.ps1

It was automatically changed to this -

C:\WINDOWS\system32\WindowsPowerShell\v1.0\powershell.exe -noexit C:\temp\restart.ps1

-noexit keeps the powershell window open so I could see any warnings or MSG. NOTE! If running via scheduled task, the task will have a status of running and will not open a new window until the first one closes.

Also,,, if you are simply removing the network cable to signify a down connection, make sure you have turned off your wireless connection as well. May save you about 20 Min’s of head scratching. <g>

Once I was satisfied with the PS1 working I then removed the -noexit. Works like a charm…
Another example where the PS1 is set to run contniuous -

$server1=”cropfrontend1″
$server2=”corpfrontend2″
$service=”OCS Communication Server Mediation”
do{
if ((test-connection $server1 -quiet) -OR (test-connection $server2 -quiet)) {
#if 1 server is reachable make sure service is running
get-service $service | where {$_.status -eq “Stopped”} | Start-Service -PassThru
}
elseif (!(test-connection $server1 -quiet) -AND (test-connection $server2 -quiet)) {
#if both servers are unreachable stop service
write-warning “Both of the servers are unreachable”
get-service $service | where {$_.status -eq “Running”} | Stop-Service -PassThru
}
start-sleep –s 15
} until ( $true –eq $false)

Excellent Article Daniel..!

Defragmentation is a great way to keep workstations and servers running

at their best performance. Windows Server 2003 comes with a

defragmenter: dfrgntfs.exe. However, you can’t automate this

defragmenter unless you purchase a program such as Diskeeper. I didn’t

have money for such a program in my budget, so I created and scheduled a

batch file named Defrag.bat.

As Listing 1 shows,

Listing 1: Defrag.bat

@Echo Off

defrag.exe c: -f

defrag.exe e: -f

defrag.exe f: -f

Defrag.bat is a simple program. It uses the defragmenter’s command-line

interface (defrag.exe) to run the defragmenter against each drive.

However, I wasn’t happy with Defrag.bat for two reasons. First, I had to

let the batch file run while being left logged on with my administrator

ID. Although I locked the screen for security reasons, I didn’t want to

leave myself logged on all the time. Second, I wanted more automation.

So, I did some digging around and found a means to automate the

procedure. I found that I could use the Windows scheduler but in a

different way that I didn’t know was possible: I could use the AT

command with a batch file.

I created a new batch file, Defrg. bat, which Listing 2 shows.

Listing 2: Defrg.bat

@Echo Off

‘ BEGIN CALLOUT A

Set logfile=f:\defrag.log

‘ END CALLOUT A

Echo Started %date%,%time% >>%logfile%

Echo ———————————– >>%logfile% Echo Defragmenting

C: drive >>%logfile% Echo. >>%logfile% defrag.exe c: -f >>%logfile% Echo

———————————– >>%logfile% Echo Defragmenting E:

drive >>%logfile% Echo. >>%logfile% defrag.exe e: -f >>%logfile% Echo

———————————– >>%logfile% Echo Defragmenting F:

drive >>%logfile% Echo. >>%logfile% defrag.exe f: -f >>%logfile% Echo

———————————– >>%logfile% Echo Finished

%date%,%time% >>%logfile% Echo ———————————–

>>%logfile%

Like Defrag.bat, Defrg.bat runs defrag.exe. However, Defrg.bat has a few

more features than Defrag.bat. I included code that documents when the

defragmenter starts and ends in a log file. I also added code that ports

the defragmenter’s screen output to the same log file (with some titles

in between) to record which drives are being defragmented. That way, I

can easily check to see whether the defragmentation operation ran and

whether any errors occurred.

To use the new script, I log on to the server with my administrator ID,

open a command-shell window, and run command

at 08:00pm /every:M,T,W,Th,F  f:\Defrg.bat

(Although this command appears on several lines here, you would enter it

on one line in the command-shell window.) This command creates a new

scheduled item in Scheduled Tasks that runs Defrg.bat every weeknight at

8 p.m. (which is before our backup runs).

With this new batch file, I don’t need to be logged on for it to run.

Because Defrg.bat is running as a system process, the defragmentation

operation is performed in the background (i.e., no window comes up), but

Task Manager will show that defrag.exe and dfrgntfs.exe are running.

After Defrg.bat finishes, the scheduler will show 0×0 for a successful

execution. However, I always check the log file to make sure no problems

were encountered.

To use Defrg.bat, you simply need to replace f:\defrag.log in the code

at callout A in Listing 2 with the pathname to your log file. The AT

command and batch file work on Windows Server 2003, Windows XP

Professional, and Windows XP Home Edition. I recommend that you make the

batch file a read-only, hidden file. That way, no one can edit it so

that it damages your computers when the scheduled batch runs.

-Daniel L. Gillard

You can download the WIN IT Pro Article here Find Files on Local Drives with Whereis and the PS1 code snippet here WhereisPS1 .

Find Files on Local Drives with Whereis.ps1

From the January 2010 Edition
of Windows IT Pro
December 15, 2009
Bill Stewart
Feature
InstantDoc #103096

I often find it useful to search for files from a command line. In the past, I’ve typically used Cmd.exe’s dir command with the /b and /s parameters to search for files; combining these parameters provides a list containing the full paths and filenames of matching files. However, dir doesn’t have a simple syntax for searching multiple locations. For example, to search drives C and D for all files ending in .doc, you would use this command:

dir /b /s c:\*.doc d:\*.doc

The syntax gets even more complex when searching for multiple wildcard patterns (e.g., all .doc, .xls, and .ppt files) in multiple locations because you have to type each location and each wildcard pattern separately.

Windows PowerShell’s Get-ChildItem cmdlet makes this task simpler. For example, to search drives C and D for all .doc, .xls, and .ppt files, you can use this command:

get-childitem c:\*,d:\*
-include *.doc,*.xls,*.ppt -recurse

Get-ChildItem’s first parameter is a list of paths to search, and the -Include parameter specifies a list of wildcard patterns that qualify the paths. The -Recurse parameter is analogous to the dir command’s /s parameter.

Introducing Whereis.ps1

Although the Get-ChildItem cmdlet is quite powerful, I still found myself wanting additional functionality. For example, I wanted to be able to omit the -Recurse parameter and to automatically search local fixed drives if I didn’t type a path. Before long, I began writing a full-featured script that augments the Get-ChildItem cmdlet with several additional features. The result is the Whereis.ps1 script, which you can download by clicking theDownload the Code Here button at the top of the page. (Note that the Whereis.ps1 script isn’t an equivalent to the whereis command you might find on a UNIX-like OS.)

Whereis.ps1 uses the following syntax:

Whereis.ps1 -Name <String[]>
[-Path <String[]>]
[-LastWriteTimeRange <DateTime[]>]
[-SizeRange <UInt64[]>] [-OneLevel]
[-Files] [-Dirs] [-Force] [-DefaultFormat]

The -Name parameter specifies a wildcard pattern. This parameter’s argument can be an array. Files and directories that match the wildcard patterns are included in the script’s output. The -Name parameter is the only required command-line parameter. For information about the wildcard patterns you can use, type

get-help about_wildcard

at a PowerShell prompt. Because -Name is a positional parameter, you can omit the parameter name (-Name) and type only its argument if it’s the first parameter on the command line after the script name.

The -Path parameter specifies a path, and its argument can be an array. If you don’t specify this parameter, Whereis.ps1 searches all local fixed drives. The -Path parameter is also positional, so you can omit the parameter name (-Path) and type only its argument if it’s the second parameter on the command line after the script name.

The -LastWriteTimeRange parameter specifies an inclusive date range, and the argument can be an array. Items that have a LastWriteTime property within the range are included in the script’s output. If you specify strings for this parameter’s argument, Whereis.ps1 attempts to convert them to DateTime objects. If you specify a single date, Whereis.ps1 interprets the date range as “the specified date or later.” If you specify an array, Whereis.ps1 interprets the first element in the array as the earlier date boundary and the second element in the array as the later date boundary. You can specify an “older than” date range by using zero as the first element in the array.Table 1 shows some examples for the -LastWriteTimeRange parameter.

The -SizeRange parameter specifies an inclusive size range, in bytes. This parameter’s argument can be an array. Files that have a Length property within the range are included in the script’s output. If you specify a single number, Whereis.ps1 interprets the range as “files of at least the specified size.” If you specify an array, Whereis.ps1 interprets the first element in the array as the smaller size boundary and the second element in the array as the larger size boundary. You can also use PowerShell’s numeric multiplier suffixes (kb, mb, and gb) when specifying the arguments for -SizeRange. Table 2 shows some examples for the -SizeRange parameter. Note that the -SizeRange parameter is ignored if you use only the -Dirs parameter (which I describe later), because directories don’t have a Length property.

The -OneLevel parameter searches within the specified directories but not their subdirectories. That is, it’s the inverse of Get-ChildItem’s -Recurse parameter.

The -Files parameter causes Whereis.ps1 to include files in its output, and the -Dirs parameter causes Whereis.ps1 to include directories. The default is -Files. If you want to search for both files and directories, use -Files and -Dirs together. Use -Dirs by itself to search only for directories.

The -Force parameter corresponds to Get-ChildItem’s -Force parameter. It causes Whereis.ps1 to search for items with hidden or system attributes.

The -DefaultFormat parameter causes Whereis.ps1 to output file-system objects instead of custom formatted string output. Figure 1 shows an example of Whereis.ps1′s custom output, which is easier to read than if you output file-system objects, particularly if you have a large number of results, but you can’t use the custom output as input for other scripts or cmdlets that expect file-system objects. The -DefaultFormat parameter helps you avoid this problem.

Inside Whereis.ps1
The param statement at the top of the script defines the script’s command-line parameters. I typically use mixed-case variable names for script parameters (and other global variables) in PowerShell scripts, but this is only a convention and isn’t required. After the param statement, the script declares the usage, isNumeric, writeItem, and main functions. Whereis.ps1 then calls the main function. Note that in PowerShell scripts, functions must be defined before they’re called, which is why Whereis.ps1 doesn’t call the main function until the last line in the script.

The usage function outputs a message explaining the script and how to use it, then exits the script. The main function calls the usage function if the -Name parameter is missing from the command line or if the -Help parameter is present.

The main function calls the isNumeric function to ensure that the arguments specified for the -SizeRange parameter are numeric. The isNumeric function works by using the -contains operator to see if its parameter’s type is in the list of numeric types (e.g., Decimal, Double).

The writeItem function controls the format of the script’s output. If the -DefaultFormat parameter exists on the command line, the writeItem function simply outputs its argument, which is a file-system object; otherwise, the function outputs a formatted string. It uses the standard .NET string formatting codes and the -f operator to produce the formatted string. For more information about string formatting, see the MSDN article “Formatting Types.”

The main Function
The main function, which Listing 1 shows, contains the bulk of the script’s code. The function’s first job is to verify that the -Name parameter is present. If the -Name parameter is missing or if the -Help parameter is present, the main function calls the usage function, which outputs a usage message and ends the script.

The main function next converts the $Name variable into an array; the variable remains unchanged if it already contains an array. The function then uses a for loop to iterate the array. If an array element contains the * wildcard, it replaces the array with the $NULL value. This step is necessary to prevent the Get-ChildItem cmdlet, which runs later in the script, from outputting the contents of subdirectories underneath a directory.

Next, the main function checks to see if the -Path parameter is present. If the -Path parameter is missing, the function uses the Get-WmiObject cmdlet to retrieve a list of local fixed drives, as the code in callout A shows. Therefore, the $Path variable contains either the path or paths specified with the -Path parameter or a list of local fixed drives. The main function then converts the $Path variable into an array; the variable remains unchanged if it already contains an array.

As the code in callout B shows, the function then uses a for loop to iterate the $Path array. For each element in the array, it checks whether the element ends with a backslash (\). If it does, the function adds the * wildcard to the path. Then the function checks whether the element ends with \*. If it doesn’t, the function appends \*. When the for loop is complete, each element in the path array ends with \*. This process lets us specify a path such as C:\Files, and the script interprets the path as C:\Files\*. This script step not only saves typing when entering paths, but it’s also required because the main function uses the Get-ChildItem cmdlet’s -Include parameter. See the sidebar “Get-ChildItem’s -Include Parameter” for more information about how the -Include parameter works.

The main function next determines if the -LastWriteTimeRange parameter exists. If this parameter doesn’t exist, the function creates a two-element array. The function stores the earliest possible date (i.e., 1 January 0001, 00:00:00) in the first element, and it stores the latest possible date (i.e., 31 December 9999, 23:59:59) in the second element. The function gets the earliest and latest possible dates by retrieving the DateTime type’s MinValue and MaxValue static properties.

If the -LastWriteTimeRange parameter exists, the main function converts the $LastWriteTimeRange variable into an array; the variable remains unchanged if it already contains an array. If the array contains only one element, the function appends a second element to the array containing the latest possible date. The main function next checks whether the array’s first element is zero; if it is, the function uses the earliest possible date as the first element. Then the function attempts to convert both elements of the array into DateTime objects by using the DateTime type’s Parse static method, as the code in callout C shows. If the Parse method throws an error, the script block following the trap statement runs, which outputs an error message and halts the script. The function then ensures that the first date is earlier than the second date; if this isn’t true, the function throws an error, ending the script.

Next, the main function checks whether the -SizeRange parameter exists. If it doesn’t exist, the function creates a two-element array, with a zero as the first element and the maximum value for a 64-bit unsigned integer (UInt64) as the second element. If the -SizeRange parameter exists, the function converts the $SizeRange variable into an array; the variable remains unchanged if it already contains an array. If the array contains only a single element, the function appends a second element to the array with the maximum value of the UInt64 type. The code incallout D shows how the main function then checks to see if both elements contain numeric values by calling the isNumeric function I described earlier. If either element contains a value that isn’t numeric, the function throws an error, ending the script. The function also throws an error if the first array element is greater than the second element.

The main function then checks for the nonexistence of the -Files and -Dirs parameters. If neither parameter exists, the function sets $Files to $TRUE. It then sets two counter variables to zero: One to keep track of the number of items found ($count) and the other to accumulate the size of all files ($sizes).

At this stage, the main function has parsed and validated all of the script’s parameters, so it executes the Get-ChildItem cmdlet. The function pipes Get-ChildItem’s output to the ForEach-Object cmdlet so that it can perform further filtering for each object. If the -Files parameter exists and the object’s PsIsContainer property is False (i.e., the object is a file and not a directory), then the main function checks to see if the object’s LastWriteTime and Length properties are within the date and size ranges, respectively. If the object’s properties are within specified criteria, the main function increments the $count and $sizes variables and calls the writeItem function to output the object. The main function performs similar checks to see if the -Dirs parameter exists and the object’s PsIsContainer property is True (i.e., the object is a directory and not a file), except that it doesn’t verify the object’s size range or increment the $sizes variable because directory objects don’t have a Length property.

Sample Commands
Now let’s look at some commands that illustrate how to use Whereis.ps1 to perform various tasks. For instance, if you want to search for video and audio files on all local drives, you would use the following command:

whereis.ps1 *.asf,*.avi,*.mov,*.mp3,
*.mp4,*.mpg,*.mpeg,*.qt,*.wav,*.wm,*.wmv

Note that although commands here are shown with line breaks for space, you would enter them all on one line; it’s also important that you don’t put spaces around the commas.

Next, to search for PowerPoint files that are 10MB or larger in C:\Data and its subdirectories, try this command:

whereis.ps1 *.pp[st]*
C:\Data -sizerange 10mb

To search for files in C:\Data that have been modified within the past 60 days, use

whereis.ps1 * C:\Data
-daterange ((get-date)
- (new-timespan -days 60)),(get-date)
-onelevel

If you want to delete all files in C:\Logs that were modified 30 days ago or earlier, you would use this command:

whereis.ps1 * c:\Logs
-daterange 0,((get-date)
- (new-timespan -days 30))
-onelevel -defaultformat | remove-item

Get-ChildItem on Steroids
PowerShell’s Get-ChildItem cmdlet has powerful native functionality, but Whereis.ps1 adds some useful functionality of its own. Add Whereis.ps1 to your toolkit and find what you’re looking for even faster. Furthermore, you can build on the scripting concepts demonstrated here to customize and enhance your use of PowerShell cmdlets to suit your personal workload.

Listing 1: Whereis.ps1′s main Function

function main {

# If -help is present or the -name parameter is missing, output

# the usage message.

if (($Help) -or (-not $Name)) {

usage

}

# Convert $Name to an array. If any array element contains *,

# change the array to $NULL. This is because

#   get-childitem c:\* -include *

# recurses to one level even if you don’t use -recurse.

$Name = @($Name)

for ($i = 0; $i -lt $Name.Length; $i++) {

if ($Name[$i] -eq “*”) {

$Name = $NULL

break

}

}

#CALLOUT A

# If no -path parameter, use WMI to collect a list of fixed drives.

if (-not $Path) {

$Path = get-wmiobject Win32_LogicalDisk -filter DriveType=3 | foreach-

object {

$_.DeviceID

}

}

#END CALLOUT A

# Convert $Path into an array so we can iterate it.

$Path = @($Path)

#CALLOUT B

# If a path ends with “\”, append “*”. Then, if it doesn’t end with

# “\*”, append “\*” so each path in the array ends with “\*”.

for ($i = 0; $i -lt $Path.Length; $i++) {

if ($Path[$i].EndsWith(“\”)) {

$Path[$i] += “*”

}

if (-not $Path[$i].EndsWith(“\*”)) {

$Path[$i] += “\*”

}

}

#END CALLOUT B

# If no -LastWriteTimeRange parameter, assume all dates.

if (-not $LastWriteTimeRange) {

$LastWriteTimeRange = @([DateTime]::MinValue, [DateTime]::MaxValue)

}

else {

# Convert $LastWriteTimeRange to an array (if it’s not already).

$LastWriteTimeRange = @($LastWriteTimeRange)

# If only one element, add max date as second element.

if ($LastWriteTimeRange.Length -eq 1) {

$LastWriteTimeRange += [DateTime]::MaxValue

}

# Zero for first element means [DateTime]::MinValue.

if ($LastWriteTimeRange[0] -eq 0) {

$LastWriteTimeRange[0] = [DateTime]::MinValue

}

#CALLOUT C

# Throw an error if [DateTime]::Parse() fails.

trap [System.Management.Automation.MethodException] {

throw “Error parsing date range. String not recognized as a valid

DateTime.”

}

# Parse the first two array elements as DateTimes.

for ($i = 0; $i -lt 2; $i++) {

$LastWriteTimeRange[$i] = [DateTime]::Parse($LastWriteTimeRange[$i])

}

#END CALLOUT C

}

# Throw an error if the date range is invalid.

if ($LastWriteTimeRange[0] -gt $LastWriteTimeRange[1]) {

throw “Invalid date range. The first date is greater than the second.”

}

# If no -sizerange parameter, assume all sizes.

if (-not $SizeRange) {

$SizeRange = @(0, [UInt64]::MaxValue)

}

else {

# Convert $SizeRange to an array (if it’s not already).

$SizeRange = @($SizeRange)

# If no second element, add max value as second element.

if ($SizeRange.Length -eq 1) {

$SizeRange += [UInt64]::MaxValue

}

}

#CALLOUT D

# Ensure the elements in the size range are numeric.

for ($i = 0; $i -lt 2; $i++) {

if (-not (isNumeric $SizeRange[$i])) {

throw “Size range must contain numeric value(s).”

}

}

#END CALLOUT D

# Throw an error if the size range is invalid.

if ($SizeRange[0] -gt $SizeRange[1]) {

throw “Invalid size range. The first size is greater than the second.”

}

# If both -files and -dirs are missing, assume -files.

if ((-not $Files) -and (-not $Dirs)) {

$Files = $TRUE

}

# Keep track of the number of files and their sizes.

$count = $sizes = 0

# Use the get-childitem cmdlet to search the file system, and use

# the writeItem function to output matching items. For files, check

# the date and size ranges. For directories, only the date range is

# meaningful.

get-childitem $Path -include $Name -force: $Force -recurse: (-not

$OneLevel) | foreach-object {

if ($Files -and (-not $_.PsIsContainer)) {

if (($_.LastWriteTime -ge $LastWriteTimeRange[0]) -and

($_.LastWriteTime -le $LastWriteTimeRange[1]) -and

($_.Length -ge $SizeRange[0]) -and ($_.Length -le $SizeRange[1])) {

$count++

$sizes += $_.Length

writeItem $_

}

}

if ($Dirs -and ($_.PsIsContainer)) {

if (($_.LastWriteTime -ge $LastWriteTimeRange[0]) -and

($_.LastWriteTime -le $LastWriteTimeRange[1])) {

$count++

writeItem $_

}

}

}

# Output statistics if not using -defaultformat.

if (-not $DefaultFormat) {

“Found {0:N0} item(s), {1:N0} byte(s)” -f $count, $sizes

}

}