Entrinsec.Powershell.SETUP

1.12.90

Entrinsec.Powershell.SETUP.psm1

#Requires -Version 7.0

$SetupVersion = '1.12.90'

function Set-SetupVersion {
    param (
        [string]$SetupVersion
    )

    # Check if the user is an administrator
    if (-not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
        Write-Host "You need to run this as an administrator." -ForegroundColor Red
        return
    }
    
    $registryPath = "HKLM:\SOFTWARE\Entrinsec\SETUP"
    $name = "Version"

    try {
        # Check if registry path exists, create if not
        if (-not (Test-Path $registryPath)) {
            New-Item -Path $registryPath -Force | Out-Null
        }

        # Set the registry value
        Set-ItemProperty -Path $registryPath -Name $name -Value $SetupVersion -Type String -Force
        Write-Host "Successfully set $name to $SetupVersion in $registryPath" -ForegroundColor Green
    } catch {
        Write-Host "Failed to set $name to $SetupVersion in $registryPath. Error: $_" -ForegroundColor Red
    }
}

Set-SetupVersion $SetupVersion

function Show-EntrinsecSETUPInfo {

    # Get the name of the current module (the module this function is part of)
    $PackageName = $MyInvocation.MyCommand.ModuleName

    # Get the currently installed module version
    $installedVersion = (Get-Module -Name $PackageName -ListAvailable).Version
    Write-Host ""
    Write-Host "$PackageName $installedVersion imported." -ForegroundColor Blue
    Write-Host "All official MIT licensed Powershell modules can be found at https://www.entrinsec.com" -ForegroundColor Blue
    Write-Host ""
}

# Show-EntrinsecINFO

function Show-EntrinsecLicenseInfoSETUP {
    $message = @(
        "Entrinsec modules and the functions contained in them are licensed under the MIT License.",
        "For more information, please visit:",
        "https://docs.entrinsec.com/BaGet/Entrinsec-License/"
    )

    $maxLength = ($message | Measure-Object -Maximum Length).Maximum
    $border = "*" * ($maxLength + 4)

    Write-Host $border -ForegroundColor White
    foreach ($line in $message) {
        if ($line -eq "https://docs.entrinsec.com/BaGet/Entrinsec-License/") {
            Write-Host "* " -ForegroundColor White -NoNewline
            Write-Host "$line" -ForegroundColor Blue -NoNewline
            Write-Host (" " * ($maxLength - $line.Length)) -NoNewline
            Write-Host " *" -ForegroundColor White
        } else {
            Write-Host "* " -ForegroundColor White -NoNewline
            Write-Host "$line" -ForegroundColor DarkCyan -NoNewline
            Write-Host (" " * ($maxLength - $line.Length)) -NoNewline
            Write-Host " *" -ForegroundColor White
        }
    }
    Write-Host $border -ForegroundColor White
    Write-Host ""
}

# Function to install NuGet.exe
function Install-Nuget {

    # Check if nuget.exe can be launched and hide the output
    try {
        $null = nuget.exe help  # This command will run nuget.exe help and discard the output
        Write-Host "nuget.exe is accessible and can be launched."
        return 0
    } catch {
        Write-Host "nuget.exe cannot be launched. Please check your PATH and the existence of nuget.exe." -ForegroundColor Red
        Write-Host "Attempting to install nuget.exe..." -ForegroundColor Yellow
    }

    # Set the installation directory
    $installDir = "C:\Program Files\Nuget"
    $nugetExePath = Join-Path -Path $installDir -ChildPath "nuget.exe"

    # Check if nuget.exe already exists in the installation directory
    if (Test-Path -Path $nugetExePath) {
        Write-Host "nuGet.exe exists at $nugetExePath"
        Write-Host "Close this Powershell session and re-launch to use the installed nuget.exe." -ForegroundColor Yellow
        return 1 # Exit the function
    }

    # Create the installation directory if it doesn't exist
    if (!(Test-Path -Path $installDir)) {
        New-Item -ItemType Directory -Path $installDir -Force
    }

    # Downloading Nuget from the official website
    Write-Host "Installing NuGet from the official source..." -ForegroundColor Green

    # Download nuget.exe from the official website
    $nugetUrl = "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
    Invoke-WebRequest -Uri $nugetUrl -OutFile $nugetExePath

    # Add the installation directory to the system PATH if it's not already present
    $pathEnv = [Environment]::GetEnvironmentVariable("PATH", "Machine")
    if (-not ($pathEnv -like "*$installDir*")) {
        $newPathEnv = $installDir + ";" + $pathEnv
        [Environment]::SetEnvironmentVariable("PATH", $newPathEnv, "Machine")
    }

    Write-Host "NuGet.exe installed successfully at $nugetExePath"
    Write-Host "Close this Powershell session and re-launch to use the installed nuget.exe." -ForegroundColor Yellow
    return 1

}

