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-Object 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

        }

}