$targetDirectory = "C:\Your\Target\Directory"

Step 2: Get all files in the target directory
We will retrieve all files from the specified directory. This is essential for processing each file based on its extension.

$files = Get-ChildItem -Path $targetDirectory -File

Step 3: Iterate through each file
Using a loop, we will go through each file retrieved in the previous step. This allows us to perform operations on each individual file.

foreach ($file in $files) {

Step 4: Extract the file extension
For each file, we’ll obtain its extension. This will be used to create appropriate subfolders for organizing the files.

    $extension = $file.Extension.TrimStart('.')

Step 5: Create a subfolder for each extension
We will check if a subfolder for the file extension exists, and if not, create it. This will ensure that files are organized properly.

    $subfolderPath = Join-Path -Path $targetDirectory -ChildPath $extension
    if (-not (Test-Path -Path $subfolderPath)) {
        New-Item -ItemType Directory -Path $subfolderPath | Out-Null
    }

Step 6: Move the file to the corresponding subfolder
Finally, we will move each file into its respective subfolder based on its extension. This completes the organization process.

    $destinationPath = Join-Path -Path $subfolderPath -ChildPath $file.Name
    Move-Item -Path $file.FullName -Destination $destinationPath
}

Final Step: Execute the script
Once the entire script is assembled, you can execute it in your PowerShell environment to manage your files efficiently. Enjoy a well-organized file structure!

The post Efficient File Management with PowerShell first appeared on CForce-IT.com.

# Define the target server and share path to analyze
$serverName = "YourServerName"  # Replace with your server name
$sharePath = "\\$serverName\*"  # Wildcard to search all shares

In this block, we define the `$serverName` variable for the target server and construct the `$sharePath` using a UNC path. You should replace `”YourServerName”` with your actual server name.
Step 2: Get List of Shared Folders
Next, we will collect the list of shared folders on the defined server using the `Get-WmiObject` cmdlet, which allows us to query WMI classes.

# Retrieve shared folders from the server
$shares = Get-WmiObject -Class Win32_Share -ComputerName $serverName | Where-Object { $_.Path }
$sharesList = $shares | Select-Object Name, Path, Description

This step queries the `Win32_Share` WMI class to get all shares on the specified server. We filter the results to include only those with a valid path and select relevant information such as `Name`, `Path`, and `Description`.
Step 3: Calculate Folder Sizes
For each shared folder, we will now calculate its total size. This is done by summing the sizes of all files within the shared folder.