function Clear-NuGetCache {
    <#
    .SYNOPSIS
      Clears the NuGet cache.
    .DESCRIPTION
      This function clears the NuGet package cache. It first attempts to use
      `dotnet nuget locals all --clear` if `dotnet` is available and then falls
      back to manually clearing the cache directories.
    #>
  
    # Check if dotnet is installed and accessible.
    if (Get-Command dotnet -ErrorAction SilentlyContinue) {
      # Suppress all errors from dotnet command.
      try {
        dotnet nuget locals all --clear | Out-Null
      }
      catch {
        # Ignore any errors from the dotnet command.
      }
    } 
  
    # Get the user's profile directory.
    $userProfile = [Environment]::GetFolderPath([Environment+SpecialFolder]::UserProfile)
  
    # Define the cache directories.
    $cacheDirectories = @(
      "$userProfile\AppData\Local\NuGet\v3-cache"
      "$userProfile\.nuget\packages"
      "$userProfile\AppData\Local\Temp\NuGetScratch"
      "$userProfile\AppData\Local\NuGet\plugins-cache"
    )
  
    # Clear each cache directory.
    foreach ($dir in $cacheDirectories) {
      if (Test-Path -Path $dir) {
        Write-Host "Clearing NuGet cache: $dir"
        Remove-Item -Path "$dir\*" -Recurse -Force -ErrorAction SilentlyContinue
      }
    }
  
    Write-Host "Local resources cleared."
}
  
function Add-EntrinsecNugetSource {

    # Set the module path (you might want to make this configurable)
    $modulePath = "C:\Program Files\PowerShell\Modules" 
    Set-Location -Path "$modulePath"

    # Source name and URL
    $sourceName = "Entrinsec"
    $sourceUrl = "https://nuget.entrinsec.com/v3/index.json"

    # Check if the source already exists and remove it
    $existingSource = nuget sources list | Select-String -Pattern $sourceName
    if ($existingSource) {
        nuget sources remove -Name $sourceName
    }

    # Add the Entrinsec NuGet source
    nuget sources add -Name $sourceName -Source $sourceUrl

    # List all NuGet sources
    nuget sources list
}

function Install-EntrinsecCORE {
    [CmdletBinding()]
    param(
        [switch]$Silent = $false 
    )

    # Function to write output only if $Silent is not true
    function Write-Output {
        param(
            [string]$Message,
            [System.ConsoleColor]$ForegroundColor = 'White'
        )
        if (-not $Silent) {
            Write-Host $Message -ForegroundColor $ForegroundColor
        }
    }

    # $command = "nuget locals all -clear"
    # Write-Output "Clearing all NuGet caches..." -ForegroundColor Yellow
    # Invoke-Expression $command
    # Write-Output "NuGet caches cleared." -ForegroundColor Green

    Write-Output ""

    try {
        if (-not (Get-Module -ListAvailable -Name BurntToast)) {
            Install-Module -Name BurntToast -Repository PSGallery -AllowClobber -Force -ErrorAction Stop -Scope AllUsers
        }
        Write-Output "BurntToast module is available." -ForegroundColor Green
    }
    catch {
        Write-Host "BurntToast module could not be installed." -ForegroundColor Red
        Write-Host "Cannot continue installing Entrinsec modules without BurntToast." -ForegroundColor Red
        exit
    }
    
    # Set the output directory for the modules
    $outputDir = "C:\Program Files\PowerShell\Modules"

    $modules = @(
        "Entrinsec.Powershell.Common"
    )
    
    # Define the output directory
    $outputDir = "C:\Program Files\PowerShell\Modules"

    # Install and import each module
    foreach ($module in $modules) {
        Write-Output ""
        Write-Output "Installing module $module..." -ForegroundColor Cyan
        if (-not $Silent) {
            # Execute nuget.exe with output
            & "C:\Program Files\Nuget\nuget.exe" install $module -Source "Entrinsec" -OutputDirectory $outputDir -ExcludeVersion
        } else {
            # Execute nuget.exe silently
            & "C:\Program Files\Nuget\nuget.exe" install $module -Source "Entrinsec" -OutputDirectory $outputDir -ExcludeVersion *> $null
        }
    
        # Push current location onto the stack
        Push-Location
    
        # Change to the module directory
        Set-Location $outputDir\$module
    
        Write-Output "Importing module $module..." -ForegroundColor White
        try {
            Import-Module $module -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue # Use relative path
          }
          catch {
            try {
              Write-Warning "Failed to import module using relative path. Trying with './'."
              Import-Module .\$module -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue # Use explicit relative path
            }
            catch {
              Write-Error "Failed to import module '$module' using both relative paths."
            }
          }
        Write-Output ""
    
        # Pop the original location from the stack
        Pop-Location 
    }

    try {
        Write-Output ""
        Write-Output "Installing Entrinsec.Powershell.SETUP module from PSGallery..." -ForegroundColor Green
        Install-Module -Name Entrinsec.Powershell.SETUP -Repository PSGallery -AllowClobber -Force -ErrorAction SilentlyContinue -Scope AllUsers *>$null
        Import-Module Entrinsec.Powershell.SETUP -Force -ErrorAction SilentlyContinue *>$null
        Write-Output ""
    }
    catch {
    }
    
    # Enumerate the modules folder and import any module starting with Entrinsec.Powershell
    Get-ChildItem -Path $outputDir -Directory | ForEach-Object {
        if ($_.Name -like "Entrinsec.Powershell*") {
            Import-Module $_.FullName
        }
    }

    # Run a test with Show-ToastNotification
    # Show-ToastNotification -Title "Entrinsec Powershell" -Information "You have successfully installed the Core Entrinsec Powershell modules!"
}

