I had a need to routinely update the members of a security group in Active Directory.  The users in an OU were to be added/removed from the security group on a scheduled basis.

1. Import-Module ActiveDirectory
2. Get-ADGroupMember -Identity "Some Security Group" | ForEach-Object { $Member = $_.SamAccountName; Remove-AdGroupMember -Identity "Some Security Group" -Members $Member -Confirm:$false }
3. Get-User -OrganizationalUnit "Some OU" | ForEach-Object { Add-ADGroupMember -Identity "Some Security Group" -Members $_.SamAccountName }

This could be written into a powershell script file to be run on a schedule.

Thie script below will impor all the .PST in a directory.  NOTE: You MUST have the .PST name match the alias in the domain.

Get-ChildItem \\server\share\*.pst | foreach { $user = $_.BaseName; New-MailboxImportRequest -Mailbox $user -FilePath \\server\share\$user.pst -BadItemLimit 50 }

In my previous post, I explained how to export a .CSV for each group in an OU.  This gives you a .CSV for each group which is named the same as the group name.

• Some Group 1.csv
• Some Group 2.csv
• Some Group 3.csv
• Some Group N.csv

Now, I need to create those Groups in a new AD.  Here is the script that I used:

Get-ChildItem | foreach { echo $_.Basename } | ForEach-Object { dsadd group -scope u "cn=$_,OU=Groups,OU=Some OU,DC=SubDomain,DC=Domain,DC=TLD" }

This script calls the program DSADD and passes it the correct name (minus the .csv) which is then used to create the Groups.

Next, we run a similar script that walks through those same .CSV's and adds the users to the group with the same name as the .CSV.

Get-ChildItem | foreach { $GN = $_.BaseName; Import-Csv $_ } | foreach { Add-ADGroupMember -Identity $GN -Members $_.SamAccountName }

This works wonderfully well if the column titled SamAccountName has the correct usernames in it.

I needed to add users to groups by PowerShell and was having trouble finding examples how to do it.  Here is how I figured it out.

First, you need a CSV of the users's logon names.  My list came from the CSV from:

Get-DistributionGroupMember -Identity 'Some List' | Export-Csv 'list.csv'

The list generated above consisted of alot of fields.  The only one I am interested in for this use is "Alias".  Once I had the list generated from my old AD, I then ran:

Import-Csv 'list.csv' | ForEach-Object { Add-ADGroupMember -Identity "Some New Group Name" -Members $_.Alias }

Remember the script above needs to be a single line.  I had to break it apart so it will fit in the blog format.  It worked like a charm.

This script exports users from an OU to a CSV that can be used by other scripts.  I had to move hundreds of users from one domain to another and modify some user properties during the process.  A CSV file allows you to open the file in Excel and edit the fields as needed.  You can take the output of this script and use it to create uses in a new domain with this script.

Get-Mailbox -OrganizationalUnit "User OU" | Export-Csv -f User_Mailboxes.csv

Export details for all mailboxes for user in OU.txt (76.00 bytes)

This script creates users via Powershell.  I had to create 500 users in a new Active Directory domain that I had previously exported from an old domain.  This script can be run from the command line in PowerShell.  I have attached a .TXT file with the script if you would like to download it.

You will need a .CSV file with the following columns:

• Alias
• UPN
• Name
• DisplayName
• FirstName
• LastName
• OU

Import-Csv 'Users.csv' | ForEach-Object { New-ADUser -SamAccountName $_.Alias -UserPrincipalName $_.UPN -Name $_.Name -DisplayName $_.displayname -GivenName $_.FirstName -Surname $_.LastName -Path $_.OU -AccountPassword (ConvertTo-SecureString "Some!Password" -AsPlainText -Force) -Enabled $true -PasswordNeverExpires $false -PassThru } > Import.log

Create users from CSV.txt (349.00 bytes)

A project I am working on requires me to import and overwrite everchanging data from a SQL database into a Manifold .map file.  This .map file is then used to generate WMS tiles that are overlaid over Google Maps.  Here is the quick and dirty script to bring in a table/view from SQL into Manifold and save the .map.

wscript.echo "Beginning Import"
set app = createobject("Manifold.Application")
set doc = app.NewDocument("C:\test_dir\map.map", false)
Set SQLImport=doc.NewDataSource()
SQLImport.ConnectionString = "DRIVER={SQL Server};SERVER=.\SQLExpress;UID=user;PWD=pass;DATABASE=database"
SQLImport.ConnectionType ="SQL Server"
TableName= "dbo.TABLE_NAME.Geometry"
SQLImport.ImportDrawing (TableName)
doc.Close(true)
set SQLImport = nothing
set doc = nothing
set app = nothing
wscript.echo "Ended Import"

I have found that Google does a good job with generic data but often a company needs to display their GIS data on a Google Map.  This is often the case when the general public is viewing the data and doesn't want to learn how a 'heavy' IMS website works.  In this case, I often suggest a Google Map Mashup using a WMS.

The Mashup gives us a few great features:

• Ease of use
• Speed of deployment
• Capacity to scale (if using a cache of generated tiles)

You'll need a few things to get started:

1. A place to host the website (this can be 'localhost' if you are developing and testing on the same machine)
2. A working WMS (I assume you have one of these if you are trying to create a mashup.)
3. A Google Map API key
4. A Snippet of code that helps generate the request to the WMS (Found Here).

I have attached a simple example that you will need to put on your server and change the WMS layers.

WMS_Google_Mashup.txt (2.72 kb)

I recently began working with SQL 2008 Spatial tools to build a Google Maps Mashup that was part of a larger work order management system for a land surveying company.  The ease of going from SQL to the Google API made it a breeze.

I had a few requirements:

1. Dynamically place markers on the map based on database critera.
2. Color those markers according to the values for each record in the database.
3. Create a visually appealing map.
4. Be fast.  My primary users are on a limited 400kbps DSL connection so speed is everything.

First, I used Manifold GIS software to get my data ready for use. This included moving the data into a SQL 2008 DB out of SHP file.  We chose Manifold GIS for a few reasons.  Mostly price, then also the great number of data formats that it can open and save as.

Second, I wrote a ASP page that ran on the server that accepted the bounding box of an area and then return a delemited list of results with Lat,Lon along with other attribute data.  This is very simlilar to a WFS but greatly trimmed down.

Third, I wrote a Javascript HttpXmlRequest function that would get the getBounds() function from the Google Map API and pass it to the script described in the second step.  Upon the ASP script returning a list, the Javascript would parse this list and place markers at appropriate locations on the map.

Code Samples:

1. GIS Code
2. ASP Code
3. JS Code