$folderSizes = @()
foreach ($share in $sharesList) {
    $totalSize = (Get-ChildItem -Path $share.Path -Recurse -File -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum
    $folderSizes += [PSCustomObject]@{
        Name        = $share.Name
        Path        = $share.Path
        SizeInMB    = [math]::round($totalSize / 1MB, 2)
        Description = $share.Description
    }
}

In this section, we iterate through the list of shared folders. For each share, we use `Get-ChildItem` with recursion to calculate the total size of all files. The results are stored in a custom PowerShell object containing the share’s name, path, size in MB, and description.
Step 4: Output the Report
With the collected data, we will create a clear and concise report to display the information about each shared folder, including its size.

# Display the folder sizes in a formatted table
$folderSizes | Format-Table -AutoSize

This final step outputs the list of shared folders and their sizes in a formatted table for easy reading. `Format-Table -AutoSize` ensures that the columns are properly aligned.
Step 5: Optional – Export the Report to CSV
If needed, we can also export the report to a CSV file for further analysis or record-keeping.

# Export folder sizes report to a CSV file
$exportPath = "C:\NetworkShareUsageReport.csv"
$folderSizes | Export-Csv -Path $exportPath -NoTypeInformation
Write-Host "Report exported to $exportPath"

In this optional step, we export the collected data to a CSV file, allowing for further analysis or sharing with other team members. The `-NoTypeInformation` parameter ensures that no additional type information is included in the CSV file.
By employing this script, system administrators can efficiently monitor network share usage, manage storage, and optimize resource allocation across the network, ensuring a well-maintained environment.

The post Network Share Usage Report Script first appeared on CForce-IT.com.

# Define the path to search for large files
$searchPath = "C:\"
# Set the minimum file size threshold in MB
$sizeThresholdMB = 100
$sizeThresholdBytes = $sizeThresholdMB * 1MB

In this code block, we define `$searchPath` as the directory to search (in this case, the C drive) and set `$sizeThresholdMB` to filter files larger than 100 MB. The size is converted into bytes for comparison.
Step 2: Retrieve Large Files
Next, we will gather a list of files larger than the defined size threshold using the `Get-ChildItem` cmdlet, which retrieves the files from the specified path.

# Get files larger than the threshold in the specified path
$largeFiles = Get-ChildItem -Path $searchPath -Recurse -File | Where-Object { $_.Length -gt $sizeThresholdBytes }

Here, the script uses `Get-ChildItem` with the `-Recurse` parameter to search through all subdirectories for files. The `Where-Object` clause filters out the files that exceed the defined size.
Step 3: Display the List of Large Files
Once we have the large files, we will output them in a readable format with relevant information such as name, size, and path.

# Display file details: Name, Size (MB), and Path
$largeFiles | Select-Object Name, @{Name="Size (MB)"; Expression={[math]::round($_.Length / 1MB, 2)}}, FullName | Format-Table -AutoSize

This block formats the output to display only the necessary details: the name of the file, its size in MB (rounded to two decimal places), and its full path. The `Format-Table -AutoSize` ensures the output is neatly aligned.
Step 4: Prompt User for Deletion Option
After displaying the large files, we will ask the user if they want to delete any of these files. This step is crucial for preventing accidental data loss.

# Ask user for deletion
$deleteFiles = Read-Host "Do you want to delete any of these files? (Y/N)"
if ($deleteFiles -eq 'Y') {
    foreach ($file in $largeFiles) {
        # Prompt for each file deletion
        $confirmDelete = Read-Host "Do you want to delete $($file.FullName)? (Y/N)"
        if ($confirmDelete -eq 'Y') {
            Remove-Item -Path $file.FullName -Force
            Write-Host "Deleted: $($file.FullName)"
        }
    }
} else {
    Write-Host "No files will be deleted."
}

In this section, if the user responds with ‘Y’ to the deletion prompt, the script will iterate through the list of large files and confirm each deletion. The `Remove-Item` cmdlet is used to delete the file if confirmed.
Step 5: Completion Message
Finally, we will provide a completion message for clarity on the outcome of the script, whether files were deleted or not.

Write-Host "Disk space cleanup operation completed."

This concluding step gives feedback to the user, indicating that the operation has finished, providing closure to the script execution.
By employing this script, system administrators can effectively manage disk space by identifying and removing large files, thus enhancing system performance and preventing potential storage issues. This proactive approach is essential for maintaining a healthy IT environment.

The post Disk Space Cleanup and Report Script first appeared on CForce-IT.com.

$osInfo = Get-CimInstance -ClassName Win32_OperatingSystem | Select-Object Name, Version, BuildNumber, OSArchitecture, LastBootUpTime
$osInfo

In this step, we use the `Get-CimInstance` cmdlet to access the `Win32_OperatingSystem` class, which contains essential data about the operating system. The `Select-Object` cmdlet ensures that we only display relevant fields.
Step 2: Retrieve Hardware Information
Next, we will gather details about the system’s processor and memory capacity.

$cpuInfo = Get-CimInstance -ClassName Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors, MaxClockSpeed
$memoryInfo = Get-CimInstance -ClassName Win32_PhysicalMemory | Measure-Object -Property Capacity -Sum
$totalMemoryGB = [math]::round($memoryInfo.Sum / 1GB, 2)
$cpuInfo
$totalMemoryGB

This block retrieves the CPU details (name, core count, logical processors, and max speed) and calculates the total physical memory by summing the capacities of each memory stick. The result is converted to gigabytes for easier understanding.
Step 3: List Installed Software
We will compile a list of installed software by checking the `Win32_Product` class, which provides information about the products installed on the system.

$installedSoftware = Get-CimInstance -ClassName Win32_Product | Select-Object Name, Version, Vendor
$installedSoftware

Using the `Get-CimInstance` cmdlet once more, we access the `Win32_Product` class to enumerate the installed software. The output includes the name, version, and vendor of each application.
Step 4: Check Running Services
Next, we will retrieve information about the currently running services, focusing on their statuses and display names.

$runningServices = Get-Service | Where-Object { $_.Status -eq 'Running' } | Select-Object DisplayName, ServiceName, Status
$runningServices

In this step, we utilize the `Get-Service` cmdlet to list all services, filtering to show only those that are currently running. The output will display the service’s display name, service name, and status.
Step 5: Output Summary Report
Finally, we will format a summary report combining all collected information to display it in a user-friendly format.

Write-Host "System Information Summary Report"
Write-Host "-------------------------------------"
Write-Host "Operating System: $($osInfo.Name), Version: $($osInfo.Version), Build: $($osInfo.BuildNumber), Architecture: $($osInfo.OSArchitecture)"
Write-Host "Last Boot Time: $($osInfo.LastBootUpTime)"
Write-Host "CPU Info: $($cpuInfo.Name), Cores: $($cpuInfo.NumberOfCores), Logical Processors: $($cpuInfo.NumberOfLogicalProcessors), Max Clock Speed: $($cpuInfo.MaxClockSpeed) MHz"
Write-Host "Total Physical Memory: $totalMemoryGB GB"
Write-Host "-------------------------------------"
Write-Host "Running Services:"
$runningServices | Format-Table -AutoSize
Write-Host "-------------------------------------"
Write-Host "Installed Software:"
$installedSoftware | Format-Table -AutoSize

This final block organizes and prints a summary report of the system’s information, including OS, CPU, total memory, running services, and installed software. This makes it easy for system administrators to assess the machine’s health and inventory.
By using this automated script, administrators can efficiently gather comprehensive system information, making it easier to perform audits, troubleshoot issues, and manage software inventories. This tool enhances day-to-day operations and contributes to better system management practices.

The post Automated System Information Gatherer Script first appeared on CForce-IT.com.

$networkAdapters = Get-NetAdapter | Where-Object { $_.Status -eq 'Up' }

In this line, we use the `Get-NetAdapter` cmdlet to get a list of all network adapters and filter them to include only those with a status of “Up,” indicating that they are currently active.
Step 2: Display Basic Information About Each Adapter
Next, we will iterate through the active network adapters and display key details, such as the adapter name, its interface description, and the link speed.

foreach ($adapter in $networkAdapters) {
    $adapterInfo = @{
        'Name'               = $adapter.Name
        'InterfaceDescription' = $adapter.InterfaceDescription
        'LinkSpeed(Mbps)'    = [math]::round($adapter.LinkSpeed / 1MB, 2)
    }
    $adapterInfo
}

In this block, we create a custom hashtable to store and display the adapter’s essential attributes. We calculate the link speed in Mbps by converting from bytes to megabits.
Step 3: Check IP Configuration for Each Adapter
We will now retrieve and display the IP configuration for each active adapter, including its IP address and subnet mask.

foreach ($adapter in $networkAdapters) {
    $ipConfig = Get-NetIPAddress -InterfaceAlias $adapter.Name | Select-Object IPAddress, PrefixLength
    $ipConfig | ForEach-Object {
        Write-Host "Adapter: $($adapter.Name) - IP Address: $($_.IPAddress) - Subnet Mask: $($_.PrefixLength)"
    }
}

This step uses `Get-NetIPAddress` to fetch the IP configuration details of each adapter. We select the `IPAddress` and `PrefixLength`, which represents the subnet mask, and then output the results.
Step 4: Check Network Connectivity
To ensure each adapter can reach a common external address (like Google), we will perform a simple ping test on each active network adapter.

foreach ($adapter in $networkAdapters) {
    $pingResult = Test-Connection -ComputerName "google.com" -Count 2 -ErrorAction SilentlyContinue
    if ($pingResult) {
        Write-Host "Adapter: $($adapter.Name) - Connectivity: Online"
    } else {
        Write-Host "Adapter: $($adapter.Name) - Connectivity: Offline"
    }
}

In this section, we utilize `Test-Connection` to ping Google to verify connectivity. Depending on whether the ping is successful, we indicate whether the adapter is currently online or offline.
Step 5: Summarize Connectivity Status Report
Finally, we will summarize the overall connectivity status of the network adapters to present an easy-to-understand report.

Write-Host "Network Connection Status Report:"
foreach ($adapter in $networkAdapters) {
    Write-Host "--------------------------------"
    Write-Host "Adapter: $($adapter.Name)"
    Write-Host "Status: Up"
    $ipConfig = Get-NetIPAddress -InterfaceAlias $adapter.Name | Select-Object IPAddress, PrefixLength
    foreach ($ip in $ipConfig) {
        Write-Host "IP Address: $($ip.IPAddress) | Subnet Mask: $($ip.PrefixLength)"
    }
    $pingResult = Test-Connection -ComputerName "google.com" -Count 1 -ErrorAction SilentlyContinue
    Write-Host "Connectivity: $(if ($pingResult) { 'Online' } else { 'Offline' })"
}

This final block provides a consolidated connectivity status report for all active network adapters, ensuring that system administrators can review their network health quickly.
By executing this script, network administrators can gain valuable insights into the status of their network connections, enhancing their ability to manage and troubleshoot network resources effectively.

The post Network Connection Status Checker Script first appeared on CForce-IT.com.

Import-Module ActiveDirectory

This command loads the Active Directory module into the current PowerShell session, enabling us to use cmdlets like `Get-ADUser`.
Step 2: Define Time Period for Inactivity
Next, we will define the time period for considering an account as inactive. For example, you might want to check for accounts inactive for more than 90 days.

$inactiveDaysThreshold = 90
$cutoffDate = (Get-Date).AddDays(-$inactiveDaysThreshold)

In this step, we calculate the cutoff date by subtracting the defined number of days from the current date. This helps in filtering users who haven’t logged in recently.
Step 3: Retrieve User Accounts and Filter Status
Now, we will retrieve all user accounts and filter them based on various criteria: whether they are locked, expired, or inactive.

$users = Get-ADUser -Filter * -Properties LockedOut, AccountExpirationDate, LastLogonDate
$filteredUsers = $users | Where-Object {
    ($_."LockedOut" -eq $true) -or
    ($_.AccountExpirationDate -ne $null -and $_.AccountExpirationDate -lt (Get-Date)) -or
    ($_.LastLogonDate -lt $cutoffDate -and $_.LastLogonDate -ne $null)
}

In this block, we gather all users along with specified properties. Then we filter the user accounts to find those that are locked out, have expired, or have not logged in since the defined cutoff date.
Step 4: Create and Export the Report
With the filtered list of user accounts, we can create a report and export it to a CSV file for further analysis or record-keeping.

$reportPath = "C:\UserAccountStatusReport.csv"
$filteredUsers | Select-Object Name, LockedOut, AccountExpirationDate, LastLogonDate | Export-Csv -Path $reportPath -NoTypeInformation

This step selects the relevant properties from the filtered user accounts and exports the information to a CSV file located at `C:\UserAccountStatusReport.csv`. The `-NoTypeInformation` parameter prevents type information from being included in the CSV.
Step 5: Notify Completion of the Report Generation
Lastly, we can notify the user that the report has been successfully generated.

Write-Host "User account status report generated successfully at $reportPath"

This command provides a confirmation message indicating the location of the generated report, enhancing user experience by ensuring they know where to find the output.
By following these steps, this PowerShell script streamlines the process of monitoring user account statuses in Active Directory, making it easier for administrators to manage user access while ensuring compliance with security policies.

The post User Account Status Reporting Script first appeared on CForce-IT.com.

$drives = @('C:', 'D:', 'E:')
$threshold = 10  # Threshold in GB

In this block, the `$drives` array contains the drive letters to be monitored, and the `$threshold` variable determines the minimum available space (in GB) before an alert will be generated.
Step 2: Check Disk Space for Each Drive
Next, we will loop through each specified drive to check its available disk space using the Get-PSDrive cmdlet.

foreach ($drive in $drives) {
    $diskSpace = Get-PSDrive -Name $drive
    $availableSpaceGB = [math]::round($diskSpace.Free / 1GB, 2)
    if ($availableSpaceGB -le $threshold) {
        Write-Host "Warning: Drive $drive has only $availableSpaceGB GB left."
    } else {
        Write-Host "Drive $drive has $availableSpaceGB GB available."
    }
}

In this block, the script retrieves the free disk space for each drive and then compares it to the predefined threshold. If the available space is less than or equal to the threshold, a warning message is displayed; otherwise, it shows the available space.
Step 3: Log Disk Space Information
For better monitoring and future reference, we can log the disk space information to a text file.

$logFilePath = "C:\DiskSpaceLog.txt"
$currentDateTime = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
foreach ($drive in $drives) {
    $diskSpace = Get-PSDrive -Name $drive
    $availableSpaceGB = [math]::round($diskSpace.Free / 1GB, 2)
    $logMessage = "$currentDateTime - Drive $drive: $availableSpaceGB GB available"
    Add-Content -Path $logFilePath -Value $logMessage
}

This block creates a log entry for each drive, recording the available space along with the timestamp. The log is saved in a text file located at `C:\DiskSpaceLog.txt`.
Step 4: Schedule the Script
To maintain continuous monitoring, its recommended to schedule this script to run at regular intervals using Windows Task Scheduler. This step is not included in the PowerShell script itself but can be accomplished via the Task Scheduler GUI.
By following these steps, this automated disk space monitoring script helps administrators keep track of disk usage efficiently. It acts as a proactive measure to avoid performance issues related to low disk space and ensures system reliability.

The post Automated Disk Space Monitoring Script first appeared on CForce-IT.com.

Import-Module ActiveDirectory

Using the Import-Module cmdlet, we ensure that our script can access Active Directory functions.
Step 2: Get All User Accounts
Next, we will retrieve all user accounts from Active Directory. This forms the foundation for our security audit.

$users = Get-ADUser -Filter * -Properties Enabled, LastLogonDate, AccountExpirationDate

Here, we use the Get-ADUser cmdlet to gather all user accounts while also retrieving specific properties related to account status.
Step 3: Filter and Analyze User Accounts
In this step, we will filter the user accounts to identify those that are disabled, expired, or have never been logged in.

$problematicUsers = $users | Where-Object {
    ($_.Enabled -eq $false) -or
    ($_.AccountExpirationDate -lt (Get-Date)) -or
    ($_.LastLogonDate -eq $null)
}

With this block, we create a collection of accounts that meet our security risk criteria.
Step 4: Display Problematic Users
Now we will display the filtered accounts in a user-friendly format, making it easier for administrators to review the results.

$problematicUsers | Select-Object Name, Enabled, LastLogonDate, AccountExpirationDate | Format-Table -AutoSize

In this block, we use Select-Object to choose specific properties to display, and Format-Table ensures the output is organized neatly.
Step 5: Export Results to CSV
Finally, we can export the list of problematic accounts to a CSV file for further analysis or reporting purposes.

$problematicUsers | Export-Csv -Path 'C:\UserAuditReport.csv' -NoTypeInformation

This command generates a CSV file containing details of the user accounts flagged during the audit, which can be opened in Excel or other programs.
By following these steps, administrators can effectively monitor user accounts in Active Directory, ensuring that potential security risks are addressed promptly. This script serves as a crucial tool for maintaining a secure environment.

The post PowerShell Script to Audit User Account Security first appeared on CForce-IT.com.

$logFile = "C:\UserAccountAudit.log"
$inactiveDaysThreshold = 90

Step 2: Get Current Date
Next, we will get the current date to compare against user account last logon dates.

$currentDate = Get-Date

Step 3: Retrieve User Accounts
We will retrieve all user accounts from Active Directory along with their last logon date.

$users = Get-ADUser -Filter * -Property LastLogonDate

Step 4: Filter Inactive Users
Filter the user accounts to find those that haven’t logged on in the past specified number of days.

$inactiveUsers = $users | Where-Object {
    ($currentDate - $_.LastLogonDate).Days -gt $inactiveDaysThreshold
}

Step 5: Log Inactive Users
Finally, we will log the inactive user accounts to the specified log file.

if ($inactiveUsers) {
    $inactiveUsers | ForEach-Object {
        Add-Content -Path $logFile -Value "$($_.Name) is inactive since $($_.LastLogonDate)"
    }
} else {
    Add-Content -Path $logFile -Value "No inactive accounts found."
}

Step 6: Output Result
Output the results to the console for immediate feedback.

Get-Content -Path $logFile | Write-Host

This script provides a comprehensive overview of user account activity, allowing you to proactively manage and secure user access within your organization.

The post Secure User Account Audit Script first appeared on CForce-IT.com.

$localDir = “C:\Path\To\Local\Directory”
$remoteDir = “\\Server\Share\Path”

Step 2: Check Remote Directory Accessibility
Next, we will verify whether the remote directory is accessible. If it is not, we will exit the script with an error message.

if (-not (Test-Path $remoteDir)) {
Write-Host “Error: Remote directory is not accessible. Please check the path and permissions.” -ForegroundColor Red
exit
}

Step 3: Get List of Files to Synchronize
We will retrieve the list of files from the local directory and compare them to the files in the remote directory. This way, we can identify which files need to be copied or updated.

$localFiles = Get-ChildItem -Path $localDir -File
$remoteFiles = Get-ChildItem -Path $remoteDir -File
$filesToSync = $localFiles | Where-Object {
-not ($remoteFiles | Where-Object { $_.Name -eq $_.Name -and $_.LastWriteTime -eq $_.LastWriteTime })
}

Step 4: Perform the Synchronization
Now, we will loop through the files determined to need synchronization and copy them to the remote directory. We will implement error handling to ensure the script runs smoothly.

foreach ($file in $filesToSync) {
try {
Copy-Item -Path $file.FullName -Destination $remoteDir -ErrorAction Stop
Write-Host “Successfully synchronized $($file.Name) to $remoteDir”
} catch {
Write-Host “Failed to synchronize $($file.Name): $_” -ForegroundColor Red
}
}

Step 5: Summary of the Synchronization Process
After the synchronization has been completed, we will output a summary of how many files were synchronized and whether there were any errors during the process.

$syncedCount = $filesToSync.Count
Write-Host “$syncedCount file(s) have been synchronized to $remoteDir.”

The post Remote Directory Synchronization with PowerShell first appeared on CForce-IT.com.

$cpuUsage = Get-WmiObject -Class Win32_Processor | Measure-Object -Property LoadPercentage -Average | Select-Object -ExpandProperty Average
$memInfo = Get-WmiObject -Class Win32_OperatingSystem
$totalMemory = $memInfo.TotalVisibleMemorySize
$freeMemory = $memInfo.FreePhysicalMemory
$usedMemory = $totalMemory – ($freeMemory * 1MB)
$memoryUsagePercentage = [math]::round(($usedMemory / $totalMemory) * 100, 2)

Step 2: Format and Display Performance Data
Now that we have gathered the performance data, we will format it for better readability and display the results to the user.

$performanceReport = @{
‘CPU Usage (%)’ = $cpuUsage
‘Used Memory (MB)’ = [math]::round($usedMemory / 1MB, 2)
‘Free Memory (MB)’ = [math]::round($freeMemory / 1MB, 2)
‘Memory Usage (%)’ = $memoryUsagePercentage
}
$performanceReport.GetEnumerator() | ForEach-Object {
Write-Host “$($_.Key): $($_.Value)”
}

Step 3: Log Performance Data to a File
To keep track of performance metrics over time, we will log this data to a text file. This can be beneficial for future analysis.

$logFilePath = “C:\Path\To\Your\PerformanceLog.txt”
$dateTime = Get-Date -Format “yyyy-MM-dd HH:mm:ss”
$logEntry = “$dateTime – CPU Usage: $cpuUsage%, Memory Usage: $memoryUsagePercentage%”
Add-Content -Path $logFilePath -Value $logEntry

Step 4: Set Up a User-Friendly Notification
Finally, we will set up a user-friendly notification to alert users about the current system performance, especially if the performance metrics are high.

if ($cpuUsage -gt 80 -or $memoryUsagePercentage -gt 80) {
[System.Windows.MessageBox]::Show(“ALERT: High System Resource Usage! Review performance metrics.”, “Performance Notification”, 0, [System.Windows.MessageBoxIcon]::Warning)
}

Step 5: Schedule the Script (Optional)
To continuously monitor system performance, you can schedule this script to run at set intervals using Windows Task Scheduler. This allows for real-time monitoring without manual intervention.

# This step typically involves using Task Scheduler within Windows, so no specific PowerShell code is provided here.

The post Monitor System Performance with PowerShell first appeared on CForce-IT.com.

$sourceDir = “C:\Path\To\Source”
$backupDir = “D:\Path\To\Backup”

Step 2: Check if the Backup Directory Exists
We will check if the backup directory already exists. If not, we will create it to ensure that our files have a destination for the backup process.

if (-not (Test-Path $backupDir)) {
New-Item -ItemType Directory -Path $backupDir
}

Step 3: Get List of Files to Backup
Next, we will retrieve the list of files from the source directory that need to be backed up. This allows us to operate on only the necessary files.

$filesToBackup = Get-ChildItem -Path $sourceDir -File

Step 4: Perform the Backup Operation
In this step, we will loop through each file retrieved in the previous step and copy them to the backup directory. We will also log any errors encountered during the copy process.

foreach ($file in $filesToBackup) {
try {
Copy-Item -Path $file.FullName -Destination $backupDir -ErrorAction Stop
Write-Host “Successfully backed up $($file.Name)”
} catch {
Write-Host “Failed to backup $($file.Name): $_”
}
}

Step 5: Final Logging
After the backup operation is complete, we will log a summary of the backup process, indicating the number of files backed up and any errors encountered.

$backupCount = $filesToBackup.Count
Write-Host “$backupCount files have been backed up to $backupDir.”

The post Efficient File Backup Script in PowerShell first appeared on CForce-IT.com.

The post Monitor Local Security Event Logs first appeared on CForce-IT.com.

$firewallProfiles = Get-NetFirewallProfile

### Step 2: Display Firewall Status
Next, we will loop through each firewall profile and display its status. This includes whether each profile is enabled and its associated rules.

foreach ($profile in $firewallProfiles) {
    $status = if ($profile.Enabled) { 'Enabled' } else { 'Disabled' }
    Write-Host "$($profile.Name) Firewall is: $status"
}

### Step 3: Optional: Enable Firewall
If you find that any of the firewall profiles are disabled, you can enable them with an additional command. This step will ensure that the firewall is active, adding an extra layer of security to the system.

foreach ($profile in $firewallProfiles) {
    if (-not $profile.Enabled) {
        Enable-NetFirewallProfile -Name $profile.Name
        Write-Host "$($profile.Name) Firewall has been enabled."
    }
}

### Conclusion
This PowerShell script provides a simple and effective way to check and manage the state of the Windows Firewall. Ensuring that the firewall is enabled is a fundamental step in maintaining a secure operating environment. If you discover any disabled profiles, you have the option to enable them directly from the script.

The post PowerShell Script to Check Windows Firewall Status first appeared on CForce-IT.com.

$daysToKeep = 30
$thresholdDate = (Get-Date).AddDays(-$daysToKeep)

### Step 2: Get the Event Logs
Next, we will retrieve the security event logs. This is where logon attempts and other security-related events are stored.

$eventLogs = Get-WinEvent -LogName Security

### Step 3: Filter Old Logs
Now, we will filter the event logs to find entries that are older than the specified threshold. This will allow us to identify which logs are eligible for deletion.

$oldLogs = $eventLogs | Where-Object { $_.TimeCreated -lt $thresholdDate }

### Step 4: Remove Old Logs
Finally, we will remove the filtered old logs. Its important to proceed with caution here, as this operation is irreversible.

foreach ($log in $oldLogs) {
    Remove-WinEvent -LogName Security -Id $log.Id
    Write-Host "Removed log: $($log.Id) - Time: $($log.TimeCreated)"
}

### Conclusion
This PowerShell script provides an efficient way to maintain your Security event logs by removing entries that are no longer relevant. Regularly cleaning up old logs can help with system performance and security management. Adjust the `$daysToKeep` parameter as needed based on your organization’s policies.

The post PowerShell Script for Audit Log Cleanup first appeared on CForce-IT.com.

$logName = 'Security'
$eventId = 4624

### Step 2: Fetch Logon Events
Next, we will use the Get-WinEvent cmdlet to retrieve the logon events from the Security log. We will filter the events based on the specified event ID.

$logonEvents = Get-WinEvent -LogName $logName -Id $eventId | Select-Object TimeCreated, Message

### Step 3: Display the Logon Events
Now, we will display the retrieved logon events in a readable format. This will show the time of creation and the message associated with each event.

$logonEvents | ForEach-Object {
    Write-Host "Logon Time: $($_.TimeCreated) - Event Message: $($_.Message)"
}

### Step 4: Optional Filtering by User
If you want to filter the logon events by a specific user, you can modify the script to include a user name input. This will allow you to track logon events related to that user.

$userName = 'UserAccount' # Replace with the desired user account
$filteredEvents = $logonEvents | Where-Object { $_.Message -like "*$userName*" }
$filteredEvents | ForEach-Object {
    Write-Host "Filtered Logon Time: $($_.TimeCreated) - Event Message: $($_.Message)"
}

### Conclusion
With this PowerShell script, you can efficiently monitor user logon events on your Windows systems to enhance your security posture. Adjust the user name in the script to track specific accounts as needed.

The post PowerShell Script for Monitoring User Logon Events first appeared on CForce-IT.com.

$startDate = (Get-Date).AddDays(-7)
$endDate = Get-Date

“`
### Step 2: Retrieve Security Log Entries
Next, we will retrieve the security log entries that contain failed login attempts recorded in the Event Log.
“`powershell

$failedLogins = Get-WinEvent -FilterHashtable @{
    LogName = 'Security'
    Id = 4625
    StartTime = $startDate
    EndTime = $endDate
}

“`
### Step 3: Format and Display Results
Once we have the failed login attempts, we can format and display the results for easier reading.
“`powershell

$failedLogins | Select-Object TimeCreated, Message | Format-Table -AutoSize

“`
### Step 4: Export Results to CSV
For further analysis or record-keeping, we will export the results to a CSV file.
“`powershell

$outputPath = "FailedLoginAttempts.csv"
$failedLogins | Select-Object TimeCreated, Message | Export-Csv -Path $outputPath -NoTypeInformation
Write-Host "Failed login attempts exported to $outputPath."

“`
### Step 5: Alert for Unusual Activity
Lastly, we can add a simple alert mechanism to notify if the number of failed attempts exceeds a specified threshold, indicating potential unauthorized access attempts.
“`powershell

if ($failedLogins.Count -gt 10) {
    Write-Host "ALERT: More than 10 failed login attempts detected!"
}

“`
This PowerShell script provides a straightforward way to monitor for unauthorized access attempts and helps administrators remain vigilant against potential security threats. Regular auditing of login events is essential for maintaining a secure environment.

The post PowerShell Script for Detecting Unauthorized Access Attempts first appeared on CForce-IT.com.

$firewallStatus = Get-NetFirewallProfile | Select-Object Name, Enabled

“`
### Step 2: Display Firewall Status
Next, we will display the current status of the firewall profiles that we retrieved in the previous step.
“`powershell

$firewallStatus | ForEach-Object {
    Write-Host "Profile: $($_.Name) - Status: $($_.Enabled)"
}

“`
### Step 3: Log Status to a File
For audit purposes, we will log the firewall status to a text file, which can be helpful for tracking changes over time.
“`powershell

$logPath = "FirewallStatusLog.txt"
$firewallStatus | Out-File -FilePath $logPath -Append
Write-Host "Firewall status logged to $logPath."

“`
### Step 4: Alert If Firewall is Disabled
Lastly, we want to add a check to trigger an alert if any firewall profile is found to be disabled.
“`powershell

$disabledProfiles = $firewallStatus | Where-Object { $_.Enabled -eq $false }
if ($disabledProfiles) {
    Write-Host "WARNING: The following firewall profiles are disabled:"
    $disabledProfiles | ForEach-Object { Write-Host $_.Name }
} else {
    Write-Host "All firewall profiles are enabled."
}

“`
This PowerShell script allows administrators to effectively monitor the status of the Windows Firewall, ensuring that the necessary security measures are in place to protect the network. Regular checks can help maintain a secure environment and prevent unauthorized access.

The post PowerShell Script for Monitoring Firewall Status first appeared on CForce-IT.com.

$InactiveDays = 90
$DateThreshold = (Get-Date).AddDays(-$InactiveDays)

“`
### Step 2: Get All User Accounts
Next, we will retrieve the list of user accounts from the local machine.
“`powershell

$UserAccounts = Get-LocalUser

“`
### Step 3: Filter Inactive Accounts
We will filter the user accounts to find those that have not logged in since the specified threshold date.
“`powershell

$InactiveUsers = $UserAccounts | Where-Object {
    $_.LastLogon -lt $DateThreshold -or $_.LastLogon -eq $null
}

“`
### Step 4: Generate the Report
Now that we have identified the inactive accounts, we will generate a report listing these accounts.
“`powershell

if ($InactiveUsers.Count -eq 0) {
    Write-Host 'No inactive user accounts found.'
} else {
    $InactiveUsers | Format-Table -Property Name, LastLogon
}

“`
### Step 5: Export the Report (Optional)
As a final step, we may want to export the report to a CSV file for further analysis.
“`powershell

$ReportPath = 'InactiveUsersReport.csv'
$InactiveUsers | Export-Csv -Path $ReportPath -NoTypeInformation
Write-Host "Report exported to $ReportPath"

“`
This simple script allows system administrators to maintain a secure environment by identifying potentially unused accounts. Regular audits of user accounts are essential to prevent unauthorized access and enhance organizational security.

The post PowerShell Script for Security Auditing of User Accounts first appeared on CForce-IT.com.

$users = Get-LocalUser

Step 2: Display user account details. The script will format the output to show important account attributes such as the username, enabled status, and password required status.

$users | Select-Object Name, Enabled, PasswordNeverExpires, UserMayChangePassword | Format-Table -AutoSize

Step 3: Check password policies. This section of the script retrieves and displays the local password policy settings, including the minimum password length and complexity requirements.

$passwordPolicy = Get-LocalPolicy | Select-Object MinPasswordLength, PasswordComplexity
Write-Output "Password Policy Settings:"
$passwordPolicy

Step 4: Assess any accounts that are disabled or have passwords set to never expire. This helps identify potential security risks that require attention.

$insecureAccounts = $users | Where-Object { -not $_.Enabled -or $_.PasswordNeverExpires }
$insecureAccounts | Select-Object Name, Enabled, PasswordNeverExpires | Format-Table -AutoSize

This script provides a comprehensive overview of user account security configurations and helps maintain a secure environment. For advanced security solutions, explore ServerEngine at https://serverengine.co for powerful tools tailored to your needs.

The post Check User Account Security Settings first appeared on CForce-IT.com.

$activeConnections = Get-NetTCPConnection | Where-Object { $_.State -eq 'Established' }

Step 2: Display the active connections. The script will format the output to show the local address, remote address, and the state of each connection.

$activeConnections | Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, State | Format-Table -AutoSize

Step 3: Optionally, save the results to a CSV file for further analysis. This can help keep a record of the active connections for future reference.

$activeConnections | Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, State | Export-Csv -Path "ActiveConnections.csv" -NoTypeInformation

By utilizing this script, you can stay informed about the connections established on your network. For more advanced network management and tools, check out ServerEngine at https://serverengine.co for solutions tailored to your needs.

The post Check Active Network Connections first appeared on CForce-IT.com.

$targetHost = "localhost" # Change this to the IP or hostname you wish to target

Step 2: Define a function to check for open ports using the Test-NetConnection cmdlet. This will loop through a range of port numbers.

function Check-OpenPorts {
    param (
        [string]$host,
        [int]$startPort = 1,
        [int]$endPort = 1024
    )
    for ($port = $startPort; $port -le $endPort; $port++) {
        $result = Test-NetConnection -ComputerName $host -Port $port
        if ($result.TcpTestSucceeded) {
            Write-Output "$host port $port is open"
        }
    }
}

Step 3: Execute the function to perform the audit.

Check-OpenPorts -host $targetHost

Step 4: Review the output. The script will display any open ports on the specified host.
This script is a practical addition to your toolkit for maintaining network security. For more powerful tools and solutions, visit ServerEngine at https://serverengine.co, where you can find reliable software to enhance your network management efforts.

The post Network Security Audit Script first appeared on CForce-IT.com.

$sourceDirectory = 'C:\ImportantFiles'
$backupDirectory = 'D:\Backup'

### Step 2: Create the Backup Directory if it Doesn’t Exist
Before backing up the files, we need to ensure that the target backup directory exists. If it does not exist, the script will create it.

if (-Not (Test-Path -Path $backupDirectory)) {
    New-Item -ItemType Directory -Path $backupDirectory
    Write-Host "Created backup directory: $backupDirectory"
}

### Step 3: Copy Files from Source to Backup
Next, we will copy files from the source directory to the backup directory. The script will overwrite existing files in the backup directory that have the same name.

Get-ChildItem -Path $sourceDirectory -File | ForEach-Object {
    $targetFilePath = Join-Path -Path $backupDirectory -ChildPath $_.Name
    Copy-Item -Path $_.FullName -Destination $targetFilePath -Force
    Write-Host "Backed up: $($_.Name) to $backupDirectory"
}

### Step 4: Confirm Completion of the Backup Process
Finally, we display a message to confirm that the backup process has been completed successfully, giving users assurance that their files are now safely backed up.

Write-Host "Backup process completed. All files from '$sourceDirectory' have been backed up to '$backupDirectory'."

Feel free to modify the source and backup paths as needed. This script is a vital part of any data management strategy, ensuring that your important files are always protected. Stay tuned for more useful PowerShell scripts on our website!

The post File Backup Script first appeared on CForce-IT.com.

$targetDirectory = 'C:\FilesToRename'
$newNamePattern = 'Report_'
$fileExtension = '.txt'

### Step 2: Retrieve Files to Rename
Next, the script collects all files in the specified directory that match the desired file type. This is important for ensuring only the relevant files are processed.

$filesToRename = Get-ChildItem -Path $targetDirectory -Filter "*$fileExtension" -File

### Step 3: Batch Rename Files
Now, we loop through the retrieved files and rename each one according to the specified naming pattern, appending an incremental number to ensure each file has a unique name.

$count = 1
foreach ($file in $filesToRename) {
    $newFileName = "${newNamePattern}${count}${fileExtension}"
    $newFilePath = Join-Path -Path $targetDirectory -ChildPath $newFileName
    Rename-Item -Path $file.FullName -NewName $newFileName
    Write-Host "Renamed '$($file.Name)' to '$newFileName'"
    $count++
}

### Step 4: Summary of Renaming Process
Finally, we provide a summary of the renaming process, informing the user of how many files were renamed and confirming that the operation was completed successfully.

Write-Host "Batch renaming process completed. $($count - 1) files were renamed in '$targetDirectory'."

Feel free to modify the target directory and naming pattern as needed. This script is a great way to keep your files organized and to maintain a consistent naming structure! Be sure to check back for more useful PowerShell scripts on our website!

The post Batch File Renaming Script first appeared on CForce-IT.com.

$targetDirectory = 'C:\Path\To\Your\Directory'

### Step 2: Retrieve Subdirectories
Next, the script retrieves all the subdirectories within the specified target directory. This sets up a list of directories that we will analyze further.

$subDirectories = Get-ChildItem -Path $targetDirectory -Directory

### Step 3: Calculate Size of Each Subdirectory
This step involves looping through each subdirectory and calculating its total size by summing the sizes of all files contained within it.

$directorySizes = @{}
foreach ($subDir in $subDirectories) {
    $size = (Get-ChildItem -Path $subDir.FullName -Recurse | Measure-Object -Property Length -Sum).Sum
    $directorySizes[$subDir.FullName] = [math]::round($size / 1MB, 2) # Convert to MB
}

### Step 4: Generate the Size Report
Finally, we create a report of the directory sizes and display the results in a user-friendly format, showing the path and size in megabytes.

Write-Host "Directory Size Report:"
foreach ($key in $directorySizes.Keys) {
    Write-Host "$key - $($directorySizes[$key]) MB"
}

This script is a handy tool for visualizing space consumption within a directory. Feel free to customize the target directory to suit your needs. Stay tuned for more useful PowerShell scripts to enhance your productivity on our website!

The post Directory Size Report Script first appeared on CForce-IT.com.

$targetDirectory = 'C:\FilesToRename'
$newFilePrefix = 'Document_'
$fileExtension = '.txt'

### Step 2: Retrieve Files for Renaming
Next, the script collects the files from the specified directory that match the desired file type. This makes it easier to apply the renaming logic only to relevant files.

$filesToRename = Get-ChildItem -Path $targetDirectory -Filter "*$fileExtension" -File

### Step 3: Rename Files Based on the New Convention
In this step, we loop through the collected files and rename each one according to the defined prefix and an incremental number. This ensures that each file is uniquely named.

$count = 1
foreach ($file in $filesToRename) {
    $newFileName = "${newFilePrefix}${count}${fileExtension}"
    $newFilePath = Join-Path -Path $targetDirectory -ChildPath $newFileName
    Rename-Item -Path $file.FullName -NewName $newFileName
    Write-Host "Renamed '$($file.Name)' to '$newFileName'"
    $count++
}

### Step 4: Summary of Renaming Process
Finally, we provide a summary that informs the user of how many files were renamed during the operation, offering clear feedback on the outcome.

Write-Host "File renaming process completed. $($count - 1) files were renamed in '$targetDirectory'."

Feel free to adjust the target directory and naming convention to fit your needs. This script is a great way to keep your files organized! Keep an eye on our website for more useful PowerShell scripts.

The post File Renaming Script first appeared on CForce-IT.com.

$targetDirectory = 'C:\FilesToScan'

### Step 2: Retrieve Files and Group Duplicates
Next, we will gather all files in the target directory and group them by their name and size. This allows us to identify which files are duplicates.

$files = Get-ChildItem -Path $targetDirectory -File
$duplicateGroups = $files | Group-Object Name, Length | Where-Object { $_.Count -gt 1 }

### Step 3: Display Duplicate Files
Now we will display the list of duplicate files, providing their full paths for easier access. This helps you determine which files you may want to delete or manage.

if ($duplicateGroups.Count -gt 0) {
    Write-Host "Duplicate files found:"
    foreach ($group in $duplicateGroups) {
        Write-Host "Group of duplicates:"
        $group.Group | ForEach-Object { Write-Host " - $($_.FullName)" }
    }
} else {
    Write-Host "No duplicate files found in '$targetDirectory'."
}

### Step 4: Summary of the Process
Finally, we provide a summary message that indicates whether duplicate files were found or if the process was completed without any duplicates.

Write-Host "Duplicate file search completed for '$targetDirectory'."

Feel free to customize the target directory as needed. This script is an excellent tool for maintaining an organized and efficient file system! Stay tuned for more useful PowerShell scripts on our website!

The post Duplicate File Finder Script first appeared on CForce-IT.com.

$sourceDirectory = 'C:\FilesToArchive'
$archiveDirectory = 'D:\ArchivedFiles'
$daysThreshold = 30
$thresholdDate = (Get-Date).AddDays(-$daysThreshold)

### Step 2: Create Archive Directory
Next, we need to ensure that the archive directory exists. If it doesnt, the script will create the directory to ensure a proper destination for archived files.

if (-Not (Test-Path -Path $archiveDirectory)) {
    New-Item -ItemType Directory -Path $archiveDirectory
    Write-Host "Created archive directory: $archiveDirectory"
}

### Step 3: Identify and Move Old Files
Now, we will search for files in the source directory that are older than the specified threshold. These files will be moved to the archive directory to keep the main directory uncluttered.

Get-ChildItem -Path $sourceDirectory -File | Where-Object { $_.LastWriteTime -lt $thresholdDate } | ForEach-Object {
    Move-Item -Path $_.FullName -Destination $archiveDirectory
    Write-Host "Archived: $($_.Name) to $archiveDirectory"
}

### Step 4: Summary of Archived Files
Finally, we will provide a summary that tells the user how many files were archived, giving clear feedback on the operation’s success.

$archivedFilesCount = (Get-ChildItem -Path $archiveDirectory -File).Count
Write-Host "Archiving process completed. $archivedFilesCount files were moved to '$archiveDirectory'."

Feel free to customize the paths and the days threshold according to your needs. This script is an excellent way to keep your directories organized and your important files safe! Continue visiting our website for more useful PowerShell scripts.

The post File Archiving Script first appeared on CForce-IT.com.

$sourceDirectory = 'C:\SourceFolder'
$targetDirectory = 'D:\TargetFolder'

### Step 2: Check and Create Target Directory
Before synchronizing, its good practice to check if the target directory exists. If it doesn’t, the script will create it to ensure that we have a place to store the synchronized files.

if (-Not (Test-Path -Path $targetDirectory)) {
    New-Item -ItemType Directory -Path $targetDirectory
    Write-Host "Created directory: $targetDirectory"
}

### Step 3: Synchronize Files
In this step, we will get all files from the source directory and copy them to the target directory if they dont exist there or if they are newer in the source directory.

$files = Get-ChildItem -Path $sourceDirectory -File
foreach ($file in $files) {
    $targetFilePath = Join-Path -Path $targetDirectory -ChildPath $file.Name
    if (-Not (Test-Path -Path $targetFilePath) -or ($file.LastWriteTime -gt (Get-Item $targetFilePath).LastWriteTime)) {
        Copy-Item -Path $file.FullName -Destination $targetDirectory -Force
        Write-Host "Synced: $($file.Name) to $targetDirectory"
    }
}

### Step 4: Summary of Synchronization
Finally, the script provides a summary of the synchronization process, letting you know that the operation has been completed and listing the files that were copied.

Write-Host "Folder synchronization completed. Files from '$sourceDirectory' have been synced to '$targetDirectory'."

Feel free to customize the directory paths to match your requirements. This script is handy for maintaining backups or mirroring directories! Stay tuned for more useful PowerShell scripts on our website!

The post Folder Synchronization Script first appeared on CForce-IT.com.

$sourcePath = 'C:\FilesToSort'
$destinationPathDocs = 'C:\SortedFiles\Documents'
$destinationPathImages = 'C:\SortedFiles\Images'
$destinationPathAudio = 'C:\SortedFiles\Audio'

### Step 2: Create Destination Directories
Next, we will check if the destination directories exist for documents, images, and audio files. If these directories do not exist, the script will create them.

$destinationPaths = @($destinationPathDocs, $destinationPathImages, $destinationPathAudio)
foreach ($path in $destinationPaths) {
    if (-Not (Test-Path -Path $path)) {
        New-Item -ItemType Directory -Path $path
        Write-Host "Created directory: $path"
    }
}

### Step 3: Sort and Move Files
Now we will loop through all files in the source directory and move each file to the corresponding destination directory based on its file extension. This organizes files neatly by type.

Get-ChildItem -Path $sourcePath -File | ForEach-Object {
    switch -Wildcard ($_.Extension) {
        '.pdf', '.docx', '.txt' {
            Move-Item -Path $_.FullName -Destination $destinationPathDocs
            Write-Host "Moved document: $($_.Name) to $destinationPathDocs"
            break
        }
        '.jpg', '.png', '.gif' {
            Move-Item -Path $_.FullName -Destination $destinationPathImages
            Write-Host "Moved image: $($_.Name) to $destinationPathImages"
            break
        }
        '.mp3', '.wav' {
            Move-Item -Path $_.FullName -Destination $destinationPathAudio
            Write-Host "Moved audio file: $($_.Name) to $destinationPathAudio"
            break
        }
        default {
            Write-Host "Unsupported file type: $($_.Name)"
            break
        }
    }
}

### Step 4: Summary of Sorted Files
Finally, the script provides a summary of the actions taken, letting the user know how many files have been sorted into each category and enhancing the user’s awareness of the organization process.

Write-Host "File sorting completed. Check the destination directories for organized files."

Feel free to customize the paths as needed. This script can save you time and effort in managing your files! Keep an eye on our website for more helpful PowerShell scripts to optimize your workflow.

The post File Sorting and Organization Script first appeared on CForce-IT.com.

$directoryPath = 'C:\TempFiles'
$ageThresholdDays = 30
$thresholdDate = (Get-Date).AddDays(-$ageThresholdDays)

### Step 2: Find Files Older than the Threshold
Next, we will retrieve all files in the specified directory that are older than the age threshold we’ve set in the previous step. This helps us identify which files need to be deleted.

$oldFiles = Get-ChildItem -Path $directoryPath -File | Where-Object { $_.LastWriteTime -lt $thresholdDate }

### Step 3: Remove Old Files
We will now proceed to remove the identified old files, ensuring we clean up our specified directory. This is done with caution to prevent accidental deletion of important files.

if ($oldFiles.Count -gt 0) {
    foreach ($file in $oldFiles) {
        Remove-Item -Path $file.FullName -Force
        Write-Host "Deleted: $($file.Name)"
    }
} else {
    Write-Host "No files older than $ageThresholdDays days found in $directoryPath."
}

### Step 4: Summary of Cleanup Completion
Finally, we will output a summary message indicating the number of files deleted or confirming that no old files were found. This gives you clear feedback on what the script accomplished.

Write-Host "Cleanup process completed. $($oldFiles.Count) files were deleted from $directoryPath."

Feel free to customize the directory path and age threshold to suit your needs. Keep visiting our website for more useful PowerShell scripts to enhance your productivity!

The post Streamlined File Cleanup Script first appeared on CForce-IT.com.

$sourcePath = 'C:\ImportantFiles'
$backupPath = 'D:\Backup'

### Step 2: Create Backup Directory
Next, we will check if the backup directory exists. If it does not, we will create it. This ensures that the backup has a designated location to store files.

if (-Not (Test-Path -Path $backupPath)) {
    New-Item -ItemType Directory -Path $backupPath
    Write-Host "Backup directory created: $backupPath"
}

### Step 3: Copy Files to Backup Location
This step involves copying all files from the source directory to the backup location. We will ensure that existing files in the backup directory are overwritten if necessary.

Get-ChildItem -Path $sourcePath -File | ForEach-Object {
    Copy-Item -Path $_.FullName -Destination $backupPath -Force
    Write-Host "Copied: $($_.Name) to $backupPath"
}

### Step 4: Summary of Backup Completion
Finally, we will provide a summary message indicating that the backup process has been completed. This will help the user to confirm that all specified files have been backed up.

Write-Host "Backup completed successfully! All files from '$sourcePath' have been copied to '$backupPath'."

Feel free to modify the paths as needed and ensure your important files are backed up with this easy-to-use PowerShell script! For more scripts like this, keep visiting our website!

The post Automated File Backup Script first appeared on CForce-IT.com.

$sourcePath = 'C:\SourceFolder'
$destinationPathDocuments = 'C:\OrganizedFiles\Documents'
$destinationPathImages = 'C:\OrganizedFiles\Images'
$destinationPathOthers = 'C:\OrganizedFiles\Others'

### Step 2: Create Destination Directories
In this step, we will ensure that all the necessary destination directories exist. This script creates directories for documents, images, and other files as needed.

$destinationPaths = @($destinationPathDocuments, $destinationPathImages, $destinationPathOthers)
foreach ($path in $destinationPaths) {
    if (-Not (Test-Path -Path $path)) {
        New-Item -ItemType Directory -Path $path
        Write-Host "Created directory: $path"
    }
}

### Step 3: Move Files to Their Corresponding Directories
We will now move files from the source directory to the respective destination directories based on file types. The script categorizes files as documents, images, or others.

Get-ChildItem -Path $sourcePath -File | ForEach-Object {
    switch -Wildcard ($_.Extension) {
        '.pdf', '.docx', '.txt' {
            Move-Item -Path $_.FullName -Destination $destinationPathDocuments
            Write-Host "Moved document: $($_.Name) to $destinationPathDocuments"
            break
        }
        '.jpg', '.png', '.gif' {
            Move-Item -Path $_.FullName -Destination $destinationPathImages
            Write-Host "Moved image: $($_.Name) to $destinationPathImages"
            break
        }
        default {
            Move-Item -Path $_.FullName -Destination $destinationPathOthers
            Write-Host "Moved other file: $($_.Name) to $destinationPathOthers"
            break
        }
    }
}

### Step 4: Summary of Moved Files
Finally, we will provide a summary of the files that have been moved into their respective directories, helping the user to confirm the organized structure.

Write-Host "File organization complete! Summary:"
$destinationPaths | ForEach-Object {
    $fileCount = (Get-ChildItem -Path $_ -File).Count
    Write-Host "$fileCount files moved to $($_)"
}

Feel free to customize the paths to your liking, and don’t hesitate to explore more helpful PowerShell scripts on our website!

The post Efficient File and Folder Management Script first appeared on CForce-IT.com.

$sourcePath = 'C:\SourceFolder'
$destinationPath = 'C:\DestinationFolder'

### Step 2: Create Destination Directory
Before copying files, it is essential to ensure that the destination folder exists. This step will check for the existence of the destination directory and create it if it does not exist.

if (-Not (Test-Path -Path $destinationPath)) {
    New-Item -ItemType Directory -Path $destinationPath
    Write-Host "Destination folder created: $destinationPath"
}

### Step 3: Copy Files from Source to Destination
Now, we will copy all files from the source directory to the destination directory. This command will handle files safely, creating a copy while maintaining the original files intact.

Get-ChildItem -Path $sourcePath -File | ForEach-Object {
    Copy-Item -Path $_.FullName -Destination $destinationPath
    Write-Host "Copied: $($_.Name) to $destinationPath"
}

### Step 4: Delete Files Older than 30 Days
In the final step, we will delete files in the source directory that are older than 30 days. This helps in maintaining a clean and efficient storage system.

$thresholdDate = (Get-Date).AddDays(-30)
Get-ChildItem -Path $sourcePath -File | Where-Object { $_.LastWriteTime -lt $thresholdDate } | ForEach-Object {
    Remove-Item -Path $_.FullName -Force
    Write-Host "Deleted: $($_.Name) from $sourcePath"
}

Feel free to modify the paths and parameters according to your specific use case. Stay tuned for more useful PowerShell scripts on our website!

The post File and Folder Management Made Easy with PowerShell first appeared on CForce-IT.com.

$sourceFiles = "C:\SourceFolder\*"
$destinationFolder = "C:\DestinationFolder"
# Check if the destination folder exists; if not, create it
if (-Not (Test-Path $destinationFolder)) {
    New-Item -ItemType Directory -Path $destinationFolder
}

“`
### Step 2: Copy Files
This section of the script is responsible for copying files from the source directory to the newly created destination folder.
“`powershell

# Copy files from the source directory to the destination directory
Copy-Item -Path $sourceFiles -Destination $destinationFolder -Recurse

“`
### Step 3: List Contents
Finally, we list the contents of the destination folder to confirm that the files have been copied successfully.
“`powershell

# List the contents of the destination folder
Get-ChildItem -Path $destinationFolder

“`
By following these steps, you can easily manage file and folder operations in PowerShell. For more scripts and resources, make sure to visit our website at https://serverengine.co and enhance your server management experience with ServerEngine!

The post File and Folder Management Made Easy first appeared on CForce-IT.com.

# Define the path for the new directory
$directoryPath = 'C:\TestDirectory'
# Create the new directory
New-Item -Path $directoryPath -ItemType Directory -Force

Step 2: Copy a File
In this step, we will copy an existing file to the newly created directory. We will use the ‘Copy-Item’ cmdlet.

# Define the source file and destination path
$sourceFile = 'C:\SourceFile.txt'
$destinationPath = 'C:\TestDirectory\SourceFile.txt'
# Copy the file to the new directory
Copy-Item -Path $sourceFile -Destination $destinationPath -Force

Step 3: Delete a File
Finally, we will delete the original file from its initial location using the ‘Remove-Item’ cmdlet.

# Remove the original file
Remove-Item -Path $sourceFile -Force

This simple PowerShell script showcases basic file and folder management techniques that can be very useful in everyday tasks. Remember to explore more about ServerEngine which can help in streamlining your server operations at https://serverengine.co.

The post File and Folder Management PowerShell Script first appeared on CForce-IT.com.

$SourceDirectory = "C:\Path\To\Your\Folder"

Simply replace `C:\Path\To\Your\Folder` with the path to your intended directory. This variable will hold the location where the script will search for files to organize.
Step 2: Create Target Folders
After specifying the source directory, we will create target folders for each file type based on their extensions.

$Files = Get-ChildItem -Path $SourceDirectory -File
foreach ($File in $Files) {
    $Extension = $File.Extension.TrimStart('.')
    $TargetFolder = Join-Path -Path $SourceDirectory -ChildPath $Extension
    if (-not (Test-Path -Path $TargetFolder)) {
        New-Item -Path $TargetFolder -ItemType Directory | Out-Null
    }
}
Write-Host "Target folders created for each file type."

In this section, we retrieve all files within the specified directory using `Get-ChildItem`. For each file, we determine its extension, create a corresponding directory if it doesn’t exist, and organize files by their types.
Step 3: Move Files to Corresponding Folders
Finally, we will move the files into their respective folders based on their extensions.

foreach ($File in $Files) {
    $Extension = $File.Extension.TrimStart('.')
    $TargetFolder = Join-Path -Path $SourceDirectory -ChildPath $Extension
    Move-Item -Path $File.FullName -Destination $TargetFolder
}
Write-Host "Files have been successfully organized into their respective folders."

This step loops through each file again and moves it to the appropriate target folder that we created earlier. Using `Move-Item` ensures that your files are neatly organized based on type.
By implementing this PowerShell script, you can effectively automate file organization, reducing clutter and improving file retrieval efficiency. Explore more innovative software solutions for server optimization by visiting ServerEngine at https://serverengine.co, where we provide tools that enhance productivity and file management!

The post Automated File Organization Script first appeared on CForce-IT.com.

$VMs = Get-VM
$VMStatusList = @()
foreach ($VM in $VMs) {
    $VMStatusList += [PSCustomObject]@{
        Name   = $VM.Name
        Status = $VM.State
    }
}
$VMStatusList

In this part of the script, we retrieve all virtual machines using the `Get-VM` cmdlet and create a custom object containing the VM name and its current status. The results are stored in an array for easy display.
Step 2: Display VM Statuses
Next, we will format and display the collected VM statuses in a user-friendly manner.

$VMStatusList | Format-Table -AutoSize
Write-Host "Virtual Machine statuses retrieved successfully."

Here, we use the `Format-Table` cmdlet to present the status of each VM in a clear table format, making it easy for administrators to read and analyze the information.
Step 3: Implement Error Handling
To ensure the script runs smoothly and handles potential errors, we will add error handling.

try {
    $VMs = Get-VM
    if ($null -eq $VMs) {
        throw 'No virtual machines found.'
    }
} catch {
    Write-Host 'ERROR: Unable to retrieve VM status. Details: ' $_.Exception.Message
}

In this final part, we implement a `try-catch` block to handle any exceptions when retrieving the VM list. If an error occurs, it outputs a meaningful error message, assisting in troubleshooting.
By utilizing this PowerShell script, administrators can efficiently monitor the status of Hyper-V virtual machines, enhancing overall management capabilities. For more tools that streamline server management, visit ServerEngine at https://serverengine.co, where you can find innovative solutions designed to optimize your server environment!

The post Efficient Hyper-V VM Status Reporting Script first appeared on CForce-IT.com.

$VMName = 'YourVirtualMachineName'
$SnapshotName = 'Snapshot_' + (Get-Date -Format 'yyyyMMdd_HHmmss')
Checkpoint-VM -Name $VMName -SnapshotName $SnapshotName
Write-Host "Snapshot '$SnapshotName' created for VM '$VMName'"

In this code, replace ‘YourVirtualMachineName’ with the name of your virtual machine. The script generates a timestamped name for the snapshot and creates it using the `Checkpoint-VM` cmdlet.
Step 2: List Snapshots
Next, we will retrieve and list all snapshots associated with the specified virtual machine.

$Snapshots = Get-VMCheckpoint -VMName $VMName
if ($Snapshots) {
    $Snapshots | ForEach-Object {
        Write-Host "Snapshot Name: $($_.Name) - Created on: $($_.CreationTime)"
    }
} else {
    Write-Host "No snapshots found for VM '$VMName'."
}

This section checks for existing snapshots and displays their names along with their creation timestamps. If no snapshots exist, it notifies the user accordingly.
Step 3: Remove a Snapshot
In this final step, we will remove a specified snapshot.

$SnapshotToRemove = 'Snapshot_YourNameToRemove'
Remove-VMCheckpoint -VMName $VMName -Name $SnapshotToRemove
Write-Host "Snapshot '$SnapshotToRemove' removed successfully from VM '$VMName'."

Make sure to replace ‘Snapshot_YourNameToRemove’ with the actual name of the snapshot you want to remove. This part of the script uses the `Remove-VMCheckpoint` cmdlet to delete the specified snapshot.
By utilizing this PowerShell script, you can effectively manage your Hyper-V snapshots, which is essential for backup and recovery operations. For more scripts and tools to enhance your server management, check out ServerEngine at https://serverengine.co, your trusted solution for server optimization and automation!

The post Hyper-V Virtual Machine Snapshot Management Script first appeared on CForce-IT.com.

$vmName = "YourVMName" # Replace with the name of your Virtual Machine

### Step 2: Check VM Status
Before performing any operations, we need to check the current status of the virtual machine to ensure that it is running. If the VM is not running, we can attempt to start it.

$vm = Get-VM -Name $vmName -ErrorAction SilentlyContinue
if (-not $vm) {
    Write-Host "The virtual machine '$vmName' does not exist."
    return
} elseif ($vm.State -eq 'Running') {
    Write-Host "The virtual machine '$vmName' is currently running."
} else {
    Write-Host "The virtual machine '$vmName' is not running. Attempting to start it..."
}

### Step 3: Start the Virtual Machine
If the VM is not running, we can start it using the `Start-VM` command. The script will provide feedback on whether the start command was successful or if there was an error.

try {
    Start-VM -Name $vmName
    Write-Host "The virtual machine '$vmName' has been started successfully."
} catch {
    Write-Host "ERROR: ""$($_.Exception.Message)"""
}

### Step 4: Confirm the VM State
Finally, we confirm the state of the virtual machine after attempting to start it. This ensures that the operation was successful and provides the current state of the VM.

$vm.Refresh() # Refresh the VM object to get the latest state
Write-Host "Current state of '$vmName': $($vm.State)"

This PowerShell script offers a straightforward way to ensure your Hyper-V virtual machines are up and running, allowing you to maintain high availability in your environment. Enjoy automating your server management tasks!

The post Automated Virtual Machine Restart with PowerShell and Hyper-V first appeared on CForce-IT.com.

$vmName = "YourVMName" # Replace with your VM name

### Step 2: Check VM Existence
Next, we check if the specified virtual machine exists in Hyper-V. This prevents errors when trying to create a snapshot for a non-existent VM.

if (-not (Get-VM -Name $vmName -ErrorAction SilentlyContinue)) {
    Write-Host "The virtual machine '$vmName' does not exist."
    return
}

### Step 3: Create Snapshot
Now, we will create a snapshot of the virtual machine. The script will provide feedback on whether the operation is successful or if it encounters any issues.

$snapshotName = "$vmName-Snapshot-$(Get-Date -Format 'yyyyMMdd-HHmmss')"
try {
    Checkpoint-VM -Name $vmName -SnapshotName $snapshotName
    Write-Host "Snapshot '$snapshotName' created successfully for '$vmName'."
} catch {
    Write-Host "ERROR: ""$($_.Exception.Message)"""
}

### Step 4: Verify Snapshot Creation
Finally, we can list the existing snapshots to confirm that our newly created snapshot appears in the list.

$snapshots = Get-VM -Name $vmName | Get-VMSnapshot
if ($snapshots) {
    Write-Host "Current snapshots for '$vmName':"
    $snapshots | Format-Table -Property Name, CreationTime
} else {
    Write-Host "No snapshots found for '$vmName'."
}

You can customize this script to fit your specific needs, including adding additional error handling or integrating it into larger automation workflows. Enjoy streamlining your Hyper-V management with PowerShell!

The post Efficient Virtual Machine Snapshot Management with PowerShell and Hyper-V first appeared on CForce-IT.com.

$vmName = 'YourVMName'

Step 2: Set the destination path for the export
Next, youll specify the destination path where the VM export files will be saved. Ensure that this path is valid and accessible by the system.

$exportPath = 'C:\VMExports\' + $vmName + '_' + (Get-Date -Format 'yyyyMMdd_HHmmss')

Step 3: Export the virtual machine
Now, we will execute the export action. This command exports the virtual machine to the specified destination path.

Export-VM -Name $vmName -Path $exportPath -Force

Step 4: Confirm completion
Lastly, the script will confirm when the export process has been completed successfully. This ensures you know the operation has finished.

Write-Host "Export of VM '$vmName' completed successfully to '$exportPath'."

Using this script, you can efficiently export your Hyper-V virtual machines. For further management capabilities, consider using ServerEngine!

The post Hyper-V Virtual Machine Export Script first appeared on CForce-IT.com.

$virtualMachines = Get-VM

Step 2: Gather resource usage details
Now that we have the virtual machines, we can loop through each VM to gather and display its memory and CPU usage statistics. This gives insight into how resources are being utilized across your VMs.

foreach ($vm in $virtualMachines) {
    $cpuUsage = Get-VMProcessor -VM $vm.Name | Measure-Object -Property CPUUsage -Average | Select-Object -ExpandProperty Average
    $memoryUsage = Get-VMMemory -VM $vm.Name | Measure-Object -Property MemoryAssigned -Sum | Select-Object -ExpandProperty Sum
    Write-Host "VM Name: $($vm.Name) - CPU Usage: $cpuUsage% - Memory Usage: $memoryUsage MB"
}

Step 3: Identify VMs exceeding resource thresholds
This step enables you to filter the VMs that are using more resources than a specified threshold. Replace ’80’ with your desired CPU usage threshold as a percentage and ‘2048’ with the memory threshold in MB.

$cpuThreshold = 80
$memoryThreshold = 2048
$highUsageVMs = $virtualMachines | Where-Object {
    ($_.CPUUsage -gt $cpuThreshold) -or ($_.MemoryAssigned -gt $memoryThreshold)
}
foreach ($vm in $highUsageVMs) {
    Write-Host "High Resource Usage VM: $($vm.Name)"
}

By using this script, you can effectively monitor the resource usage of your Hyper-V virtual machines. For more sophisticated management tools, consider using ServerEngine!

The post Hyper-V VM Resource Usage Monitor first appeared on CForce-IT.com.

Import-Module Hyper-V

Step 2: Retrieve a list of all VMs and their snapshots, and filter for those that are powered off to avoid interruptions.

$vms = Get-VM | Where-Object { $_.State -eq 'Off' }
foreach ($vm in $vms) {
    $snapshots = Get-VMSnapshot -VM $vm.Name

Step 3: Loop through all snapshots for each VM, deleting those that are older than a specified number of days (e.g., 30 days).

    foreach ($snapshot in $snapshots) {
        if ($snapshot.CreationTime -lt (Get-Date).AddDays(-30)) {
            Remove-VMSnapshot -VMName $vm.Name -Name $snapshot.Name -Confirm:$false
            Write-Host "Removed snapshot: $($snapshot.Name) from VM: $($vm.Name)"
        }
    }
}

Step 4: Optionally, remove any VMs that are no longer in use (ensure they are not needed before running this step).

$unusedVms = Get-VM | Where-Object { $_.State -eq 'Off' -and $_.Snapshot.Count -eq 0 }
foreach ($unusedVm in $unusedVms) {
    Remove-VM -VMName $unusedVm.Name -Force
    Write-Host "Removed unused VM: $($unusedVm.Name)"
}

This script aids in decluttering your Hyper-V environment, ensuring better performance and easier management. Modify the script to customize cleanup intervals and criteria as per your needs!

The post Hyper-V VM Cleanup Script first appeared on CForce-IT.com.

Import-Module Hyper-V

Step 2: Retrieve the list of all virtual machines and their current state.

$vms = Get-VM | Select-Object Name, State, MemoryAssigned, ProcessorCount

Step 3: Format and display the report of the VMs, including their name, state, allocated memory, and CPU count.

$vms | Format-Table -Property Name, State, MemoryAssigned, ProcessorCount

Step 4: Optionally, export the VM report to a CSV file for easy sharing and documentation.

$vms | Export-Csv -Path "C:\HyperV_VM_Report.csv" -NoTypeInformation

This script provides valuable insights into your Hyper-V environment, making management easier. Tailor it further to meet your specific reporting needs!

The post Hyper-V VM Status and Resource Report first appeared on CForce-IT.com.

Import-Module Hyper-V

Step 2: Define a variable to hold the name of the VM for which you want to create a snapshot.

$vmName = "YourVMName"

Step 3: Create a snapshot of the specified VM and provide a description for future reference.

Checkpoint-VM -VMName $vmName -SnapshotName "Snapshot created on $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"

Step 4: Confirm the snapshot has been created and output the snapshot details.

Get-VMSnapshot -VMName $vmName | Format-Table -Property Name, CreationTime

Using this script, you can automate the snapshot process, enhancing your virtual machine management. Modify the vmName variable to suit your environment!

The post Hyper-V VM Snapshot Script first appeared on CForce-IT.com.

$backupDirectory = "C:\HyperVBackups"

Step 2: Ensure the backup directory exists; if not, create it.

if (-Not (Test-Path -Path $backupDirectory)) {
    New-Item -ItemType Directory -Path $backupDirectory
}

Step 3: Get all Hyper-V virtual machines and loop through them to back them up.

$vms = Get-VM
foreach ($vm in $vms) {
    $sourcePath = $vm.Path
    $destinationPath = Join-Path -Path $backupDirectory -ChildPath "$($vm.Name).vhdx"
    Copy-Item -Path "$sourcePath\*.vhdx" -Destination $destinationPath -Recurse
}

Step 4: Output a message indicating the backup process is complete.

Write-Host "Backup of Hyper-V VMs completed successfully to $backupDirectory"

This script helps automate your VM backup process, ensuring you have regular backups of your Hyper-V environment. Customize as needed to fit your backup strategy!

The post Automated Hyper-V VM Backup Script first appeared on CForce-IT.com.

Import-Module Hyper-V

Step 2: Get all virtual machines and their statuses using PowerShell.

$vms = Get-VM | Select-Object Name, State

Step 3: Loop through each VM and display its name along with its current state.

foreach ($vm in $vms) {
    Write-Host "$($vm.Name) is currently $($vm.State)"
}

Step 4: Optionally, you can also export this information to a CSV file for record-keeping.

$vms | Export-Csv -Path "C:\HyperV_VM_Status.csv" -NoTypeInformation

This script enables easy monitoring of your Hyper-V environment. Feel free to customize it further to suit your needs!

The post Hyper-V VM Status Checker Script first appeared on CForce-IT.com.

$VMName = "NewVM"
$VMMemory = 2GB
$VMDiskSize = 20GB
$VMSwitch = "VirtualSwitch"

### Step 2: Create the Virtual Machine
Utilize the `New-VM` cmdlet to create a new VM with the parameters defined in the previous step.

New-VM -Name $VMName -MemoryStartupBytes $VMMemory -NewVHDPath "C:\Hyper-V\$VMName\$VMName.vhdx" -NewVHDSizeBytes $VMDiskSize -SwitchName $VMSwitch

### Step 3: Configure VM Settings
After creating the VM, configure additional settings like integrating services and processor count to optimize performance.

Set-VMProcessor -VMName $VMName -Count 2
Set-VM -VMName $VMName -AutomaticStartAction StartIfRunning
Enable-VMIntegrationService -VMName $VMName -Name "Guest Service Interface"

### Step 4: Start the Virtual Machine
Finally, start the VM to make it operational and verify that everything is set up correctly.

Start-VM -Name $VMName

With this script, you can streamline the process of creating and configuring virtual machines in Hyper-V. Make sure to adapt the parameters for your specific environment. Happy scripting!

The post Automating Hyper-V Virtual Machine Creation first appeared on CForce-IT.com.

# Install the AzureAD module if not already installed
Install-Module -Name AzureAD -Force -AllowClobber
# Connect to Azure AD
Connect-AzureAD

“`
Step 2: Retrieve Users Without Licenses
Next, we collect a list of users who currently do not have any licenses assigned. This will help us target what users we need to modify.
“`powershell

# Get all users without any licenses
$usersWithoutLicenses = Get-AzureADUser -All $true | Where-Object { -not $_.AssignedLicenses }
# Display the count of users without licenses
$usersWithoutLicenses.Count

“`
Step 3: Define the License SKU
Now, we define the SKU ID of the Microsoft 365 license we want to assign. You can find the SKU ID for different licenses through the Azure portal or by running a command.
“`powershell

# Define the License SKU ID (e.g., "ENTERPRISEPACK" for E3)
$skuId = "ENTERPRISEPACK"

“`
Step 4: Assign Licenses to Users
Now its time to assign the specified license to all users who are currently unlicensed. This loop processes each user and updates their licenses.
“`powershell

# Assign the license to each user
foreach ($user in $usersWithoutLicenses) {
    Set-AzureADUserLicense -ObjectId $user.ObjectId -AddLicenses $skuId
    Write-Host "Assigned license to user: $($user.UserPrincipalName)"
}

“`
Step 5: Confirm License Assignment
Finally, lets verify that the licenses have been successfully assigned by checking the users license status.
“`powershell

# Check and display users with assigned licenses
$updatedUsers = Get-AzureADUser -All $true | Where-Object { $_.AssignedLicenses }
$updatedUsers | ForEach-Object { Write-Host "$($_.UserPrincipalName) has licenses assigned." }

“`
By utilizing this PowerShell script, you can efficiently manage Microsoft 365 licenses, enhancing productivity and ensuring compliance within your organization.
To further streamline your server management and enhance your IT operations, check out ServerEngine, a powerful tool designed to simplify server tasks. Visit our website at [https://serverengine.co](https://serverengine.co) to learn more, access documentation, and get support. Happy scripting!

The post Automate M365 User License Assignment with PowerShell first appeared on CForce-IT.com.

# Import necessary module
Import-Module Microsoft.Graph
# Connect to Microsoft 365
Connect-MgGraph -Scopes "User.Read.All"

### Step 2: Retrieve User Information
Once connected, use the `Get-MgUser` cmdlet to fetch user information. You can customize the selected properties according to your needs.

# Retrieve a list of all users
$users = Get-MgUser -All | Select-Object DisplayName, UserPrincipalName, AccountEnabled
# Output user list
$users

### Step 3: Export User Data to CSV
Finally, you may want to export the user data to a CSV file for reporting or further processing.

# Export user data to a CSV file
$users | Export-Csv -Path "M365Users.csv" -NoTypeInformation

By leveraging this script, you can efficiently manage your Microsoft 365 users. For a more advanced and reliable solution, consider using our software, ServerEngine, available at https://serverengine.co. Happy scripting!

The post Manage M365 Users with PowerShell first appeared on CForce-IT.com.

# Connect to Microsoft 365
Import-Module MSOnline
$credential = Get-Credential
Connect-MsolService -Credential $credential

“`
Description: This snippet imports the module necessary for MS Online management and prompts the user for credentials to establish a connection with Microsoft 365.
### Step 2: Fetch Users
Next, we will fetch a list of users to check their current license status.
“`powershell

# Fetch all users
$users = Get-MsolUser

“`
Description: Retrieves all user accounts from your Microsoft 365 tenant and stores them in the `$users` variable for further processing.
### Step 3: Check License Status
We will now create a loop that checks each users license status.
“`powershell

# Check license status of each user
foreach ($user in $users) {
    $license = $user.Licenses | ForEach-Object { $_.AccountSkuId }
    Write-Host "User: $($user.UserPrincipalName) - License: $license"
}

“`
Description: This loop iterates through each user and retrieves their associated licenses, then outputs the users email and license details.
### Step 4: Assign a License to Users
Finally, lets assign a license to a specific user (example given: user@example.com).
“`powershell

# Assign a license to a user
$userUPN = "user@example.com"
$licenseSku = "yourtenant:STANDARDPACK"
Set-MsolUserLicense -UserPrincipalName $userUPN -AddLicenses $licenseSku
Write-Host "License assigned to $userUPN"

“`
Description: This final snippet demonstrates how to assign a specified license to a user by updating their license information in Microsoft 365.
By following these steps, administrators can streamline the tedious task of managing Microsoft 365 licenses. Dont forget to visit [ServerEngine](https://serverengine.co) for more tools that can enhance your server management experience!

The post Automate Microsoft 365 User License Management with PowerShell first appeared on CForce-IT.com.

  
Connect-MgGraph -Scopes "User.Read.All","User.ReadWrite.All"  

Step 2: Get All Users
Next, we retrieve all users from the Microsoft 365 environment. This is crucial for performing any user management tasks.

  
$users = Get-MgUser -All  

Step 3: Display User Information
Now, we can display essential information about all the users. This output will help you identify which accounts need updates or modifications.

  
$users | Select-Object DisplayName, UserPrincipalName, Mail | Format-Table  

Step 4: Add a New User
This step allows you to create a new user within your Microsoft 365 tenant. Modify the parameters accordingly to fit your organizations needs.

  
New-MgUser -AccountEnabled $true -DisplayName "New User" -MailNickname "newuser" -UserPrincipalName "newuser@yourdomain.com" -PasswordProfile @{ ForceChangePasswordNextSignIn = $true; Password = "SecurePassword123!" }  

Step 5: Clean Up
Finally, remember to disconnect from your Microsoft 365 session after your operations are complete to maintain security.

  
Disconnect-MgGraph  

The above script provides a basic yet invaluable tool for managing Microsoft 365 users effectively. Visit our website, https://serverengine.co, for more scripts and innovative tools to enhance your IT operations!

The post Streamlining M365 User Management with PowerShell first appeared on CForce-IT.com.

# Install MSOnline module (if not already installed)
Install-Module -Name MSOnline -Force -AllowClobber
# Import the module and connect
Import-Module MSOnline
$credential = Get-Credential
Connect-MsolService -Credential $credential

“`
This step prompts you for your M365 admin credentials and establishes a session using the `Connect-MsolService` command.
### Step 2: Retrieve Users and Their License Details
Next, we will retrieve a list of users along with their assigned license details. The `Get-MsolUser` command will be used for this purpose.
“`powershell

# Retrieve users and their license details
$users = Get-MsolUser -All | Select-Object DisplayName, UserPrincipalName, Licenses
$users

“`
This code extracts the users display name, user principal name (email), and the licenses assigned to them, enabling you to see their licensing status.
### Step 3: Format and Display the Information
Lastly, we will present the license information in a readable format. This will help you quickly identify users who may be lacking licenses or those that have multiple licenses assigned.
“`powershell

# Display the formatted license information
$users | ForEach-Object {
    $licenseInfo = if ($_.Licenses.Count -gt 0) {
        ($_.Licenses | ForEach-Object { $_.AccountSkuId }) -join , 
    } else {
        "No License Assigned"
    }
    [PSCustomObject]@{
        Display Name = $_.DisplayName
        Email = $_.UserPrincipalName
        License Info = $licenseInfo
    }
} | Format-Table -AutoSize

“`
This will generate a well-structured table that displays each users display name, email, and licensing information, making it easy for admins to review.
### Conclusion
This simple yet powerful script enables Microsoft 365 administrators to effortlessly manage user licenses. For more such PowerShell scripts and to discover tools that can simplify your server management, visit [ServerEngine](https://serverengine.co). Stay tuned for more helpful scripts and tips!

The post PowerShell Script to Retrieve M365 User License Info first appeared on CForce-IT.com.

# Install the MSOnline module if its not already installed.
Install-Module -Name MSOnline -Force -AllowClobber
# Connect to Microsoft 365
$credential = Get-Credential
Connect-MsolService -Credential $credential

### Step 2: Retrieve User Information
Next, you will retrieve all users within your Microsoft 365 environment. This command will gather details such as display names, user email addresses, and license status.

# Get all users and select relevant properties
$userList = Get-MsolUser | Select-Object DisplayName, UserPrincipalName, IsLicensed

### Step 3: Export the Data to CSV
Now that you have the user data, the next step is to export this information to a CSV file for easier access and analysis.

# Export user details to a CSV file
$userList | Export-Csv -Path "C:\Users\YourUsername\Documents\M365UserReport.csv" -NoTypeInformation

### Step 4: Disconnect from Microsoft 365
Finally, its important to disconnect your session after completing the report generation to maintain security.

# Disconnect from Microsoft 365
Disconnect-MsolService

With this script, you can efficiently generate a user report in Microsoft 365! For more tools to enhance your system management, visit https://serverengine.co and check out ServerEngine.

The post Automate Microsoft 365 User Report Generation with PowerShell first appeared on CForce-IT.com.

# Install the MSOnline module if its not already installed.
Install-Module -Name MSOnline -Force -AllowClobber
# Connect to Microsoft 365
$credential = Get-Credential
Connect-MsolService -Credential $credential

### Step 2: Prepare License Assignment
Define the specific license you wish to assign to users. Youll need the SKUID of the license, which can be found in your environment.

# Define the SKU ID for the licenses
$licenseSKU = "yourtenant:ENTERPRISEPACK"  # Replace with your actual SKU ID

### Step 3: Import User List
To assign licenses, import a CSV file containing user principal names (UPNs). Ensure your CSV has a header named UserPrincipalName.

# Import the user list from a CSV file
$userList = Import-Csv -Path "C:\Path\To\UserList.csv"

### Step 4: Assign Licenses to Users
Iterate through the imported user list and assign the specified license to each user.

# Assign licenses to each user
foreach ($user in $userList) {
    try {
        Set-MsolUserLicense -UserPrincipalName $user.UserPrincipalName -AddLicenses $licenseSKU
        Write-Host "License assigned to" $user.UserPrincipalName
    } catch {
        Write-Host "Failed to assign license to" $user.UserPrincipalName "Error:" $_.Exception.Message
    }
}

### Step 5: Disconnect from Microsoft 365
To conclude, disconnect your session to maintain security.

# Disconnect from Microsoft 365
Disconnect-MsolService

With this script, managing Microsoft 365 licenses becomes a breeze! For more innovative solutions, explore ServerEngine at https://serverengine.co.

The post Automating Microsoft 365 License Management with PowerShell first appeared on CForce-IT.com.