function Update-EntrinsecEVERYTHING {
    Install-EntrinsecEVERYTHING
}

function Update-EntrinsecCORE {
    Install-EntrinsecCORE
}

function Update-EntrinsecENTERPRISE {
    Install-EntrinsecENTERPRISE
}

function Install-EntrinsecEVERYTHING {
    [CmdletBinding()]
    param(
        [switch]$Silent = $false
    )

    # Function to write output only if $Silent is not true
    function Write-Output {
        param(
            [string]$Message,
            [System.ConsoleColor]$ForegroundColor = 'White'
        )
        if (-not $Silent) {
            Write-Host $Message -ForegroundColor $ForegroundColor
        }
    }

    # $command = "nuget locals all -clear"
    # Write-Output "Clearing all NuGet caches..." -ForegroundColor Yellow
    # Invoke-Expression $command
    # Write-Output "NuGet caches cleared." -ForegroundColor Green
    
    Write-Output ""

    try {
        if (-not (Get-Module -ListAvailable -Name BurntToast)) {
            Install-Module -Name BurntToast -Repository PSGallery -AllowClobber -Force -ErrorAction Stop -Scope AllUsers
        }
        Write-Output "BurntToast module is available." -ForegroundColor Green
    }
    catch {
        Write-Host "BurntToast module could not be installed." -ForegroundColor Red
        Write-Host "Cannot continue installing Entrinsec modules without BurntToast." -ForegroundColor Red
        exit
    }

    # Set the output directory for the modules
    $outputDir = "C:\Program Files\PowerShell\Modules"

    # Define the list of modules
    $modules = @(
        "Entrinsec.Powershell.ADO",
        "Entrinsec.Powershell.Common",
        "Entrinsec.Powershell.Containers",
        "Entrinsec.Powershell.Data",
        "Entrinsec.Powershell.Directories",
        "Entrinsec.Powershell.Email",
        "Entrinsec.Powershell.Endpoint",
        "Entrinsec.Powershell.Forensics",
        "Entrinsec.Powershell.Gaming",
        "Entrinsec.Powershell.Geography",
        "Entrinsec.Powershell.GIT",
        "Entrinsec.Powershell.Identity",
        "Entrinsec.Powershell.Networking",
        "Entrinsec.Powershell.Software",
        "Entrinsec.Powershell.SCCM",
        "Entrinsec.Powershell.Scheduling",
        "Entrinsec.Powershell.SQL"
    )

    # Define the output directory
    $outputDir = "C:\Program Files\PowerShell\Modules"

    # Install and import each module
    foreach ($module in $modules) {
        Write-Output ""
        Write-Output "Installing module $module..." -ForegroundColor Cyan
        if (-not $Silent) {
            # Execute nuget.exe with output
            & "C:\Program Files\Nuget\nuget.exe" install $module -Source "Entrinsec" -OutputDirectory $outputDir -ExcludeVersion
        } else {
            # Execute nuget.exe silently
            & "C:\Program Files\Nuget\nuget.exe" install $module -Source "Entrinsec" -OutputDirectory $outputDir -ExcludeVersion *> $null
        }
    
        # Push current location onto the stack
        Push-Location
    
        # Change to the module directory
        Set-Location $outputDir\$module
    
        Write-Output "Importing module $module..." -ForegroundColor White
        try {
            Import-Module $module -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue # Use relative path
          }
          catch {
            try {
              Write-Warning "Failed to import module using relative path. Trying with './'."
              Import-Module .\$module -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue # Use explicit relative path
            }
            catch {
              Write-Error "Failed to import module '$module' using both relative paths."
            }
          }
        Write-Output ""
    
        # Pop the original location from the stack
        Pop-Location 
    }

    try {
        Write-Output ""
        Write-Output "Installing Entrinsec.Powershell.SETUP module from PSGallery..." -ForegroundColor Green
        Install-Module -Name Entrinsec.Powershell.SETUP -Repository PSGallery -AllowClobber -Force -ErrorAction SilentlyContinue -Scope AllUsers *>$null
        Import-Module Entrinsec.Powershell.SETUP -Force -ErrorAction SilentlyContinue *>$null         
        Write-Output ""
    }
    catch {
    }

    # Enumerate the modules folder and import any module starting with Entrinsec.Powershell
    Get-ChildItem -Path $outputDir -Directory | ForEach-Object {
        if ($_.Name -like "Entrinsec.Powershell*") {
            Import-Module $_.FullName
        }
    }

    # Run a test with Show-ToastNotification
    # Show-ToastNotification -Title "Entrinsec Powershell" -Information "You have successfully installed all currently available Entrinsec Powershell modules!"
}

