PowerShell Gallery | HelperFunctions.psm1 23.1.8.0 (2023)

functionSave-ClearTextToEncryptedFile($Password,$FileName)
{
$secureStringPwd=$Password|ConvertTo-SecureString-AsPlainText-Force
#$secureStringPwd = New-Object PSCredential ("Dummy User", $Password) | Select-Object -ExpandProperty Password
$secureStringText=$secureStringPwd|ConvertFrom-SecureString
Set-Content$FileName$secureStringText
}

functionSave-SecureStringToEncryptedFile($FileName,$Prompt)
{
if($Prompt-eq$null){$Prompt="Enter Password:"}
$secureStringPwd=Read-Host-Prompt$Prompt-AsSecureString
$secureStringText=$secureStringPwd|ConvertFrom-SecureString
Set-Content$FileName$secureStringText
}

functionGet-SecureStringFromEncryptedFile($FileName)
{
$pwdTxt=Get-Content$FileName
$securePwd=$pwdTxt|ConvertTo-SecureString
Write-Output$securePwd
}

functionGet-ClearTextFromEncryptedFile($FileName)
{
$pwdTxt=Get-Content$FileName
$securePwd=$pwdTxt|ConvertTo-SecureString
$BSTR=[System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($securePwd)
$clearText=[System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)
Write-Output$clearText
}
#endregion

#region Conversion
functionConvertTo-DataTable
{
<#
.SYNOPSIS
Convert regular PowerShell objects to a DataTable object.
.DESCRIPTION
Convert regular PowerShell objects to a DataTable object.
.EXAMPLE
$myDataTable = $myObject | ConvertTo-DataTable

# using the SqlServer PowerShell module to connect to SQL Server and query for and return data
# returns data as an array of DataRow objects
$drs=Invoke-Sqlcmd -ServerInstance "ServerName" -Database Databasename -Username UserName -Password Password -Query "SELECT * FROM [dbo].[DrawingValidation] where Owner='None' and UpToDate=1 order by stamptime desc"

# use this function to Convert the DataRow array to a DataTable
$dt=ConvertTo-DataTable $drs

# use PWPS_DAB cmdlet to output the DataTable into a spreadsheet
New-XLSXWorkbook -InputTables $dt -OutputFileName c:\temp\Output.xlsx

#>
[CmdletBinding()]
param(
# The object to convert to a DataTable
[Parameter(ValueFromPipeline=$true)]
[PSObject[]]$InputObject,

# Override the default type.
[Parameter()]
[string]$DefaultType='System.String'
)

begin{

# create an empty datatable
try{
$dataTable=New-Object-TypeName'System.Data.DataTable'
Write-Verbose-Message'Empty DataTable created'
}

catch{
Write-Warning-Message$_.Exception.Message
break
}

# define a boolean to keep track of the first datarow
$first=$true

# define array of supported .NET types
$types=@(
'System.String',
'System.Boolean',
'System.Byte[]',
'System.Byte',
'System.Char',
'System.DateTime',
'System.Decimal',
'System.Double',
'System.Guid',
'System.Int16',
'System.Int32',
'System.Int64',
'System.Single',
'System.UInt16',
'System.UInt32',
'System.UInt64'
)
}

process{

# iterate through each input object
foreach($objectin$InputObject){

try{

# create a new datarow
$dataRow=$dataTable.NewRow()
Write-Debug-Message'New DataRow created'

# iterate through each object property
foreach($propertyin$object.PSObject.get_properties()){

# check if we are dealing with the first row or not
if($first){

# handle data types
if($types-contains$property.TypeNameOfValue){
$dataType=$property.TypeNameOfValue
Write-Debug-Message"$($property.Name): Supported datatype <$($dataType)>"
}

else{
$dataType=$DefaultType
Write-Debug-Message"$($property.Name): Unsupported datatype ($($property.TypeNameOfValue)), using default <$($DefaultType)>"
}

# create a new datacolumn
$dataColumn=New-Object'System.Data.DataColumn'$property.Name,$dataType
Write-Debug-Message'Created new DataColumn'

# add column to DataTable
$dataTable.Columns.Add($dataColumn)
Write-Debug-Message'DataColumn added to DataTable'
}

# add values to column
if($property.Value-ne$null){

# handle data types
if($types-contains$property.TypeNameOfValue){
$dataType=$property.TypeNameOfValue
Write-Debug-Message"$($property.Name): Supported datatype <$($dataType)>"
}

# if array or collection, add as XML
if(($property.Value.GetType().IsArray)-or($property.TypeNameOfValue-like'*collection*')){
$dataRow.Item($property.Name)=$property.Value|ConvertTo-Xml-As'String'-NoTypeInformation-Depth1
Write-Debug-Message'Value added to row as XML'
}

else{
$dataRow.Item($property.Name)=$property.Value-as$dataType
Write-Debug-Message"Value ($($property.Value)) added to row as $($dataType)"
}
}
}

# add DataRow to DataTable
$dataTable.Rows.Add($dataRow)
Write-Debug-Message'DataRow added to DataTable'
}

catch{
Write-Warning-Message$_.Exception.Message
}

$first=$false
}
}

end{
#"properties" that aren't really columns when this is passed an array of or DataRows
if($dataTable.Columns.Contains("RowError")){$dataTable.Columns.Remove("RowError")}
if($dataTable.Columns.Contains("RowState")){$dataTable.Columns.Remove("RowState")}
if($dataTable.Columns.Contains("Table")){$dataTable.Columns.Remove("Table")}
if($dataTable.Columns.Contains("ItemArray")){$dataTable.Columns.Remove("ItemArray")}
if($dataTable.Columns.Contains("HasErrors")){$dataTable.Columns.Remove("HasErrors")}

Write-Output(,($dataTable))
}
}
#endregion

#region Utility

FUNCTIONNew-PWScanForReferences
{
<#
.SYNOPSIS
Runs the ScanRef.exe with provided parameter values.
.DESCRIPTION
The function runs a scan for reference job using the parameter values passed. MUST be run in a 32Bit session of PowerShell. See ScanRef documenation on the command line parameters for details on the cmdlet parameters functionality.
.INPUTS
None
.OUTPUTS
None
.EXAMPLE
There are many options and configurations for this function. Use the following as a template to setup your reference scanning.
$NewScanRef = @{
DataSourceName = '';
UserName = '';
Password = '';
ScanMode = 'references';
MasterDocuments = '';
MasterFolders = '';
Priority = '';
Proximity = 'r:1';
Order = 'priority;proximity';
Applications = '';
LogFilePath = '';
}
New-PWScanForReferences @NewScanRef -RecurseMasterFolders -RecursePriority -OpenLogFile -Verbose
#>
[CMDLETBINDING()]
PARAM(
[Parameter(
Position=0,
Mandatory=$true,
HelpMessage="ProjectWise Datasource to log into.")]
[string]$DataSourceName,

[PARAMETER(
Position=1,
Mandatory=$false,
HelpMessage="If this option is absent, SSO login will be attempted.")]
[string]$UserName,

[PARAMETER(
Position=2,
Mandatory=$false,
HelpMessage="If this option is absent, password prompt will be shown. When username is supplied.")]
[string]$Password,

[PARAMETER(
Position=3,
Mandatory=$false,
HelpMessage="Specifies a list of scanning modes to use. If not included, defaults to references;linksets.")]
[ValidateSet("references","linksets","references;linksets")]
[string[]]$ScanMode="references;linksets",

[PARAMETER(
Mandatory=$false,
HelpMessage="A list of documents to scan for references and/or linksets.")]
[string[]]$MasterDocuments,

[PARAMETER(
Mandatory=$false,
HelpMessage="A list of folders to scan for references and/or linksets.")]
[string[]]$MasterFolders,

[PARAMETER(
Mandatory=$false,
HelpMessage="When included, all sub-folders within the supplied folder path will be scanned for references and/or linksets.")]
[switch]$RecurseMasterFolders,

[PARAMETER(
Mandatory=$false,
HelpMessage="Enable priority search for reference files in the specified folders. To recurse folders, prefix with r:.")]
[string[]]$Priority,

[PARAMETER(
Mandatory=$false,
HelpMessage="When included, all sub-folders within the supplied folder path will be scanned for references and/or linksets.")]
[switch]$RecursePriority,

[PARAMETER(
Mandatory=$false,
HelpMessage="Enable proximity search for reference files <number> levels above the master file's folder. To recurse folders, prefix with r:.")]
# [ValidateSet("0", "1", "r:1")]
[string[]]$Proximity,

[PARAMETER(
Mandatory=$false,
HelpMessage="Order in which the proximity and priority searches will be done (if both are enabled). If this parameter is not specified, proximity search will take precedence.")]
[ValidateSet("proximity","priority","priority;proximity","proximity;priority")]
[string]$Order="proximity;priority",

[PARAMETER(
Mandatory=$false,
HelpMessage="Application filter for the lists of documents to scan - only the documents with matching application names will be scanned.")]
[string[]]$Applications,

[PARAMETER(
Mandatory=$false,
HelpMessage="Log file path.")]
[string]$LogFilePath,

[PARAMETER(
Mandatory=$false,
HelpMessage="When included, the log file will be open when process is complete.")]
[switch]$OpenLogFile
)

BEGIN{
$Continue=$true
# This function will only run within a 32Bit session of PowerShell.
if($env:PROCESSOR_ARCHITECTURE-ne'x86'){
Write-Warning-Message"This New-PWScanForReferences function will ONLY run in a 32Bit session of PowerShell."
$Continue=$false
}
}

PROCESS{
if($Continue=$false){
return
}

# Variables:
#$DataSourceName = $datasource #'BMF_W2K12R2:PSTraining'
#$UserName = $user #'admin'
## Entered in clear text. This can be modified to encrypt or lookup password.
#$Password = $password # 'admin'

# The following retrieves the ProjectWise path information from the registry.
#$execpath = # Get-PWScanRefsPath
#
## Stops processing if the path information is not found.
#if([string]::IsNullOrEmpty($ExecPath)) {
# Write-Error("Failed to get ProjectWise path.")
# return;
#}

# Verify the scanrefs executable exists on the current machine. Stops processing if not found.
$executable="C:\Program Files (x86)\Bentley\ProjectWise\bin\scanrefs.exe"#(Get-PWScanRefsPath) + "\scanrefs.exe"
if(-not(Test-Path-Path$executable))
{
Write-Error("Could not find scanrefs.exe file.")
return;
}else{
"Found scanrefs.exe file."
}# end if/else

# -d datasource Datasource name to connect to.
$dsname=$DataSourceName
Write-Verbose"DSName = $dsname"
# -u username Username for the datasource connection.
# If this option is absent, SSO login will be attempted.
$user=$UserName
Write-Verbose"UserName = $user"
# -p password Password of the datasource user.
# If this option is absent, password prompt will be shown.
$pw=$Password
Write-Verbose"PW = $pw"

# -mode scanmode Specifies a list of scanning modes to use.
# If this option is absent, the tool will operate in "references;linksets" mode.
#
# Possible modes:
# references - scan for references.
# linksets - scan DGN documents for link sets.
# urfcs - update references from current set - no attempt will be made at creating new sets,
# only existing reference sets will be updated.
# If this mode is enabled, priority or proximity reference search paths will be ignored.
# This option is intended to be used after upgrading a datasource from a pre-V8.1 version.
# Note that this mode disables other modes.
# Modes can be combined:
# references;linksets - scan for reference documents and for DGN link sets.
# NOTE: Do not add spaces between mode labels. This will cause an error (Unrecognized scanning mode:)
$scanmode1=$ScanMode# 'references'
Write-Verbose"ScanMode = $scanmode1"

# -masters documentlist A list of documents to scan for references and/or linksets.
if([string]::IsNullOrEmpty($MasterDocuments)){
$masterdocuments1=-1
}else{
$masterdocuments1=$MasterDocuments
Write-Verbose"MasterDocuments = $masterdocuments1"
}# end if/else

# -masterfolders folderlist A list of folders to scan for references and/or linksets.
# If RecurseMasterFolders is included, prefix master folders with r:.
if([string]::IsNullOrEmpty($MasterFolders)){
$masterfolders1=-1
}
else
{
$masterfolders1=$MasterFolders#"r:Documents\Projects\NewFolder\BSI900 - Adelaide Tower"
if($RecurseMasterFolders)
{
$masterfolders1=""
$folders=$masterfolders.Split(";")

foreach($folderin$folders)
{
$masterfolders1=$masterfolders1+"r:"+$folder+";"
}

$masterfolders1=$masterfolders1.TrimEnd(";")
}
}# end if/else
Write-Verbose"MasterFolders = $masterfolders1"

# -priority folderlist Enable priority search for reference files in the specified folders.
# Prefix folder path with "r:" to recurse through the folder and sub-folders.
# NOTE: Ensure the folder path does NOT end with a backslash "\". This will cause an error.
# NOTE: Do not add spaces between folder paths. This will cause an error.
if([string]::IsNullOrEmpty($Priority)){
$priority1=-1
}
else
{
$priority1=$Priority#"r:Documents\BSI900 - Adelaide Tower\05-Incoming;r:Documents\BSI900 - Adelaide Tower\03-Published"
if($RecursePriority)
{
$priority1=""
$folders=$Priority.Split(";")

foreach($folderin$folders)
{
$priority1=$priority1+"r:"+$folder+";"
}

$priority1=$priority1.TrimEnd(";")
}
Write-Verbose"Priority = $priority1"
}# end if/else

### Proximity is required when priority is not set.
#
# -proximity [r:]number Enable proximity search for reference files <number> levels above the master file's folder.
# r: switch enables recursive search (includes subfolders).
# Examples:
# -proximity 0 - look for references in the master's folder.
# -proximity 1 - look for references in the parent folder of the master.
# -proximity r:1 - look for references in the master's folder's parent folder and its subfolders.
if([string]::IsNullOrEmpty($Proximity)){
if($priority1-eq-1){
Write-Verbose"Setting proximity to 0 due to priority not being included."
$proximity1=0
}else{
$proximity1=-1
}# end if/else
}else{
$proximity1=$Proximity#"r:1"
Write-Verbose"Proximity = $proximity1"
}# end if/else

# -order orderlist Order in which the proximity and priority searches will be done (if both are enabled).
# If this parameter is not specified, proximity search will take precedence.
# Examples:
# -order proximity;priority - proximity first.
# -order priority;proximity - priority first.
# NOTE: Do not add spaces between order label. This will cause an error (Input error: Unknown search type:).
$order1=$Order#"priority;proximity"
Write-Verbose"Order = $order1"

# -af applicationlist Application filter for the lists of documents to scan - only the documents with matching application names will be scanned.
# Example:
# -af "MicroStation;AutoCad;Bentley Navigator"
# NOTE: This is case sensative, so ensure the names are listed exactly as they are in ProjectWise Administrator.
# NOTE: Do not add spaces between application names. This will cause an error (Collecting data... Failure).
if([string]::IsNullOrEmpty($Applications)){
$applications1=-1
}else{
$applications1=$Applications#"AutoCAD;MicroStation"
Write-Verbose"Applications = $applications1"
}# end if/else

# -l logfile Log file path.
# If logfile path and name is not included, set default to 'c:\temp\'.
if([string]::IsNullOrEmpty($LogFilePath)){
$logfilePath1='c:\temp\'
}else{
$logfilePath1=$LogFilePath
}# end if/else

# Test to determine if the log folder exists. If not, create.
if(-not(Test-Path-Path$logfilePath1)){
New-Item-Path$logfilePath1-ItemType"directory"
}

$logfile="$logfilePath1\ScanRef.log"
# -lv Use verbose logging - write more details to the log file.

# masterfolders
# masterdocuments
# applications
# priority
# If priority is enabled, proximity is not required. If priority is not included, proximity is required.

# Master Folders ONLY
if(($masterfolders1-ne-1)-and($masterdocuments1-eq-1)){
if($applications1-eq-1){
# Masterfolders1, no applications, no priority, proximity
# Masterfolders1, no applications, priority, no proximity
# Masterfolders1, no applications, priority, proximity
if($priority1-eq-1){
Write-Verbose"Only master folders will be scanned. Applications NOT included. Priority NOT included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-proximity$proximity1-order$order1-l$logfile-lv
}elseif($proximity1-eq-1){
Write-Verbose"Only master folders will be scanned. Applications NOT included. Priority included. Proximity NOT included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-priority$priority1-order$order1-l$logfile-lv
}else{
Write-Verbose"Only master folders will be scanned. Applications NOT included. Priority included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-priority$priority1-proximity$proximity1-order$order1-l$logfile-lv
}# end if/elseif/else

}else{
# Masterfolders1, applications, no priority, proximity
# Masterfolders1, applications, priority, no proximity
# Masterfolders1, applications, priority, proximity
if($priority1-eq-1){
Write-Verbose"Only master folders will be scanned. Applications included. Priority NOT included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-af$applications1-proximity$proximity1-order$order1-l$logfile-lv
}elseif($proximity1-eq-1){
Write-Verbose"Only master folders will be scanned. Applications included. Priority included. Proximity NOT included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-af$applications1-priority$priority1-order$order1-l$logfile-lv
}else{
Write-Verbose"Only master folders will be scanned. Applications included. Priority included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-af$applications1-priority$priority1-proximity$proximity1-order$order1-l$logfile-lv
}# end if/elseif/else
}# end if/else
}elseif(($masterfolders1-eq-1)-and($masterdocuments1-ne-1)){
if($applications1-eq-1){
# masterdocuments1, no applications, no priority, proximity
# masterdocuments1, no applications, priority, no proximity
# masterdocuments1, no applications, priority, proximity
if($priority1-eq-1){
Write-Verbose"Only master documents will be scanned. Applications NOT included. Priority NOT included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masters$masterdocuments1-proximity$proximity1-order$order1-l$logfile-lv
}elseif($proximity1-eq-1){
Write-Verbose"Only master documents will be scanned. Applications NOT included. Priority included. Proximity NOT included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masters$masterdocuments1-priority$priority1-order$order1-l$logfile-lv
}else{
Write-Verbose"Only master documents will be scanned. Applications NOT included. Priority included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masters$masterdocuments1-priority$priority1-proximity$proximity1-order$order1-l$logfile-lv
}# end if/elseif/else

}else{
# masterdocuments1, applications, no priority, proximity
# masterdocuments1, applications, priority, no proximity
# masterdocuments1, applications, priority, proximity
if($priority1-eq-1){
Write-Verbose"Only master documents will be scanned. Applications included. Priority NOT included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masters$masterdocuments1-af$applications1-proximity$proximity1-order$order1-l$logfile-lv
}elseif($proximity1-eq-1){
Write-Verbose"Only master documents will be scanned. Applications included. Priority included. Proximity NOT included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masters$masterdocuments1-af$applications1-priority$priority1-order$order1-l$logfile-lv
}else{
Write-Verbose"Only master documents will be scanned. Applications included. Priority included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masters$masterdocuments1-af$applications1-priority$priority1-proximity$proximity1-order$order1-l$logfile-lv
}# end if/elseif/else
}# end if/else
}elseif(($masterfolders1-ne-1)-and($masterdocuments1-ne-1)){
if($applications1-eq-1){
# Masterfolders1, masterdocuments1, no applications, no priority, proximity
# Masterfolders1, masterdocuments1, no applications, priority, no proximity
# Masterfolders1, masterdocuments1, no applications, priority, proximity
if($priority1-eq-1){
Write-Verbose"Both master folders and documents will be scanned. Applications NOT included. Priority NOT included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-masters$masterdocuments1-proximity$proximity1-order$order1-l$logfile-lv
}elseif($proximity1-eq-1){
Write-Verbose"Both master folders and documents will be scanned. Applications NOT included. Priority included. Proximity NOT included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-masters$masterdocuments1-priority$priority1-order$order1-l$logfile-lv
}else{
Write-Verbose"Both master folders and documents will be scanned. Applications NOT included. Priority included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-masters$masterdocuments1-priority$priority1-proximity$proximity1-order$order1-l$logfile-lv
}# end if/elseif/else

}else{
# Masterfolders1, masterdocuments1, applications, no priority, proximity
# Masterfolders1, masterdocuments1, applications, priority, no proximity
# Masterfolders1, masterdocuments1, applications, priority, proximity
if($priority1-eq-1){
Write-Verbose"Both master folders and documents will be scanned. Applications included. Priority NOT included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-masters$masterdocuments1-af$applications1-proximity$proximity1-order$order1-l$logfile-lv
}elseif($proximity1-eq-1){
Write-Verbose"Both master folders and documents will be scanned. Applications included. Priority included. Proximity NOT included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-masters$masterdocuments1-af$applications1-priority$priority1-order$order1-l$logfile-lv
}else{
Write-Verbose"Both master folders and documents will be scanned. Applications included. Priority included. Proximity included."
&$executable-d$dsname-u$user-p$pw-mode$scanmode1-masterfolders$masterfolders1-masters$masterdocuments1-af$applications1-priority$priority1-proximity$proximity1-order$order1-l$logfile-lv
}# end if/elseif/else
}# end if/else
}# end if/elseif/else
}# end process

END{
# Opens log file
if($OpenLogFile){
if(Test-Path$logfile){
explorer$logfile
}
}# end if
}# end
}
#Export-ModuleMember -Function New-PWScanForReferences

FUNCTIONNew-PWEnumFolders
{
<#
.SYNOPSIS
Runs the EnumFolders.exe with provided parameter values.
.DESCRIPTION
The function runs the enumfolders.exe using the parameter values passed.
.INPUTS
None
.OUTPUTS
None
.EXAMPLE
There are many options and configurations for this function. Use the following as a template to setup your reference scanning.
$NewEnum = @{
DataSourceName = '';
UserName = '';
Password = '';
PWFolder = '';
OutputFilePath = '';
}
New-PWEnumFolders @NewEnum -IncludeDocuments -RecurseFolders-OpenLogFile -Verbose
#>
[CMDLETBINDING()]
PARAM(
[Parameter(
Position=0,
Mandatory=$true,
HelpMessage="ProjectWise Datasource to log into.")]
[string]$DataSourceName,

[PARAMETER(
Position=1,
Mandatory=$false,
HelpMessage="If this option is absent, SSO login will be attempted.")]
[string]$UserName,

[PARAMETER(
Position=2,
Mandatory=$false,
HelpMessage="If this option is absent, password prompt will be shown. When username is supplied.")]
[string]$Password,

[PARAMETER(
Position=3,
Mandatory=$false,
HelpMessage="Specifies a folder ID to enumerate. If not included, returns information for the entire datasource.")]
[int]$PWFolderID=0,

[PARAMETER(
Mandatory=$false,
HelpMessage="When included, all sub-folders are enumerated.")]
[switch]$RecurseFolders,

[PARAMETER(
Mandatory=$false,
HelpMessage="Include documents within the enumeration process.")]
[switch]$IncludeDocuments,

[PARAMETER(
Mandatory=$false,
HelpMessage="Include deleted objects within the enumeration process.")]
[switch]$IncludeDeletedObjects,

[PARAMETER(
Mandatory=$false,
HelpMessage="Uses verbose operation. (Does not appear to do anything.)")]
[switch]$VerboseOperation,

[PARAMETER(
Mandatory=$false,
HelpMessage="Output file path and name.")]
[string]$OutputFilePathName="c:\temp\"+(Get-Date).Year+(Get-Date).Month+(Get-Date).Day+"_enumfolders.txt",

[PARAMETER(
Mandatory=$false,
HelpMessage="When included, the output file will be open when process is complete.")]
[switch]$OpenOutputFile
)

BEGIN{

}

PROCESS{
<#
Enumerates the objects in a folder hierarchy.
Options:
-d datasource hostname:datasource.
-u user ProjectWise username (omit for domain auth).
-p password ProjectWise password (omit for domain auth).
-f folder # Folder to enumerate (GUID or integer folder id)
-v Verbose operation.
-D Include documents in object list
-l Include deleted objects in object list
-r Recursive enumeration operation. All subfolders are
enumerated, along with any objects in those subfolders.
-o filename Save results to the specified file.
#>

# Verify the enumfolders.exe executable exists on the current machine. Stops processing if not found.
$executable="C:\Program Files (x86)\Bentley\ProjectWise\bin\enumfolders.exe"
if(-not(Test-Path-Path$executable))
{
Write-Error"Could not find enumfolders.exe file."
return;
}else{
Write-Verbose"Found enumfolders.exe file."-Verbose
}# end if/else

# -d datasource Datasource name to connect to.
$dsname=$DataSourceName
Write-Verbose"DSName = $dsname"
# -u username Username for the datasource connection.
# If this option is absent, SSO login will be attempted.
$user=$UserName
Write-Verbose"UserName = $user"
# -p password Password of the datasource user.
# If this option is absent, password prompt will be shown.
$pw=$Password
Write-Verbose"PW = $pw"

Write-Verbose"FolderID: $PWFolderID"-Verbose
Write-Verbose"Recurse: $RecurseFolders"-Verbose
Write-Verbose"IncludeDocuments: $IncludeDocuments"-Verbose
Write-Verbose"IncludeDeletedObjects: $IncludeDeletedObjects"-Verbose
Write-Verbose"VerboseOperation: $VerboseOperation"-Verbose

# RecurseFolders
# If RecurseFolders ONLY
if($RecurseFolders-and(-not($IncludeDocuments))-and(-not($IncludeDeletedObjects))-and(-not($VerboseOperation))){
Write-Verbose"Recurse through all folders ONLY. Do not include documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects NOT included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-r-o$OutputFilePathName
}elseif($RecurseFolders-and$IncludeDocuments-and(-not($IncludeDeletedObjects))-and(-not($VerboseOperation))){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments IS included. IncludeDeletedObjects NOT included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-r-D-o$OutputFilePathName
}elseif($RecurseFolders-and(-not($IncludeDocuments))-and$IncludeDeletedObjects-and(-not($VerboseOperation))){
Write-Verbose"Recurse through all folders. Do not include documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects IS included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-r-l-o$OutputFilePathName
}elseif($RecurseFolders-and(-not($IncludeDocuments))-and(-not($IncludeDeletedObjects))-and$VerboseOperation){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects NOT included. VerboseOperation IS included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-r-v-o$OutputFilePathName
}elseif($RecurseFolders-and$IncludeDocuments-and$IncludeDeletedObjects-and(-not($VerboseOperation))){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments IS included. IncludeDeletedObjects IS included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-r-D-l-o$OutputFilePathName
}elseif($RecurseFolders-and$IncludeDocuments-and$IncludeDeletedObjects-and$VerboseOperation){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments IS included. IncludeDeletedObjects IS included. VerboseOperation IS included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-r-D-l-v-o$OutputFilePathName
}elseif($RecurseFolders-and(-not($IncludeDocuments))-and$IncludeDeletedObjects-and$VerboseOperation){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects IS included. VerboseOperation IS included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-r-l-v-o$OutputFilePathName
}

# Without RecurseFolders
if((-not($RecurseFolders))-and(-not($IncludeDocuments))-and(-not($IncludeDeletedObjects))-and(-not($VerboseOperation))){
Write-Verbose"Current folder ONLY. Do not include documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects NOT included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-o$OutputFilePathName
}elseif((-not($RecurseFolders))-and$IncludeDocuments-and(-not($IncludeDeletedObjects))-and(-not($VerboseOperation))){
Write-Verbose"Current folder and documents."-Verbose
Write-Verbose"IncludeDocuments IS included. IncludeDeletedObjects NOT included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-D-o$OutputFilePathName
}elseif((-not($RecurseFolders))-and(-not($IncludeDocuments))-and$IncludeDeletedObjects-and(-not($VerboseOperation))){
Write-Verbose"Recurse through all folders. Do not include documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects IS included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-l-o$OutputFilePathName
}elseif((-not($RecurseFolders))-and(-not($IncludeDocuments))-and(-not($IncludeDeletedObjects))-and$VerboseOperation){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects NOT included. VerboseOperation IS included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-v-o$OutputFilePathName
}elseif((-not($RecurseFolders))-and$IncludeDocuments-and$IncludeDeletedObjects-and(-not($VerboseOperation))){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments IS included. IncludeDeletedObjects IS included. VerboseOperation NOT included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-D-l-o$OutputFilePathName
}elseif((-not($RecurseFolders))-and$IncludeDocuments-and$IncludeDeletedObjects-and$VerboseOperation){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments IS included. IncludeDeletedObjects IS included. VerboseOperation IS included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-D-l-v-o$OutputFilePathName
}elseif((-not($RecurseFolders))-and(-not($IncludeDocuments))-and$IncludeDeletedObjects-and$VerboseOperation){
Write-Verbose"Recurse through all folders and documents."-Verbose
Write-Verbose"IncludeDocuments NOT included. IncludeDeletedObjects IS included. VerboseOperation IS included."-Verbose
&$executable-d$dsname-u$user-p$pw-f$PWFolderID-l-v-o$OutputFilePathName
}
}# end process

END{
# Opens log file
if($OpenOutputFile){
if(Test-Path$OutputFilePathName){
explorer$OutputFilePathName
}
}# end if
}# end
}
#Export-ModuleMember -Function New-PWEnumFolders

#endregion
#region Logging

functionWrite-PWPSLog
{

<#
.SYNOPSIS
Writes and appends logs to a log file.
.DESCRIPTION
Writes and appends logs to a log file. Format for each row is "DateTime [Level] Cmdlet - Message". Max file size for a single log is 10MB, and a maximum of four log files will be created. The older file will rollover if four files exist and the current file size exceeds the size limit.
.PARAMETER Message
Log message to write.
.PARAMETER Path
Path to target log file. File will be created if it doesn't exist. Default path is "C:\users\<username>\AppData\Local\Bentley\Logs\PowerShellLogging.log".
.PARAMETER Level
Severity level for the target log line. Accepts 'Error', 'Warn' and 'Info'.
.PARAMETER Cmdlet
Name of the cmdlet/function/script writing the log line. This is for sorting purposes when analysing logs, so source function/cmdlet/script can be easily identified.
.PARAMETER NoClobber
Switch to enagle NoClobber. If enabled and the target log file already exists, the log will not be written and the file cannot be overwritten.
.EXAMPLE
This example will write an info level log with function name Test-Logging to the default log location, with the message 'We are testing the logging'.
Write-PWPSLog -Cmdlet 'Test-Logging' -Level Info -Message 'We are testing the logging'.
.EXAMPLE
This example will write an error level log with function name Test-Logging to C:\temp\log.log, with the message 'There was an error!'.
Write-PWPSLog -Cmdlet 'Test-Logging' -Level Error -Message 'There was an error!'.

#>

[CmdletBinding()]

Param
(

[Parameter(Mandatory=$true,ValueFromPipelineByPropertyName=$true)]
[ValidateNotNullOrEmpty()]
[Alias("LogContent")]
[string]$Message,

[Parameter(Mandatory=$false)]
[Alias('LogPath')]
[string]$Path="$env:LOCALAPPDATA"+"\Bentley\Logs\PowerShellLogging.log",

[Parameter(Mandatory=$false)]
[ValidateSet("Error","Warn","Info")]
[string]$Level="Info",

[Parameter(Mandatory=$true)]
[string]$Cmdlet,

[Parameter(Mandatory=$false)]
[switch]$NoClobber

)

Begin
{

# Set VerbosePreference to Continue so that verbose messages are displayed.

#$VerbosePreference = 'Continue'

#
# Rollover logs if size is exceeded
#

if((Get-Item-LiteralPath$Path-ErrorActionSilentlyContinue))
{

if((Get-Item-LiteralPath$Path).Length-gt9999999)
{

if((Test-Path-LiteralPath"$Path.3"))
{

Remove-Item-LiteralPath"$Path.3"-Force

}

if((Test-Path-LiteralPath"$Path.2"))
{

Rename-Item-LiteralPath"$Path.2"-NewName"$Path.3"-Force

}

if((Test-Path-LiteralPath"$Path.1"))
{

Rename-Item-LiteralPath"$Path.1"-NewName"$Path.2"-Force

}

Rename-Item-LiteralPath$Path-NewName"$Path.1"-Force

New-Item$Path-Force-ItemTypeFile|Out-Null

}

}

}
Process
{

# If the file already exists and NoClobber was specified, do not write to the log.

if((Test-Path$Path)-AND$NoClobber)
{

Write-Error"Log file $Path already exists, and you specified NoClobber. Either delete the file or specify a different name."
Return

}

# If attempting to write to a log file in a folder/path that doesn't exist create the file including the path.

elseif(!(Test-Path$Path))
{

Write-Verbose"Creating $Path."
$NewLogFile=New-Item$Path-Force-ItemTypeFile

}

else{
# Nothing to see here yet.
}

# Format Date for our Log File
$FormattedDate=Get-Date-Format"yyyy/MM/dd HH:mm:ss"

# Write message to error, warning, or verbose pipeline and specify $LevelText
switch($Level)
{
'Error'
{

$LevelText='ERROR'
Write-Error$Message

}

'Warn'
{

$LevelText='WARNING'
Write-Warning$Message

}
'Info'
{

$LevelText='INFO'
Write-Verbose$Message

}

}

# Write log entry to $Path
"$FormattedDate [$LevelText] $Cmdlet - $Message"|Out-File-FilePath$Path-Append

}
End
{

# Nothing

}

}

functionGet-PWPSLogsFromPreviousDays
{

<#
.SYNOPSIS
Returns log entries written by Write-PWPSLog from a specified number of days ago.
.DESCRIPTION
Searches a log file written using the Write-PWPSLog function, and returns entries from a specified number of days ago. Returns records from a single day only. There is no logging for this cmdlet by design.
.PARAMETER LogFilePath
Target log file path to search. Default is 'C:\users\<username>\AppData\Local\Bentley\Logs\PowerShellLogging.log'.
.PARAMETER DaysAgo
Integer value to specify the desired number of days ago to return logs for. A value of '1' is equal to yesterday.
.PARAMETER IncludeIntermediateDays
Switch to include intermediate results. If days is '5' and this switch is activated, log entries from 5 days ago up until now will be returned, as opposed to just the log entries from 5 days ago if this switch is not activated.
.PARAMETER Level
Target level to return. Default is set to return all levels. Takes multiple inputs. Acceptable input values are 'INFO','WARN' and 'ERROR'.
.EXAMPLE
This example will return all log entries from 10 days ago.
Get-PowerShellLogsFromPreviousDays -DaysAgo 10 -Verbose
.EXAMPLE
This example will return all log entries from the last 10 days.
Get-PowerShellLogsFromPreviousDays -DaysAgo 10 -IncludeIntermediateDays -Verbose
.EXAMPLE
This example will return info and warn log entries from 10 days ago.
Get-PowerShellLogsFromPreviousDays -DaysAgo 10 -Level INFO,WARN -Verbose
.EXAMPLE
This example will return error log entries from the last 10 days.
Get-PowerShellLogsFromPreviousDays -DaysAgo 10 -IncludeIntermediateDays -Level ERROR -Verbose

#>

[CmdletBinding()]

Param
(

[Parameter(Mandatory=$false)]
[string]$LogFilePath="$env:LOCALAPPDATA"+"\Bentley\Logs\PowerShellLogging.log",

[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[int]$DaysAgo,

[Parameter(Mandatory=$false)]
[switch]$IncludeIntermediateDays,

[Parameter(Mandatory=$false)]
[ValidateNotNullOrEmpty()]
[ValidateSet("INFO","WARN","ERROR")]
[string[]]$Level

)

Begin
{

## Check log file exists

if(!(Test-Path-LiteralPath$LogFilePath))
{

Write-Error"Log file not found! ($LogFilePath)"
break;

}

}
Process
{

#region Get Content

try
{

$RawLogContent=Get-Content-LiteralPath$LogFilePath

}
catch
{

Write-Error"Failed to retrieve log content!"
Write-Error$_.Exception.Message
break;

}

#endregion Get Content

#region Sort Log Content

[System.Collections.ArrayList]$TargetLogEntries=@()

if($IncludeIntermediateDays)
{

While($DaysAgo-ge0)
{

foreach($rowin$RawLogContent)
{

try
{

$RawDate=$row.Split(' ')[0]
$CalculatedDate=(Get-Date-Date$row.Split(' ')[0]).Date
$TargetDate=(Get-Date).AddDays(-$DaysAgo).Date

if($CalculatedDate-eq$TargetDate)
{

$TargetLogEntries.Add($row)|Out-Null

}

}
Catch
{

Write-Warning"Could not read row!"
Write-Warning"Raw row content: $row"

}

}

$DaysAgo--

}

}
else
{

foreach($rowin$RawLogContent)
{

try
{

$RawDate=$row.Split(' ')[0]
$CalculatedDate=(Get-Date-Date$row.Split(' ')[0]).Date
$TargetDate=(Get-Date).AddDays(-$DaysAgo).Date

if($CalculatedDate-eq$TargetDate)
{

$TargetLogEntries.Add($row)|Out-Null

}

}
Catch
{

Write-Warning"Could not read row!"
Write-Warning"Raw row content: $row"

}

}

}

$TargetLogEntriesCount=($TargetLogEntries|Measure-Object).Count

Write-Verbose"Returned $TargetLogEntriesCount target log entries."

#endregion Sort Log Content

#region Filter Log Content

if($Level)
{

[System.Collections.ArrayList]$FilteredLogEntries=@()

foreach($rowin$TargetLogEntries)
{

try
{

$CalculatedLevel=$row.Split(' ')[2].TrimStart('[').TrimEnd(']')

if($CalculatedLevel-in$Level)
{

$FilteredLogEntries.Add($row)|Out-Null

}

}
Catch
{

Write-Warning"Could not read row!"
Write-Warning"Raw row content: $row"

}

}

$FilteredLogEntriesCount=($FilteredLogEntries|Measure-Object).Count

Write-Verbose"Returned $FilteredLogEntriesCount filtered log entries."

}

#endregion Filter Log Content

}
End
{

if($Level-and($FilteredLogEntriesCount-gt0))
{

Write-Output$FilteredLogEntries

}
elseif($Level-and($FilteredLogEntriesCount-eq0))
{

Write-Warning"No log entries found for specified dates and levels."

}
elseif(!($Level)-and($TargetLogEntriesCount-gt0))
{

Write-Output$TargetLogEntries

}
elseif(!($Level)-and($TargetLogEntriesCount-eq0))
{

Write-Warning"No log entries found for specified dates."

}
else
{

Write-Error"Unable to output log entries!"

}

}

}

#endregion Logging

#region Windows

FunctionGet-WindowsFolderPath($InitialDirectory)
{
[System.Reflection.Assembly]::LoadWithPartialName("System.windows.forms")|Out-Null

$FolderBrowser=New-ObjectSystem.Windows.Forms.FolderBrowserDialog
$FolderBrowser.Description="Select a folder"
$FolderBrowser.rootfolder="MyComputer"

if($FolderBrowser.ShowDialog()-eq"OK")
{
$FolderPath+=$FolderBrowser.SelectedPath
}

return$FolderPath
}

FunctionGet-WindowsFilePath($InitialDirectory)
{
[System.Reflection.Assembly]::LoadWithPartialName("System.windows.forms")|Out-Null

$FileBrowser=New-ObjectSystem.Windows.Forms.OpenFileDialog
$FileBrowser.Multiselect=$false
$FileBrowser.Filter='Excel Workbooks (*.xls, *.xlsx)|*.xls;*.xlsx'

if($FileBrowser.ShowDialog()-eq"OK")
{
$FilePath+=$FileBrowser.FileName
}

return$FilePath
}

#endregion Windows

#region SQL

functionBulkCopy-SQLTable
{

<#
.SYNOPSIS
Bulk copies a datatable into a SQL table.
.DESCRIPTION
Copies the contents of an input datatable to a target table in the database. The target table can be truncated before bulk copy is executed. Database is specified in New-SQLConnection.
.PARAMETER SQLConnection
SQL Server connection generated using New-SQLConnection. Database must be specified in New-SQLConnection to use this BulkCopy-SQLTable.
.PARAMETER Datatable
Datatable containing the records to be bulk copied to the target SQL table. Must have matching schema with target table.
.PARAMETER TruncateBeforeCopy
If this switch parameter is activated, the target SQL table will be truncated before records from the input datatable are bulk copied.
.EXAMPLE
This example will bulk copy all records from the dms_audt datatable to the dms_audt SQL table in the database specified during SQL Connection.
$SQLConnection = New-SQLConnection -SQLServer 'SQLONE' -Database 'DATABASEONE' -WindowsAuthentication
$DataTable = Select-PWSQLDataTable -SQLSelectStatement "SELECT * FROM dms_audt"
$DataTable.TableName = "dms_audt"
BulkCopy-SQLTable -SQLConnection $SQLConnection -DataTable $DataTable
.EXAMPLE
This example will bulk copy all records from the dms_audt datatable to the dms_audt SQL table in the database specified during SQL Connection, truncating the SQL table before bulk copying.
$SQLConnection = New-SQLConnection -SQLServer 'SQLONE' -Database 'DATABASEONE' -WindowsAuthentication
$DataTable = Select-PWSQLDataTable -SQLSelectStatement "SELECT * FROM dms_audt"
$DataTable.TableName = "dms_audt"
BulkCopy-SQLTable -SQLConnection $SQLConnection -DataTable $DataTable -TruncateBeforeCopy
#>

[CmdletBinding()]

Param
(

[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[Microsoft.SqlServer.Management.Common.ConnectionManager]$SQLConnection,

[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[System.Data.DataTable]$DataTable,

[Parameter(Mandatory=$false)]
[switch]$TruncateBeforeCopy

)

Begin
{

#region Startup

$Cmdlet='BulkCopy-SQLTable'

#endregion Startup

#region Parameter Checks

### Check database is specified in SQL Connection object

if(!($SQLConnection.DatabaseName))
{

$Message="No database specified in SQL Connection. Create new SQL Connection using New-SQLConnection, making sure to specify the database parameter."
Write-Error$Message
Write-PWPSLog-Cmdlet$Cmdlet-Message$Message-LevelError

return;

}

#endregion Parameter Checks

}
Process
{

#region Truncate Table

if($TruncateBeforeCopy)
{

$Message="Truncate switch activated. Truncating table '$($DataTable.TableName)' in database '$($SQLConnection.DatabaseName)'..."
Write-Verbose$Message

if($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent)
{

Write-PWPSLog-Cmdlet$Cmdlet-LevelInfo-Message$Message

}

try
{

Truncate-SQLTable-SQLConnection$SQLConnection-TableName$DataTable.TableName-ErrorActionStop

}
catch
{

$Message="$($PSItem.Exception.Message)"
Write-Error$Message
Write-PWPSLog-Cmdlet$Cmdlet-Message$Message-LevelError

$Message="Error truncating table."
Write-Error$Message
Write-PWPSLog-Cmdlet$Cmdlet-Message$Message-LevelError

return;

}

$Message="Successfully truncated table."
Write-Verbose$Message

if($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent)
{

Write-PWPSLog-Cmdlet$Cmdlet-LevelInfo-Message$Message

}

}

#endregion Truncate Table

#region Define SQL Objects

### Initiate Bulk Copy object

$Message="Initiating SQL Bulk Copy object."
Write-Verbose$Message

if($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent)
{

Write-PWPSLog-Cmdlet$Cmdlet-LevelInfo-Message$Message

}

try
{

$SQLBulkCopy=New-ObjectData.SqlClient.SqlBulkCopy$SQLConnection
$SQLBulkCopy.DestinationTableName=$Datatable.TableName

}
catch
{

$Message="$($PSItem.Exception.Message)"
Write-Error$Message
Write-PWPSLog-Cmdlet$Cmdlet-Message$Message-LevelError

$Message="Error initiating SQL Bulk Copy object."
Write-Error$Message
Write-PWPSLog-Cmdlet$Cmdlet-Message$Message-LevelError

return;

}

$Message="Successfully initiated SQL Bulk Copy object."
Write-Verbose$Message

if($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent)
{

Write-PWPSLog-Cmdlet$Cmdlet-LevelInfo-Message$Message

}

#endregion Define SQL Objects

}
End
{

#region Bulk Copy table

$Message="Performing bulk copy of '$($Datatable.TableName)' to database '$($SQLConnection.DatabaseName)'..."
Write-Verbose$Message

if($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent)
{

Write-PWPSLog-Cmdlet$Cmdlet-LevelInfo-Message$Message

}

$Message="Copying $($Datatable.Rows.Count) rows..."
Write-Verbose$Message

if($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent)
{

Write-PWPSLog-Cmdlet$Cmdlet-LevelInfo-Message$Message

}

try
{

$SQLBulkCopy.WriteToServer($Datatable)

}
catch
{

$Message="$($PSItem.Exception.Message)"
Write-Error$Message
Write-PWPSLog-Cmdlet$Cmdlet-Message$Message-LevelError

$Message="Error bulk copying table."
Write-Error$Message
Write-PWPSLog-Cmdlet$Cmdlet-Message$Message-LevelError

return;

}

$Message="Successfully performed bulk copy."
Write-Verbose$Message

if($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent)
{

Write-PWPSLog-Cmdlet$Cmdlet-LevelInfo-Message$Message

}

#endregion Bulk Copy table

}

}

functionGet-SQLDatabase
{

<#
.SYNOPSIS
Returns databases in a SQL instance.
.DESCRIPTION
Returns either all databases or a specified database from the SQL Server specified in New-SQLConnection.
.PARAMETER SQLConnection
SQL Server connection generated using New-SQLConnection.
.PARAMETER Database
Optional parameter to specify the name of database within the SQL Server instance to return. If not specified, all databases within the SQL Server instance will be returned.
.EXAMPLE
This example will return all databases in the SQL instance SQLONE.
$SQLConnection = New-SQLConnection -SQLServer 'SQLONE' -WindowsAuthentication
Get-SQLDatabase -SQLConnection $SQLConnection
.EXAMPLE
This example will return the database object for DATABASEONE from the SQL instance SQLONE.
$SQLConnection = New-SQLConnection -SQLServer 'SQLONE' -WindowsAuthentication
Get-SQLDatabase -SQLConnection $SQLConnection -Database "DATABASEONE"
#>

[CmdletBinding()]

Param
(

[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[Microsoft.SqlServer.Management.Common.ConnectionManager]$SQLConnection,

[Parameter(Mandatory=$false)]
[ValidateNotNullOrEmpty()]
[string]$Database

)

Begin
{

#region Startup

$Cmdlet='Get-SQLDatabase'

#endregion Startup

}
Process
{