public/Import-Users.ps1

Function Import-Users {

<#
 
.Synopsis
Use this function to import users from a CSV file in to Active Directory
 
.Description
Users are imported in to an imported users OU, from there you can move them as you wish
 
 
.Parameter CSV
The path to a CSV file containing user data, CSV MUST have 3 columns, firstname, lastname & description
 
.Parameter UsernameFormat
Select the format you want for the usernames generated, currently johnd, john.d, jdoe, j.doe, john.doe are supported.
 
.Parameter Usertype
Select the type of user account, the function uses this to find the home directory (eg Home$\Staff) and also adds them to the corresponding security group
 
.Parameter Homeshare
Path to the Home$ share (eg \\DC01\Home$)
 
.Parameter Profileshare
Path to the Profile$ share (eg \\DC01\Profile$)
 
.Parameter Password
What password you want for the account, MUST comply with domain policy OR fine grained password policy.
 
.Parameter RandomPassword
Tells the function to use www.dinopass.com to generate random passwords for each account
 
.Parameter Logpath
What path to generate the log files, by default is current users desktop
 
 
#>



#Requires -RunAsAdministrator
    
    [cmdletbinding(SupportsShouldProcess=$True)]
    [CmdletBinding(DefaultParameterSetName='password')]
    Param(
        
        [string]
        [Parameter(Mandatory=$true)]
        $csv,
        
        [string]
        [Parameter(Mandatory=$true)]
        [ValidateSet('johnd','john.d','jdoe','j.doe','john.doe')]
        $UsernameFormat,
        
        [string]
        [Parameter(Mandatory=$true)]
        [ValidateSet('Staff','Office','Students')]
        $UserType,
        
        [string]
        [Parameter(Mandatory=$true)]
        $HomeShare,
        
        [string]
        [Parameter(Mandatory=$true)]
        $ProfileShare,
        
        [Parameter(ParameterSetName='password', Position=0)]
        $Password,
        
        [Switch]
        [Parameter(ParameterSetName='random', Position=0)]
        $RandomPassword,
        
        [string]
        $LogPath = "$env:USERPROFILE\Desktop\User Import Logs"
    )


# Setup logging
$Log = "$LogPath\$(Get-Date -UFormat %Y-%m-%d) Import Log.csv"
$FailLog = "$LogPath\$(Get-Date -UFormat %Y-%m-%d) FAILED Import Log.csv"

if (!(Test-Path $Log)) {

    New-Item $Log, $FailLog -Force
    Set-Content -Path $Log -Value '"Full Name","UserName","Description","Password"'
    Set-Content -Path $FailLog -Value '"Full Name","UserName"'
    
    }

# Store the data from the CSV in the $Users variable
$Users = Import-csv $csv

# Defines what the CSV headers should be
$CorrectHeaders = @(
    'firstname'
    'lastname'
    'description'
    )

# Assigns the actual headers to a variable
$ImportHeaders = (($Users[0].psobject.properties.name))

# Counts the differencnes
$HeaderDiffs = (Compare-Object $CorrectHeaders $ImportHeaders).count

# Throws an error if the differences are not 0
if ($HeaderDiffs -ne '0') {

    Throw "Check your CSV Headers! Should be 'firstname,lastname,description'"

}

# Set some Variables
$Domain = (Get-ADDomain).name
$FullDomain = (Get-ADDomain).dnsroot
$DomainRoot = (Get-ADDomain).DistinguishedName
$HomePath = "$HomeShare\$UserType"
$ProfilePath = "$ProfileShare\$UserType"
$bar = "*" * 125

# Tests for an "Imported Users" OU at root of domain and if it does not exist then it creates it
$ImportOU = "OU=Imported Users,$DomainRoot"

try {
    Get-ADOrganizationalUnit -Identity $ImportOU | Out-Null
    } catch {
    New-ADOrganizationalUnit -Name "Imported Users" -Path $DomainRoot
    }

# Check Home & Profile paths exist
if (!(Test-Path $HomePath)) {
    Throw "Could not find $HomePath!"
}
    
if (!(Test-Path $ProfilePath)) {
    Throw "Could not find $ProfilePath!"
}

# Loop through each row containing user details in the CSV file

foreach ($User in $Users) {

    # Read user data from each field in each row and assign the data to a variable as below
        
    $Firstname      = $User.firstname 
    $Lastname      = $User.lastname
    $FullName    = "$Firstname $Lastname"
    $Description = $User.description

    # Select username format

    if ($UsernameFormat -eq "johnd") {
        $Username = $Firstname + $Lastname.substring(0,1)
        
    }

    if ($UsernameFormat -eq "john.d") {
        $Username = $Firstname + "." + $Lastname.substring(0,1)
    }

    if ($UsernameFormat -eq "jdoe") {
        $Username = $Firstname.substring(0,1) + $Lastname
    }

    if ($UsernameFormat -eq "j.doe") {
        $Username = $Firstname.substring(0,1) + "." + $Lastname
    }

    if ($UsernameFormat -eq "john.doe") {
        $Username = $Firstname + "." + $Lastname
    }
    
    # change to lower case and remove - and ' and spaces

    $Username    = $Username.ToLower()
    $Username    = $Username.Replace('-','').replace("'",'').replace(" ",'')

    # Generate a random password and make the first letter a capital

    if ($RandomPassword) {
        
        Write-Verbose "Generating random password..."
        $Password = (Get-Culture).TextInfo.ToTitleCase((Invoke-WebRequest "http://www.dinopass.com/password/simple" -Verbose:$False | Select-Object Content -ExpandProperty Content))

        }

    $PasswordSecure = $Password | ConvertTo-SecureString -AsPlainText -Force


    # Create splat of user params
        
    $UserParams = @{
        SamAccountName = $Username
        UserPrincipalName  = "$Username@$FullDomain"
        Name = $FullName
        GivenName = $Firstname
        Surname = $Lastname
        Enabled = $True
        DisplayName = $FullName
        Path = $ImportOU
        ProfilePath = "$ProfilePath\$Username"
        HomeDrive = "H:"
        HomeDirectory = "$HomePath\$Username"
        Description = $Description
        AccountPassword = $PasswordSecure
        ChangePasswordAtLogon = $true
        }

    # Create an object to make reporting later easier
       
    $UserObject = [PSCustomObject]@{

        Name            = $Fullname
        UserName        = $Username
        Description     = $Description
        Password        = $Password

        }

    try {
        
        New-ADUser @UserParams
        Write-Verbose "Successfully created $FullName with username $Username and Password $Password"
        $UserObject | ConvertTo-Csv -NoTypeInformation | Select-Object -Skip 1 | Out-File -FilePath $Log -Append -encoding ASCII

        } catch {

        $_ | Out-File -FilePath $FailLog -Append -encoding ASCII
        $UserObject | Select Name,Username | ConvertTo-Csv -NoTypeInformation | Select-Object -Skip 1 | Out-File -FilePath $FailLog -Append -encoding ASCII
        $bar | Out-File -FilePath $FailLog -Append -encoding ASCII
        Write-Verbose "Unable to create $FullName, moving on to next user..."
        continue
        
        }

    Write-Verbose "Creating home directory: $HomePath\$Username"
    # Create users home folder and give them full rights
    New-Item -Name $Username -Path $HomePath -ItemType Directory | Out-Null
        
    Write-Verbose "Setting access rights..."
    $Acl = Get-Acl "$HomePath\$Username"
    $Ar = New-Object  System.Security.AccessControl.FileSystemAccessRule("$Domain\$Username","FullControl","ContainerInherit,ObjectInherit","None","Allow")
    $Acl.SetAccessRule($Ar)
    Set-Acl "$HomePath\$Username" $Acl

    Write-Verbose "Assigning to groups..."
    # Add them to AD groups
    Add-ADGroupMember -Identity $UserType -Members $Username

    # Set password and enable account after group membership (fine grained password policy)
    Write-Verbose "Setting password..."
    
    Set-ADAccountPassword -Identity $Username -Reset -NewPassword $PasswordSecure
    Set-ADUser -Identity $Username -Enabled $true
    
    if ($UserType -eq "Students") {

        Set-ADUser -Identity $Username -CannotChangePassword $true -ChangePasswordAtLogon $false -PasswordNeverExpires $true
        
        } else {

        Set-ADUser -Identity $Username -CannotChangePassword $false -ChangePasswordAtLogon $true

        }

    Write-Verbose $bar

    }

}