function Initialize-EntrinsecNuget {
    
    <#
    .SYNOPSIS
        Sets up the Entrinsec PowerShell environment by installing NuGet,
        adding the Entrinsec NuGet source, and installing Entrinsec modules.
 
    .DESCRIPTION
        This function performs the following steps:
            1. Installs NuGet.exe if it's not already present.
            2. Adds the Entrinsec NuGet source.
            3. Installs core Entrinsec modules.
 
    .PARAMETER CORE
        Indicates whether to install core Entrinsec modules. Default is $true.
 
    .PARAMETER EVERYTHING
        Indicates whether to install all Entrinsec modules. Default is $false.
 
    .EXAMPLE
        PS> Initialize-EntrinsecNuget -CORE $true -EVERYTHING $false
 
    .NOTES
        Author: Entrinsec
        Date: 2024-11-19
        Version: 1.0
        Run as an administrator.
    #>

    param (
        [switch]$CORE = $false,
        [switch]$ENTERPRISE = $false,
        [switch]$EVERYTHING = $false
    )

    # Check if the user is an administrator
    if (-not ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
        Write-Host "You need to run this as an administrator." -ForegroundColor Red
        return
    }

    Write-Host "Setting up the Entrinsec PowerShell environment..." -ForegroundColor Cyan
    Write-Host "(Setup version : $SetupVersion)" -ForegroundColor Cyan
    if ($CORE) {
        Write-Host "Installing CORE Entrinsec modules..." -ForegroundColor Cyan
    } elseif ($ENTERPRISE) {
        Write-Host "Installing ENTERPRISE Entrinsec modules..." -ForegroundColor Cyan
    } elseif ($EVERYTHING) {
        Write-Host "Installing ALL Entrinsec modules..." -ForegroundColor Cyan
    } else {
        Write-Host "Installing CORE Entrinsec modules..." -ForegroundColor Cyan
    }
    Write-Host ""

    Show-EntrinsecLicenseInfoSETUP

    $NugetTest = Install-Nuget
    if ($NugetTest -ne 0) {
        Write-Host "NuGet installed. Need to exit this session and re-launch." -ForegroundColor Yellow
        pause
        exit
    }

    Write-Host ""

    # Adding the Entrinsec NuGet source
    Write-Host "Adding the Entrinsec NuGet source..." -ForegroundColor Green
    Add-EntrinsecNugetSource

    Write-Host ""

    # Cleaning up previous Entrinsec modules
    Remove-EntrinsecModules

    # Installing core Entrinsec modules as an example and a starting point
    if ($CORE) {
        Write-Host ""
        Write-Host "Installing core Entrinsec modules..." -ForegroundColor Green
        Install-EntrinsecCORE
        Write-Host ""
    } elseif ($ENTERPRISE) {
        Write-Host ""
        Write-Host "Installing Enterprise Entrinsec modules..." -ForegroundColor Green
        Install-EntrinsecENTERPRISE
        Write-Host ""
    } elseif ($EVERYTHING) {
        Write-Host ""
        Write-Host "Installing all Entrinsec modules..." -ForegroundColor Green
        Install-EntrinsecEVERYTHING
        Write-Host ""
    } else {
        Write-Host ""
        Write-Host "Installing core Entrinsec modules..." -ForegroundColor Green
        Install-EntrinsecCORE
        Write-Host ""
    }

    Write-Host ""
    Write-Host "Entrinsec PowerShell environment setup completed." -ForegroundColor Green
    Write-Host "It is recommended that you close any existing Powershell sessions to apply changes." -ForegroundColor Green
    Write-Host ""
}

function Remove-EntrinsecModules {
    param (
        [switch]$Test
    )

    Set-SetupVersion '0.0.0'

    Write-Host "Cleanup of Entrinsec modules, folders, and references..." -ForegroundColor Green
    Write-Host "Removing all Entrinsec modules, folders, and references from the local machine..." -ForegroundColor Yellow

    # Get all installed modules
    $modules = Get-Module -ListAvailable | Where-Object { $_.Name -like "Entrinsec.Powershell.*" }

    # Uninstall each module or perform a WhatIf
    foreach ($module in $modules) {
        if ($Test) {
            Uninstall-Module -Name $module.Name -Force -AllVersions -WhatIf -ErrorAction SilentlyContinue
        } else {
            Write-Host "Uninstalling $($module.Name)..." -ForegroundColor Yellow
            Uninstall-Module -Name $module.Name -Force -AllVersions -ErrorAction SilentlyContinue
        }
    }

    # Remove cached and memory-resident modules
    $loadedModules = Get-Module | Where-Object { $_.Name -like "Entrinsec.Powershell.*" }
    foreach ($loadedModule in $loadedModules | Where-Object { $_.Name -ne "Entrinsec.Powershell.SETUP" }) {
        if ($Test) {
            Write-Host "Would remove loaded module $($loadedModule.Name)" -ForegroundColor Yellow
        } else {
            Write-Host "Removing loaded module $($loadedModule.Name)..." -ForegroundColor Yellow
            Remove-Module -Name $loadedModule.Name -Force -ErrorAction SilentlyContinue
        }
    }

    # Define paths to check
    $paths = @(
        "C:\Program Files\PowerShell\Modules",
        "C:\Program Files\PowerShell\Modules",
        "$env:USERPROFILE\Documents\WindowsPowerShell\Modules",
        "$env:ProgramFiles\WindowsPowerShell\Modules",
        "$env:ProgramFiles(x86)\WindowsPowerShell\Modules"
    )

    # Remove corresponding folders or perform a WhatIf
    foreach ($path in $paths) {
        if (Test-Path -Path $path) {
            if ($Test) {
                Get-ChildItem -Path $path -Directory |
                Where-Object { $_.Name -like "Entrinsec.Powershell.*" } |
                Remove-Item -Recurse -Force -WhatIf -ErrorAction SilentlyContinue
            } else {
                Write-Host "Removing all Entrinsec modules from folder $($path)..." -ForegroundColor Yellow
                Get-ChildItem -Path $path -Directory |
                Where-Object { $_.Name -like "Entrinsec.Powershell.*" } |
                Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
            }
        }
    }

    Write-Host "All Entrinsec.Powershell.* modules, folders, and references have been processed on the local machine." -ForegroundColor Yellow
    Write-Host "Clearing NuGet cache." -ForegroundColor Yellow
    Clear-NuGetCache -erroraction SilentlyContinue -warningaction SilentlyContinue | out-null
}

function Install-EntrinsecModule {
    param (
        [Parameter(Mandatory=$true)]
        [string]$ModuleName
    )

    # Ensure the module name starts with "Entrinsec.Powershell."
    if ($ModuleName -notmatch "^Entrinsec\.Powershell\." -and $ModuleName -notmatch "^entrinsec\.powershell\." ) {
        $ModuleName = "Entrinsec.Powershell.$ModuleName"
    }

    # Set the output directory for the modules
    $outputDir = "C:\Program Files\PowerShell\Modules"

    # Install and import the specified module
    if ($ModuleName) {

        # Ensuring CORE Entrinsec
        Write-Host "Installing CORE Entrinsec modules..." -ForegroundColor Cyan
        Write-Host "(Setup version : $SetupVersion)" -ForegroundColor Cyan

        Install-EntrinsecCORE -Silent
        Write-Host "CORE Entrinsec modules installed successfully." -ForegroundColor Green
        Write-Host ""

        Write-Host "Installing module $ModuleName..." -ForegroundColor Cyan
        & "C:\Program Files\Nuget\nuget.exe" install $ModuleName -Source "Entrinsec" -OutputDirectory $outputDir -ExcludeVersion
        Import-Module "$outputDir\$ModuleName" -Force

        Write-Host ""
        Write-Host "Functions and aliases that are available in $ModuleName..." -ForegroundColor Green
        # List both functions and aliases in the module
        (Get-Command -Module $ModuleName -CommandType Function, Alias).Name | Sort-Object
        Write-Host ""
    }
    else {
        Write-Host "No module name provided." -ForegroundColor Red
    }

    # Run a test with Show-ToastNotification
    # Show-ToastNotification -Title "Entrinsec Powershell" -Information "You have successfully installed the specified Entrinsec Powershell module!"
}

function Install-EntrinsecENTERPRISE {
    [CmdletBinding()]
    param(
        [switch]$Silent = $false 
    )

    # Function to write output only if $Silent is not true
    function Write-Output {
        param(
            [string]$Message,
            [System.ConsoleColor]$ForegroundColor = 'White'
        )
        if (-not $Silent) {
            Write-Host $Message -ForegroundColor $ForegroundColor
        }
    }

    # $command = "nuget locals all -clear"
    # Write-Output "Clearing all NuGet caches..." -ForegroundColor Yellow
    # Invoke-Expression $command
    # Write-Output "NuGet caches cleared." -ForegroundColor Green

    Write-Output ""

    try {
        if (-not (Get-Module -ListAvailable -Name BurntToast)) {
            Install-Module -Name BurntToast -Repository PSGallery -AllowClobber -Force -ErrorAction Stop -Scope AllUsers
        }
        Write-Output "BurntToast module is available." -ForegroundColor Green
    }
    catch {
        Write-Host "BurntToast module could not be installed." -ForegroundColor Red
        Write-Host "Cannot continue installing Entrinsec modules without BurntToast." -ForegroundColor Red
        exit
    }
    
    # Set the output directory for the modules
    $outputDir = "C:\Program Files\PowerShell\Modules"

    $modules = @(
        "Entrinsec.Powershell.ADO",
        "Entrinsec.Powershell.Common",
        "Entrinsec.Powershell.Containers",
        "Entrinsec.Powershell.Data",
        "Entrinsec.Powershell.Directories",
        "Entrinsec.Powershell.Email",
        "Entrinsec.Powershell.Endpoint",
        "Entrinsec.Powershell.Forensics",
        "Entrinsec.Powershell.Geography",
        "Entrinsec.Powershell.GIT",
        "Entrinsec.Powershell.Identity",
        "Entrinsec.Powershell.Networking",
        "Entrinsec.Powershell.Software",
        "Entrinsec.Powershell.SCCM",
        "Entrinsec.Powershell.Scheduling",
        "Entrinsec.Powershell.SQL"
    )
    
    # Define the output directory
    $outputDir = "C:\Program Files\PowerShell\Modules"

    # Install and import each module
    foreach ($module in $modules) {
        Write-Output ""
        Write-Output "Installing module $module..." -ForegroundColor Cyan
        if (-not $Silent) {
            # Execute nuget.exe with output
            & "C:\Program Files\Nuget\nuget.exe" install $module -Source "Entrinsec" -OutputDirectory $outputDir -ExcludeVersion
        } else {
            # Execute nuget.exe silently
            & "C:\Program Files\Nuget\nuget.exe" install $module -Source "Entrinsec" -OutputDirectory $outputDir -ExcludeVersion *> $null
        }
        Write-Output "Importing module $module..." -ForegroundColor White
        try {
            Import-Module $module -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue # Use relative path
          }
          catch {
            try {
              Write-Warning "Failed to import module using relative path. Trying with './'."
              Import-Module .\$module -Force -ErrorAction SilentlyContinue -WarningAction SilentlyContinue # Use explicit relative path
            }
            catch {
              Write-Error "Failed to import module '$module' using both relative paths."
            }
          }
        Write-Output ""
    }

    try {
        Write-Output ""
        Write-Output "Installing Entrinsec.Powershell.SETUP module from PSGallery..." -ForegroundColor Green
        Install-Module -Name Entrinsec.Powershell.SETUP -Repository PSGallery -AllowClobber -Force -ErrorAction SilentlyContinue -Scope AllUsers *>$null
        Import-Module Entrinsec.Powershell.SETUP -Force -ErrorAction SilentlyContinue *>$null
        Write-Output ""
    }
    catch {
    }
    
    # Enumerate the modules folder and import any module starting with Entrinsec.Powershell
    Get-ChildItem -Path $outputDir -Directory | ForEach-Object {
        if ($_.Name -like "Entrinsec.Powershell*") {
            Import-Module $_.FullName
        }
    }

    # Run a test with Show-ToastNotification
    # Show-ToastNotification -Title "Entrinsec Powershell" -Information "You have successfully installed the Core Entrinsec Powershell modules!"
}

function Show-EntrinsecModulesVersionChecker {
    [CmdletBinding()]
    param(
        [switch]$UpdateCheck
    )

    Write-Host ""
    if ($UpdateCheck) {
        Write-Host "Checking for updates to Entrinsec modules..." -ForegroundColor Cyan
    } else {
        Write-Host "Checking installed versions of Entrinsec modules..." -ForegroundColor Cyan
    }

    # Array of module names to check
    $modulesToCheck = @(
        "ADO",
        "Common",
        "Containers",
        "Data",
        "Directories",
        "Email",
        "Endpoint",
        "Forensics",
        "Gaming",
        "Geography",
        "GIT",
        "Identity",
        "Networking",
        "SCCM",
        "Scheduling",
        "SETUP",
        "Software",
        "SQL"
    )

    # Loop through each module and call its update check function
    foreach ($module in $modulesToCheck) {
        $functionName = "Show-Entrinsec$module" + "Info"
        if (Get-Command $functionName -ErrorAction SilentlyContinue) {
            & $functionName -UpdateCheck
        }
    }

    Write-Host ""
    Write-Host "Update check completed." -ForegroundColor Green
    Write-Host ""

}

function Update-EntrinsecNuGetPackage {
    param (
        [Parameter(Mandatory=$true)]
        [string]$PackageName,
        [string]$OutputDirectory = "C:\Program Files\Powershell\Modules",
        [string]$NuGetExePath = "C:\Program Files\Nuget\nuget.exe",
        [string]$SourceUrl = "https://nuget.entrinsec.com/v3/index.json"
    )

    # Function to check if the script is run as an administrator
    function Test-IsAdmin {
        $currentUser = [Security.Principal.WindowsIdentity]::GetCurrent()
        $principal = New-Object Security.Principal.WindowsPrincipal($currentUser)
        return $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
    }

    try {
        # Check for admin privileges if the OutputDirectory is "C:\Program Files\Powershell\Modules"
        if ($OutputDirectory -eq "C:\Program Files\Powershell\Modules" -and -not (Test-IsAdmin)) {
            throw "Please run this script with administrative privileges."
        }

        Write-Host ""
        Write-Host "Updating (re-installing) the package $PackageName..." -ForegroundColor Cyan
        Write-Host ""
        
        # Clear all NuGet caches
        & $NuGetExePath locals all -clear

        # Remove the existing package folder
        $packagePath = Join-Path -Path $OutputDirectory -ChildPath $PackageName
        if (Test-Path $packagePath) {
            Remove-Item -Recurse -Force $packagePath
        }

        # Install the latest version of the package
        & $NuGetExePath install $PackageName -Source $SourceUrl -OutputDirectory $OutputDirectory -ExcludeVersion
        
        Write-Host ""
        Write-Host "Package $PackageName updated successfully." -ForegroundColor Green
        Write-Host ""
    }
    catch {
        Write-Host "An error occurred: $_" -ForegroundColor Red
    }
}

function Get-HighestModuleVersion {
    param (
        [Parameter(Mandatory=$true)]
        [string]$ModuleName
    )

    try {
        # Get all versions of the specified module
        $modules = Get-Module -Name $ModuleName -ListAvailable

        # Check if any versions are available
        if ($modules.Count -eq 0) {
            return "UNKNOWN"
        }

        # Get the highest version number
        $highestVersion = $modules | Sort-Object Version -Descending | Select-Object -First 1

        # Output the highest version number as a string
        return $highestVersion.Version.ToString()
    }
    catch {
        Write-Host "An error occurred: $_" -ForegroundColor Red
        return "UNKNOWN"
    }
}

function Show-EntrinsecINFO {
    # $MyModuleVersion = Get-HighestModuleVersion -ModuleName Entrinsec.Powershell.SETUP
    Write-Host ""
    Write-Host 'ENTRINSEC (https://www.entrinsec.com)' -ForegroundColor Blue
    Write-Host 'MIT Licensed (https://docs.entrinsec.com/BaGet/Entrinsec-License)' -ForegroundColor Blue
    Show-EntrinsecSETUPInfo
    # write-host "Module Version: $($MyModuleVersion)" -ForegroundColor Blue
    Write-Host ""
    Write-Host "SETUP (As admin)" -ForegroundColor DarkCyan
    Write-Host ""
    Write-Host ' Install SETUP' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Install-Module -Name Entrinsec.Powershell.SETUP -Repository "PSGallery" -Force -Scope AllUsers'  -ForegroundColor White
    Write-Host ' Import SETUP' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Import-Module -Name Entrinsec.Powershell.SETUP -Force -Global'  -ForegroundColor White
    Write-Host ""
    Write-Host ""
    Write-Host "INITIALIZATION (As admin)" -ForegroundColor DarkCyan
    Write-Host ""
    Write-Host ' Initialize as CORE' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Initialize-EntrinsecNuget -CORE' -ForegroundColor White
    Write-Host ""
    Write-Host " or"
    Write-Host ""
    Write-Host ' Initialize as ENTERPRISE' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Initialize-EntrinsecNuget -ENTERPRISE' -ForegroundColor White
    Write-Host ""
    Write-Host " or"
    Write-Host ""
    Write-Host ' Initialize as EVERYTHING' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Initialize-EntrinsecNuget -EVERYTHING' -ForegroundColor White
    Write-Host ""
    Write-Host ""
    Write-Host "Import Entrinsec Modules" -ForegroundColor DarkCyan
    Write-Host ""
    Write-Host ' Perform an Import-Module on all Entrinsec.Powershell modules that are currently installed.' -ForegroundColor Cyan
    Write-Host ' This is useful at the start of any PS1 script that uses Entrinsec.Powershell modules.' -ForegroundColor Cyan 
    Write-Host ' Entrinsec modules import (Optional switches -Forced -VerboseOuput)' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Import-EntrinsecModules -Forced -VerboseOutput' -ForegroundColor White
    Write-Host ""
    # Import-EntrinsecModulesForce
    Write-Host ""
    Write-Host "VERSION CHECKS" -ForegroundColor DarkCyan
    Write-Host ""
    Write-Host ' Check Installed Version' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Show-EntrinsecModulesVersionChecker' -ForegroundColor White
    Write-Host ""
    Write-Host ""
    Write-Host "UPDATING (As admin)" -ForegroundColor DarkCyan
    Write-Host ""
    Write-Host ' Update an Entrinsec Powershell module' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Update-EntrinsecNuGetPackage -PackageName <entrinsec.powershell.xxxxxxx>' -ForegroundColor White
    Write-Host ' For example' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Update-EntrinsecNuGetPackage -PackageName Entrinsec.Powershell.COMMON' -ForegroundColor White
    Write-Host ""
    Write-Host ""
    Write-Host "REMOVAL (As admin)" -ForegroundColor DarkCyan
    Write-Host ""
    Write-Host ' Remove ALL Entrinsec Powershell modules' -ForegroundColor Cyan -NoNewline
    Write-Host ' : Remove-EntrinsecModules' -ForegroundColor White
    Write-Host ""
    Write-Host ""
}

# Export aliases
# Set-Alias -Name "Entrinsec" -Value "Show-EntrinsecINFO" -Description "How to provision Entrinsec Powershell modules" -Scope Global
# Set-Alias -Name "Entrinsec-Help" -Value "Show-EntrinsecINFO" -Description "How to provision Entrinsec Powershell modules" -Scope Global
# Set-Alias -Name "Entrinsec-Info" -Value "Show-EntrinsecINFO" -Description "How to provision Entrinsec Powershell modules" -Scope Global
# Set-Alias -Name "Show-Entrinsec" -Value "Show-EntrinsecINFO" -Description "How to provision Entrinsec Powershell modules" -Scope Global
# Export-ModuleMember -Alias Entrinsec, Show-Entrinsec

function Import-EntrinsecModules {
    param (
        [Parameter(Mandatory=$false)]
        [string]$modulePath = "C:\Program Files\PowerShell\Modules",

        [switch]$VerboseOutput = $false,
        [switch]$Forced = $false
    )
    
    # Check if the directory exists
    if (-Not (Test-Path -Path $modulePath)) {
        Write-Error "The specified module path '$modulePath' does not exist."
        return
    }

    # Get directories that start with "Entrinsec.Powershell."
    $modules = Get-ChildItem -Path $modulePath -Directory | Where-Object {
        $_.Name -like "Entrinsec.Powershell.*"
    }

    if ($modules.Count -eq 0) {
        if ($VerboseOutput) {
            Write-Host "No modules starting with 'Entrinsec.Powershell.' were found in '$modulePath'." -ForegroundColor Yellow
        }
        return
    }

    # Separate the SETUP module and other modules
    $setupModule = $modules | Where-Object { $_.Name -eq "Entrinsec.Powershell.SETUP" }
    $otherModules = $modules | Where-Object { $_.Name -ne "Entrinsec.Powershell.SETUP" }

    # Import the SETUP module first
    if ($setupModule) {
        try {
            if ($VerboseOutput) {
                Write-Host "Attempting to import SETUP module: $($setupModule.Name)" -ForegroundColor White
            }
            Import-Module -Name $setupModule.Name -Force:($Forced.IsPresent) -ErrorAction Stop
            if ($VerboseOutput) {
                Write-Host "Successfully imported SETUP module: $($setupModule.Name)" -ForegroundColor Green
            }
        } catch {
            Write-Host "Failed to import SETUP module: $($setupModule.Name). Error: $_" -ForegroundColor Red
        }
    }

    # Import other modules
    foreach ($module in $otherModules) {
        try {
            if ($VerboseOutput) {
                Write-Host "Attempting to import module: $($module.Name)" -ForegroundColor White
            }
            Import-Module -Name $module.Name -Force:($Forced.IsPresent) -ErrorAction Stop
            if ($VerboseOutput) {
                Write-Host "Successfully imported module: $($module.Name)" -ForegroundColor Green
            }
        } catch {
            Write-Host "Failed to import module: $($module.Name). Error: $_" -ForegroundColor Red
        }
    }
}