msgDSM7Module

1.0.4.2

msgDSM7Module.psm1

<#
.SYNOPSIS
    msg powershell Module fuer die SOAP Schnittstelle fuer Ivanti DSM (Version 7.0 - 2023.1)
.DESCRIPTION
     msg powershell Module fuer die SOAP Schnittstelle fuer Ivanti DSM (Version 7.0 - 2023.1)
.NOTES
    File Name : msgDSM7Module.psm1
    Author : Raymond von Wolff, Uwe Franke
    Version : 1.0.4.2
    Requires : PowerShell V5.1
    History : https://github.com/uwefranke/msgDSM7Module/blob/master/CHANGELOG.md
    Help : https://github.com/uwefranke/msgDSM7Module/blob/master/docs/about_msgDSM7Module.md
.LINK
        https://github.com/uwefranke/msgDSM7Module
.LINK
        https://www.powershellgallery.com/packages/msgDSM7Module
.LINK
        https://www.msg-services.de
.LINK
        https://www.ivanti.com
#>
###############################################################################
# Allgemeine Variablen
$DSM7requiredVersion = "7.0" # benoetigte DSM Version 7.0 oder hoeher
$DSM7testedVersion = "7.5.2.0" # hoechste getestet DSM Version mit diesem Modul
$DSM7Targets = "(|(SchemaTag=Domain)(SchemaTag=OU)(SchemaTag=Computer)(SchemaTag=User)(SchemaTag=CitrixFarm)(SchemaTag=CitrixZone)(SchemaTag=Group)(SchemaTag=ExternalGroup)(SchemaTag=DynamicGroup))"
$DSM7Structure = "(|(SchemaTag=Domain)(SchemaTag=OU)(SchemaTag=CitrixFarm)(SchemaTag=CitrixZone)(SchemaTag=Group)(SchemaTag=DynamicGroup)(SchemaTag=SwFolder)(SchemaTag=SwLibrary)(SchemaTag=DynamicSwCategory)(SchemaTag=SwCategory))"
$DSM7Container = "(|(SchemaTag=Domain)(SchemaTag=OU)(SchemaTag=CitrixFarm)(SchemaTag=CitrixZone)(SchemaTag=SwFolder)(SchemaTag=SwLibrary)(SchemaTag=DynamicSwCategory)(SchemaTag=SwCategory))"
$DSM7StructureComputer = "(|(SchemaTag=Domain)(SchemaTag=OU)(SchemaTag=CitrixFarm)(SchemaTag=CitrixZone)(SchemaTag=Group)(SchemaTag=DynamicGroup))"
$DSM7StructureSoftware = "(|(SchemaTag=SwFolder)(SchemaTag=SwLibrary)(SchemaTag=DynamicSwCategory)(SchemaTag=SwCategory))"
$global:DSM7GenTypeData = "ModifiedBy,CreatedBy,Modified,Created"
$DSM7RegPath = "HKEY_LOCAL_MACHINE\SOFTWARE\NetSupport\NetInstall"
$DSM7ExportNCP = "NcpExport.exe"
$DSM7ExportNCPXML = "NcpExport.xml"
$DSM7NCPfile = "NiCfgSrv.ncp"
###############################################################################
# Allgemeine interne Funktionen
function Get-PSCredential {
    [CmdletBinding()] 
    param ($User, $Password)
    $SecPass = convertto-securestring -asplaintext -string $Password -force
    $Creds = new-object System.Management.Automation.PSCredential -argumentlist $User, $SecPass
    return $Creds
}
###############################################################################
# Allgemeine externe Funktionen
function Write-Log {
    <#
    .SYNOPSIS
        eigene Log Funktion
    .DESCRIPTION
        eigene Log Funktion
    .EXAMPLE
        Write-Log 0 "Text" $MyInvocation.MyCommand
    .NOTES
    .LINK
        Write-Log
    .LINK
        Remove-Log
    #>
    [CmdletBinding()] 
    param ([int]$typ, [system.String]$message, [system.String]$Name)
    $typs = @("Info ", "Warning", "Error ")
    $dt = Get-Date -format "yyyy-MM-dd HH:mm:ss"
    $strtyp = $typs[$typ]
    $global:LogMessage = "[$Name] - $message"
    $global:LogMessageTyp = $strtyp
    $LogMessageStr = "$dt - $strtyp - [$Name] - $message"
    if (!$Ochestrator) {
        if (!$DSM) {
            switch ($typ) {
                0 { Write-Host $LogMessageStr }
                1 { Write-Host $LogMessageStr -ForegroundColor Yellow }
                2 { Write-Host $LogMessageStr -ForegroundColor Red }
            }
        }
        else {
            switch ($typ) {
                0 { write-nireport $LogMessage }
                1 { write-nireport $LogMessage }
                2 { Set-NIError $LogMessage }
            }
        }
    }
    if ($logfile) {
        echo $LogMessageStr >> $logfile
    }
}
Export-ModuleMember -Function Write-Log
function Remove-Log {
    <#
    .SYNOPSIS
        eigene Log Funktion
    .DESCRIPTION
        eigene Log Funktion
    .EXAMPLE
        Remove-Log -CountLogFiles 10 -DaysLogFilesAge 30 -Logpath "c:\Logs" -Logname "Test"
    .NOTES
    .LINK
        Write-Log
    .LINK
        Remove-Log
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [system.String]$Logpath, 
        [Parameter(Position = 1, Mandatory = $true)]
        [system.String]$Logname,
        [int]$CountLogFiles = 0, 
        [int]$DaysLogFilesAge = 0
    )
    $DateLogFiles = (Get-Date).AddDays(-$DaysLogFilesAge)
    Write-Log 0 "Loesche alle Datei(en), behalte die letzen $CountLogFiles,aelter $DaysLogFilesAge und enthaelt im Namen $Logname befindet sich im Path $Logpath" $MyInvocation.MyCommand
    try { 
        $filestodelete = Get-ChildItem $logpath -Recurse | Where-Object { $_.Name -like "$Logname*" } 
        if ($DaysLogFilesAge -gt 0) {
            $filestodelete = $filestodelete | Where-Object { $_.LastWriteTime -lt $DateLogFiles }
            Write-Log 0 "Loesche $($filestodelete.count) Datei(en) die aelter als $DaysLogFilesAge Tage sind." $MyInvocation.MyCommand
            $filestodelete | Remove-Item -Force -Verbose
            $filestodelete = Get-ChildItem $logpath -Recurse | Where-Object { $_.Name -like "$Logname*" } 
        }
        if ($filestodelete.Count -gt $CountLogFiles -and $CountLogFiles -gt 0) {
            $filestodelete = $filestodelete | sort LastWriteTime -Descending | select -Last ($filestodelete.Count - $CountLogFiles)
            Write-Log 0 "Loesche $($filestodelete.count) Datei(en) ueber der Anzahl $CountLogFiles." $MyInvocation.MyCommand
            $filestodelete | Remove-Item -Force -Verbose
        }
        return $true
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
Export-ModuleMember -Function Remove-Log
function Convert-ToFilename {
    param(
        $filename
    )
    $filename = $filename.Replace("/", "_")
    $filename = $filename.Replace("\", "_")
    $filename = $filename.Replace(";", "_")
    $filename = $filename.Replace(",", "_")
    return $filename
}
function Test-RegistryValue {
    param (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]$Path,
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]$Value
    )
    try {
        Get-ItemProperty -Path $Path | Select-Object -ExpandProperty $Value -ErrorAction Stop | Out-Null
        Write-Log 0 "Value ($Value) found" $MyInvocation.MyCommand 
        return $true
    }
    catch {
        Write-Log 1 "Value ($Value) not found!" $MyInvocation.MyCommand 
        return $false
    }
}
function Remove-Files {
    <#
    .SYNOPSIS
        function to remove files
    .DESCRIPTION
        function to remove files
    .EXAMPLE
        Remove-Files -CountFiles 10 -DaysFilesAge 30 -Filepath "c:\Logs" -Filename "Test"
    .NOTES
    .LINK
        Remove-Files
    .LINK
        Remove-Files
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [system.String]$Filepath, 
        [Parameter(Position = 1, Mandatory = $true)]
        [system.String]$Filename,
        [int]$CountFiles = 0, 
        [int]$DaysFilesAge = 0
    )
    $DateFiles = (Get-Date).AddDays(-$DaysFilesAge)
    Write-Log 0 "Delete all file(s), keep the last $CountFiles, older then $DaysFilesAge and file name contains ($filename) in path ($Filepath)." $MyInvocation.MyCommand
    try { 
        $filestodelete = Get-ChildItem $Filepath -Recurse | Where-Object { $_.Name -like "$filename*" } 
        if ($DaysFilesAge -gt 0) {
            $filestodelete = $filestodelete | Where-Object { $_.LastWriteTime -lt $DateFiles }
            Write-Log 0 "Delete $($filestodelete.count) file(s), older then $DaysFilesAge day(s)." $MyInvocation.MyCommand
            $filestodelete | Remove-Item -Force -Verbose:$Verbose
            $filestodelete = Get-ChildItem $Filepath -Recurse | Where-Object { $_.Name -like "$filename*" } 
        }
        if ($filestodelete.Count -gt $CountFiles -and $CountFiles -gt 0) {
            $filestodelete = $filestodelete | Sort-Object LastWriteTime -Descending | select-object -Last ($filestodelete.Count - $CountFiles)
            Write-Log 0 "Delete $($filestodelete.count) file(s) more then count ($CountFiles)." $MyInvocation.MyCommand
            $filestodelete | Remove-Item -Force -Verbose:$Verbose
        }
        return $true
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function remove-XMLSpecialChar {
    param (
        $file
    )
    $temp = (Get-Content -path $file ) -join "`r"
    $temp = $temp | foreach { $_ -replace "`n|`r" }
    # $temp = $temp -replace "[^\u0000-\u007F]+"
    $temp = $temp -replace "\x04"
    $temp = $temp -replace "\x05"
    $temp = $temp -replace "\x06"
    $temp = $temp -replace "\x1d"
    $temp = $temp -replace "<\?xml version=`"1.0`" encoding=`"UTF-8`"\?>" , "<?xml version=`"1.0`" encoding=`"UTF-8`"?>`n"
    Set-Content -path $file -Value $temp -Force
    $temp = ""
    return $true
}
function Get-RegistryValue {
    param (
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]$Path,
        [parameter(Mandatory = $true)]
        [ValidateNotNullOrEmpty()]$Value
    )
    try {
        $Item = (Get-ItemProperty -Path $Path | Select-Object $Value).$Value
        Write-Log 0 "Value ($Value): ($Item)" $MyInvocation.MyCommand 
        return $Item
    }
    catch {
        Write-Log 1 "cant read Value ($Value)!" $MyInvocation.MyCommand 
        return $false
    }
}
function Convert-StringtoPSRegKey {
    param (
        $KeyPath,
        [switch]$is32Bit
    )
    $KeyPath = $KeyPath -replace ("HKLM\\", "HKLM:\\")
    $KeyPath = $KeyPath -replace ("HKU\\", "HKU:\\")
    $KeyPath = $KeyPath -replace ("HKEY_LOCAL_MACHINE\\", "HKLM:\\")
    $KeyPath = $KeyPath -replace ("HKEY_USERS\\", "HKU:\\")
    if ($is32Bit -and [Environment]::Is64BitProcess -and $KeyPath -like "HKLM:\\SOFTWARE*") {
        $KeyPath = $KeyPath -replace ("HKLM:\\\\SOFTWARE", "HKLM:\\SOFTWARE\WOW6432Node")

    }
    return $KeyPath
}
function Convert-ArrayToHash {
    <#
    .SYNOPSIS
        konvertiert eine Array zu einem Hash mit Keylist
    .DESCRIPTION
        konvertiert eine Array zu einem Hash mit Keylist
    .EXAMPLE
        Convert-ArrayToHash Array Key
    .NOTES
    .LINK
    #>
    [CmdletBinding()] 
    param (
        $myArray,
        $myKey
    )
    $myHash = @{}
    $myArray | foreach { $myHash[$_.$myKey] = $_ }
    return $myHash
}
Export-ModuleMember -Function Convert-ArrayToHash
function Confirm-Creds {
    <#
    .SYNOPSIS
        ueberprueft die Benutzerinformationen und ggf. Passwortabfrage
    .DESCRIPTION
        ueberprueft die Benutzerinformationen und ggf. Passwortabfrage
    .EXAMPLE
        Confirm-Creds -User Benutzer -Password *******
    .NOTES
    .LINK
    #>
    [CmdletBinding()] 
    param (
        $Domain,
        $User,
        $Password
    )
    if (!$Domain) {
        if (!$User) {
            $User = Read-Host "Bitte Benutzer eingeben (Domain\Benutzer):" 
        }
        else {
            if ($User.Contains("\") -or $User.Contains("@")) {
                Write-Log 0 "Benutzer ist: $User" $MyInvocation.MyCommand
            }
            else { 
                $User = Read-Host "Bitte Benutzer eingeben (Domain\Benutzer):" 
            }
            if ($User.Contains("\")) {
                $Domain = $User.Split("\")[0]
                $User = $User.Split("\")[1]
            }
            if ($User.Contains("@")) {
                $Domain = $User.Split("@")[1]
                $User = $User.Split("@")[0]
            }
        }
    }
    else {
        if (!$User) {
            $User = Read-Host "Bitte Benutzer eingeben (Benutzer)"
        }
    } 
    if (!$Password) {
        $Password = Read-Host "Bitte Passwort fuer ($Domain\$User) eingeben" -AsSecureString 
    }
    else {
        $Password = convertto-securestring -asplaintext -string $Password -force
    }
    $DomainUser = "$Domain\$User"
    $cred = new-object -typename System.Management.Automation.PSCredential -argumentlist $DomainUser, $Password
    return $cred
}
Export-ModuleMember -Function Confirm-Creds
###############################################################################
# DSM7 Funktionen - allgemein
function Connect-DSM7Web { 
    <#
    .SYNOPSIS
        Stellt Verbindung zur SOAP Schnittstelle von HEAT Software DSM7 her.
    .DESCRIPTION
        Stellt Verbindung zur SOAP Schnittstelle von HEAT Software DSM7 her.
    .EXAMPLE
        Connect-DSM7Web -WebServer "DSM7 BLS" -UseDefaultCredential
    .EXAMPLE
        Connect-DSM7Web -WebServer "DSM7 BLS" -UseSSL -UseDefaultCredential
    .EXAMPLE
        Connect-DSM7Web -WebServer "DSM7 BLS" -Port 8080 -User "Domuene\Benutzer" -UserPW "******"
    .EXAMPLE
        Connect-DSM7Web -WebServer "DSM7 BLS" -Port 8080 -Credential PSCredential
    .NOTES
    .LINK
        Connect-DSM7Web
    .LINK
        Connect-DSM7WebRandom
    #>
    [CmdletBinding()] 
    param (
        [System.String]$WebServer = "localhost",
        [System.String]$Port,
        [switch]$UseSSL = $false,
        [switch]$UseDefaultCredential = $false,
        [System.String]$User,
        [System.String]$UserPW,
        $Credential
    )
    if ($UseSSL) {
        $Protocol = "https://"
        if (!$Port) { 
            $Port = "443"
        }
    }
    else {
        $Protocol = "http://"
        if (!$Port) { 
            $Port = "8080"
        }
    }
    $DSM7wsdlURL = $Protocol + $WebServer + ":" + $Port + "/blsAdministration/AdministrationService.asmx?WSDL" 
    $global:DSM7Types = @{} 
    try {
        Write-Log 0 "Verbinde zu $DSM7wsdlURL." $MyInvocation.MyCommand
        Write-Log 0 "Powershell Version: $($Host.Version)" $MyInvocation.MyCommand
        if ($UseDefaultCredential) {
            $global:DSM7WebService = New-WebServiceProxy -uri $DSM7wsdlURL -UseDefaultCredential -ErrorAction:Stop 
            Write-Log 0 "Verbinde mit Benutzer ($(whoami))." $MyInvocation.MyCommand
        }
        else {
            if (!$Credential) {
                if ($User) {
                    $Credential = Confirm-Creds -User $User -Password $UserPw
                }
                else {
                    return $false
                }
            } 
            else {
                if (!($Credential -is [PSCredential])) {
                    $Credential = Confirm-Creds -User $Credential 
                }
            }
            $global:DSM7WebService = New-WebServiceProxy -uri $DSM7wsdlURL -Credential $Credential -ErrorAction:Stop 
            $DSM7WebService.Credentials = $Credential
            Write-Log 0 "Verbinde mit Benutzer $($Credential.Username)." $MyInvocation.MyCommand
        }
        Write-Log 0 "Module Name : $($MyInvocation.MyCommand.Module.Name)" $MyInvocation.MyCommand
        Write-Log 0 "Module Version: $($MyInvocation.MyCommand.Module.Version)" $MyInvocation.MyCommand
        if ($global:DSM7WebService) {
            foreach ($Type in $DSM7WebService.GetType().Assembly.GetExportedTypes()) { 
                $global:DSM7Types.Add($Type.Name, $Type.FullName) 
            }
            $DSM7ServerInfo = Get-DSM7ServerInfo
            if ($DSM7ServerInfo) {
                $global:DSM7Version = $DSM7ServerInfo.CmdbVersionString
                Write-Log 0 "Verbindung hergestellt." $MyInvocation.MyCommand 
                Write-Log 0 "CmdbGuid = $($DSM7ServerInfo.CmdbGuid)" $MyInvocation.MyCommand 
                Write-Log 0 "CmdbVersionString = $DSM7Version" $MyInvocation.MyCommand 
                Write-Log 0 "MetaModelVersion = $($DSM7ServerInfo.MetaModelVersion)" $MyInvocation.MyCommand 
                if ($DSM7Version -lt $DSM7requiredVersion) {
                    Write-Log 2 "DSM Version wird nicht unterstuetzt!!!" $MyInvocation.MyCommand 
                    return $false
                }
                if ($DSM7Version -gt $DSM7testedVersion) {
                    Write-Log 1 "DSM Version ($DSM7Version) nicht getestet!!! Einige Funktionen koennten nicht mehr richtige Ergebnisse liefern oder gar nicht mehr funktionieren!!!" $MyInvocation.MyCommand 
                }
                if ($DSM7Version -gt "7.4.0") {
                    $global:DSM7GenTypeData = "$DSM7GenTypeData,CreationSource"
                } 
                Write-Log 0 "SOAP Verbindung erfolgreich hergestellt. ($DSM7wsdlURL)" $MyInvocation.MyCommand 
                return $true
            }
            else {
                Write-Log 2 "keine Verbindung" $MyInvocation.MyCommand 
                return $false
            }
        }
        else {
            Write-Log 2 "keine Verbindung" $MyInvocation.MyCommand 
            return $false
        }
    }
    catch [System.Net.WebException] {
        Write-Log 2 "keine Verbindung" $MyInvocation.MyCommand 
        $global:DSM7WebService = $false
    } 
    catch {
        Write-Log 2 "Verbindungsfehler: $_ $($_.Exception.Message)" $MyInvocation.MyCommand 
        $global:DSM7WebService = $false
    }
}
Export-ModuleMember -Function Connect-DSM7Web -Variable DSM7WebService, DSM7Types
function Connect-DSM7WebRandom {
    <#
    .SYNOPSIS
        Stellt Verbindung zur SOAP Schnittstelle von HEAT Software DSM7 her, mit einen BSL Server der zufoallig ausgewaehlt wird.
    .DESCRIPTION
        Stellt Verbindung zur SOAP Schnittstelle von HEAT Software DSM7 her, mit einen BSL Server der zufaellig ausgewaehlt wird.
    .EXAMPLE
        Connect-DSM7WebRandom -WebServer "DSM7 BLS" -UseDefaultCredential
    .EXAMPLE
        Connect-DSM7WebRandom -WebServer "DSM7 BLS" -Port 8080 -User "Domaene\Benutzer" -UserPW "******"
    .EXAMPLE
        Connect-DSM7WebRandom -WebServer "DSM7 BLS" -Port 8080 -Credential PSCredential
    .NOTES
    .LINK
        Connect-DSM7Web
    .LINK
        Connect-DSM7WebRandom
    #>
    [CmdletBinding()] 
    param (
        [System.String]$WebServer = "localhost",
        [System.String]$Port = "8080",
        [switch]$UseSSL = $false,
        [switch]$UseDefaultCredential = $false,
        [System.String]$User,
        [System.String]$UserPW,
        $Credential
    )
    if ($UseDefaultCredential) {
        $SOAP = Connect-DSM7Web -WebServer $WebServer -Port $Port -UseSSL:$UseSSL -UseDefaultCredential
    }
    else { 
        if (!$Credential) {
            if ($User) {
                $Credential = Confirm-Creds -User $User -Password $UserPw
            }
            else {
                return $false
            }
        } 
        $SOAP = Connect-DSM7Web -WebServer $WebServer -Port $Port -UseSSL:$UseSSL -Credential $Credential
    }
    if ($SOAP) {
        $AllBLS = Get-DSM7ComputerList -Filter "(BasicInventory.InfrastructureRole:IgnoreCase=BLS)" -Attributes "BasicInventory.FullQualifiedName"
        Write-Log 0 "Anzahl der gefunden BLS Server = $($AllBLS.count)" $MyInvocation.MyCommand 
        $BLSrandom = Get-Random -Maximum $AllBLS.count
        if ($AllBLS[$BLSrandom]."BasicInventory.FullQualifiedName" -ne $BLSServer) {
            DisConnect-DSM7Web
            $BLSServer = $AllBLS[$BLSrandom]."BasicInventory.FullQualifiedName"
            Write-Log 0 "Neuer BLS Server = $BLSServer" $MyInvocation.MyCommand 
            if ($User) {
                $SOAP = Connect-DSM7Web -WebServer $BLSServer -Port $Port -UseSSL:$UseSSL -Credential $Credential
            }
            else {
                $SOAP = Connect-DSM7Web -WebServer $BLSServer -Port $Port -UseSSL:$UseSSL -UseDefaultCredential
            }
        } 
    }
}
Export-ModuleMember Connect-DSM7WebRandom
function DisConnect-DSM7Web {
    <#
    .SYNOPSIS
        Verbindung trennen.
    .DESCRIPTION
        Verbindung trennen.
    .EXAMPLE
        DisConnect-DSM7Web
    .NOTES
    .LINK
     
    #>
    $global:DSM7Types = $null
    $global:DSM7WebService = $null 
    $global:DSM7Version = $null
    $global:DSM7Version = $null
    $global:DSM7AssociationSchemaList = $null
    $global:DSM7PropGroupDefList = $null
    Write-Log 0 "Verbindung getrennt." $MyInvocation.MyCommand 
    return $true
}
Export-ModuleMember -Function DisConnect-DSM7Web

function Get-DSM7RequestHeader ($action) {
    $action = $action + "Request" 
    $Webrequest = New-Object $DSM7Types[$action] 
    if ($DSM7Version -gt "7.3.2" -and $Webrequest.MaxResults -eq 0) {
        $Webrequest.MaxResults = -1
    }
    $Webrequest.Header = New-Object $DSM7Types["RequestHeader"] 
    $Webrequest.Header.UserCulture = $Host.CurrentCulture
    $Webrequest.Header.ClientInfo = New-Object $DSM7Types["ClientInfo"] 
    $Webrequest.Header.ClientInfo.Name = $Host.Name 
    $Webrequest.Header.ClientInfo.Version = $Host.Version 
    $Webrequest.ServerInfo = New-Object $DSM7Types["ServerInfo"] 
    $Webrequest.ServerInfo.CmdbGuid = { 0000000 - 0000 - 0000 - 0000 - 000000000000 } 
    $Webrequest.ServerInfo.MetaModelVersion = 203 
    return $Webrequest 
} 
function Get-DSM7ServerInfo {
    [CmdletBinding()] 
    param (
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "GetServerInfo"
        $Webresult = $DSM7WebService.GetServerInfo($Webrequest).ServerInfo
        if ($Webresult) {
            Write-Log 0 "GetServerInfo erfolgreich." $MyInvocation.MyCommand
            return $Webresult
        }
        else {
            Write-Log 2 "GetServerInfo nicht gefunden!" $MyInvocation.MyCommand 
            return $false
        }
    }
    catch [System.Web.Services.Protocols.SoapException] {
        Write-Log 2 $_.Exception.Detail.Message.'#text' $MyInvocation.MyCommand 
        return $false 
    } 
    catch {
        Write-Log 2 $MyInvocation.MyCommand 
        return $false 
    } 

}
function Get-DSM7IdentifiedUser {
    [CmdletBinding()] 
    param (
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "GetIdentifiedUser"
        $Webresult = $DSM7WebService.GetIdentifiedUser($Webrequest)
        if ($Webresult) {
            Write-Log 0 "GetIdentifiedUser erfolgreich." $MyInvocation.MyCommand
            return $Webresult
        }
        else {
            Write-Log 2 "GetIdentifiedUser nicht gefunden!" $MyInvocation.MyCommand 
            return $false
        }
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function Confirm-Connect {
    if (!$DSM7WebService) {
        Write-Log 1 "Keine Verbindung zum Webserver (SOAP)!!!`n`t`t`t`tBitte die Funktion `"Connect-DSM7Web`" fuer die Verbindung benutzen,`n`t`t`t`toder es ist ein Fehler beim verbinden aufgetreten." $MyInvocation.MyCommand
        return $false
    }
    else {
        return $true
    }
}
function Find-DSM7Target {
    [CmdletBinding()] 
    param (
        [System.int32]$ID,
        [System.String]$Name,
        [System.String]$LDAPPath,
        [System.int32]$ParentContID
    )
    if ($ID) {
        $Target = (Get-DSM7ObjectList -Filter "(&(ObjectId=$ID)$DSM7Targets)")
    }
    else { 
        if ($ParentContID) {
            $Target = (Get-DSM7ObjectList -Filter "(&(Name:IgnoreCase=$Name)$DSM7Targets)" -ParentContID $ParentContID)
        }
        else {
            $Target = (Get-DSM7ObjectList -Filter "(&(Name:IgnoreCase=$Name)$DSM7Targets)" -LDAPPath $LDAPPath)
        }
    }
    if ($Target) {
        if ($Target.BasePropGroupTag -eq "OrgTreeContainer") {
            $TargetObject = Get-DSM7OrgTreeContainer -ID $Target.ID 
        }
        else {
            $TargetObject = Get-DSM7ObjectObject -ID $Target.ID
        }
        write-log 0 "TargetObject mit ID($($TargetObject.ID)) gefunden." $MyInvocation.MyCommand
        return $TargetObject
    }
    else {
        write-log 1 "TargetObject nicht gefunden!" $MyInvocation.MyCommand
        return $false
    }
}
###############################################################################
# DSM7 Funktionen - Convert
###############################################################################
function Convert-StringtoLDAPString ($String) {
    if ($String.contains("\")) { $String = $String.Replace("\", "\\") }
    if ($String.Contains("(") -or $String.Contains(")") ) {
        $String = $String.Replace("(", "\(")
        $String = $String.Replace(")", "\)")
    }
    return $String
}
function Convert-LDAPStringToReplaceString ($String) {
    if ($String.contains("\(")) { $String = $String.Replace("\(", "\+") }
    if ($String.Contains("\)")) { $String = $String.Replace("\)", "\-") }
    return $String
}
function Convert-ReplaceStringToLDAPString ($String) {
    if ($String.contains("\+")) { $String = $String.Replace("\+", "\(") }
    if ($String.Contains("\-")) { $String = $String.Replace("\-", "\)") }
    return $String
}

function Convert-DSM7ObjectListtoPSObject {
    [CmdletBinding()] 
    param ( 
        $ObjectList,
        [switch]$LDAP = $false
    )
    $DSM7ObjectMembers = ($ObjectList[0] | Get-Member -MemberType Properties).Name
    foreach ($DSM7Object in $ObjectList) {
        $Raw = Convert-DSM7ObjecttoPSObject -DSM7Object $DSM7Object -DSM7ObjectMembers $DSM7ObjectMembers -LDAP:$LDAP
        $DSM7ObjectList += @($Raw)
    }
    return $DSM7ObjectList
}
function Convert-DSM7ObjectListtoPSObjectID {
    [CmdletBinding()] 
    param ( 
        $ObjectList,
        [switch]$LDAP = $false
    )
    $DSM7ObjectList = @{}
    $DSM7ObjectMembers = ($ObjectList | Get-Member -MemberType Properties).Name
    foreach ($DSM7Object in $ObjectList) {
        $Raw = Convert-DSM7ObjecttoPSObject -DSM7Object $DSM7Object -DSM7ObjectMembers $DSM7ObjectMembers -LDAP:$LDAP
        $DSM7ObjectList[$DSM7Object.ID] = @($Raw)
    }
    return $DSM7ObjectList
}
function Convert-DSM7ObjecttoPSObject {
    [CmdletBinding()] 
    param ( 
        $DSM7Object,
        $DSM7ObjectMembers,
        [switch]$LDAP = $false
    )
    if (!$DSM7ObjectMembers) {
        $DSM7ObjectMembers = ($DSM7Object | Get-Member -MemberType Properties).Name
    }
    $Raw = New-Object PSObject
    foreach ($DSM7ObjectMember in $DSM7ObjectMembers) {
        if ($DSM7ObjectMember -ne "GenTypeData" -and $DSM7ObjectMember -ne "TargetObjectList" -and $DSM7ObjectMember -ne "PropGroupList") {
            if ($DSM7ObjectMember -like "*List") {
                $DSM7ObjectMemberLists = $DSM7Object.$DSM7ObjectMember
                if ($DSM7ObjectMemberLists.Count -gt 0) {
                    $DSM7ObjectMemberListsMembers = ($DSM7ObjectMemberLists | Get-Member -MemberType Properties).Name
                    foreach ($DSM7ObjectMemberListsMember in $DSM7ObjectMemberListsMembers) {
                        for ($I = 0; $I -lt $($DSM7ObjectMemberLists.Count) - 1; $I++) {
                            if ($DSM7ObjectMemberListsMember -eq "GenTypeData") {
                                foreach ($GenTypeData in $($DSM7ObjectMemberLists[$I].GenTypeData | get-member -membertype properties)) { 
                                    add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
                                }
                            } 
                            else {
                                add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.$DSM7ObjectMemberListsMember" -Value $DSM7ObjectMemberLists.$DSM7ObjectMemberListsMember[$I]
                            }
                        }
                    }
                }
                else {
                    add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember

                }
            }
            else {
                add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember

            }
        } 
    }

    if ($DSM7Object.GenTypeData) {
        foreach ($GenTypeData in $($DSM7Object.GenTypeData | get-member -membertype properties)) { 
            add-member -inputobject $Raw -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
        }
    }
    if ($LDAP) {
        $LDAPPath = Get-DSM7LDAPPath $DSM7Object.ParentContID
        add-member -inputobject $Raw -MemberType NoteProperty -name LDAPPath -Value $LDAPPath
    } 
    if ($DSM7Object.PropGroupList) {
        foreach ($PropGroup in $DSM7Object.PropGroupList) {
            $Groupname = $PropGroup.Tag
            foreach ($Prop in $PropGroup.PropertyList) {
                $TypedValue = $Prop.TypedValue
                if ($Prop.Type -eq "CatalogLink" -and $TypedValue -and $LDAP) {
                    add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag).Name" -Value (Get-DSM7ObjectObject -ID $TypedValue -ObjectGroupType "Catalog" ).Name
                }
                if ($TypedValue -and $TypedValue.GetType().Name -eq "MdsVersion") {
                    add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag)" -Value $Prop.TypedValue.Version
                }
                else {
                    add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag)" -Value $Prop.TypedValue
                } 
            }
        }
    } 
    return $Raw
}

function Convert-DSM7AssociationListtoPSObject {
    [CmdletBinding()] 
    param ( 
        $ObjectList,
        [switch]$resolvedName = $false
    )
    $IDs = @()
    $IDs += ($ObjectList | Select-Object -ExpandProperty SourceObjectID)
    $IDs += ($ObjectList | Select-Object -ExpandProperty TargetObjectID)
    $IDs = $IDs | Get-Unique
    $DSM7Objects = @()
    $DSM7Objects += Get-DSM7ObjectsObject -IDs $IDs
    $DSM7Objects += Get-DSM7ObjectsObject -IDs $IDs -ObjectGroupType "Catalog"
    $DSM7Objects = Convert-DSM7ObjectListtoPSObjectID ($DSM7Objects)
    foreach ($DSM7Object in $ObjectList) {
        $DSM7Object = Convert-DSM7AssociationtoPSObject -DSM7Object $DSM7Object -DSM7Objects $DSM7Objects -resolvedName:$resolvedName
        $DSM7ObjectList += @($DSM7Object)
    }
    return $DSM7ObjectList
}
function Convert-DSM7AssociationtoPSObject {
    [CmdletBinding()] 
    param ( 
        $DSM7Object,
        $DSM7Objects,
        [switch]$resolvedName = $false
    )
    $Raw = New-Object PSObject
    add-member -inputobject $Raw -MemberType NoteProperty -name ID -Value $DSM7Object.ID
    add-member -inputobject $Raw -MemberType NoteProperty -name SchemaTag -Value $DSM7Object.SchemaTag
    add-member -inputobject $Raw -MemberType NoteProperty -name SourceObjectID -Value $DSM7Object.SourceObjectID
    add-member -inputobject $Raw -MemberType NoteProperty -name TargetObjectID -Value $DSM7Object.TargetObjectID
    add-member -inputobject $Raw -MemberType NoteProperty -name TargetSchemaTag -Value $DSM7Object.TargetSchemaTag
    if ($DSM7Object.PropGroupList) {
        foreach ($PropGroup in $DSM7Object.PropGroupList) {
            $Groupname = $PropGroup.Tag
            foreach ($Prop in $PropGroup.PropertyList) {
                $TypedValue = $Prop.TypedValue
                # if ($Prop.Type -eq "CatalogLink" -and $TypedValue) {
                # add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag).Name" -Value (Get-DSM7ObjectObject -ID $TypedValue -ObjectGroupType "Catalog" ).Name
                # }
                add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag)" -Value $Prop.TypedValue
            }
        }
    }
    if ($resolvedName) {
        $SourceObjectName = $DSM7Objects.item($Raw.SourceObjectID)[0].Name 
        $TargetObjectName = $DSM7Objects.item($Raw.TargetObjectID)[0].Name 
        add-member -inputobject $Raw -MemberType NoteProperty -name SourceObjectName -Value $SourceObjectName
        add-member -inputobject $Raw -MemberType NoteProperty -name TargetObjectName -Value $TargetObjectName
    }
    return $Raw
}
function Convert-DSM7PolicyListtoPSObject {
    [CmdletBinding()] 
    param ( 
        $ObjectList,
        [switch]$resolvedName = $false
    ) 
    if ($resolvedName) {
        $IDs = @() 
        $IDs += ($ObjectList | Select-Object -ExpandProperty AssignedObjectID)
        $DSM7Objects = Get-DSM7ObjectsObject -IDs $IDs
        $DSM7ObjectsTargetIDs = $ObjectList | Select-Object -ExpandProperty TargetObjectList | Select-Object -ExpandProperty TargetObjectID -Unique
        foreach ($DSM7ObjectsTargetID in $DSM7ObjectsTargetIDs) {
            $filter = "$filter(ObjectID=$DSM7ObjectsTargetID)"
        }
        $filter = "(|$filter)"
        $DSM7ObjectsTargets = Get-DSM7ObjectList -Filter $filter
    }
    $DSM7ObjectMembers = ($ObjectList[0] | Get-Member -MemberType Properties).Name
    foreach ($DSM7Object in $ObjectList) {
        $DSM7Object = Convert-DSM7PolicytoPSObject -DSM7Object $DSM7Object -DSM7ObjectMembers $DSM7ObjectMembers -DSM7Objects $DSM7Objects -DSM7ObjectsTargets $DSM7ObjectsTargets -resolvedName:$resolvedName
        $DSM7ObjectList += @($DSM7Object)
    }
    return $DSM7ObjectList
}
function Convert-DSM7PolicytoPSObject {
    [CmdletBinding()] 
    param ( 
        $DSM7Object,
        $DSM7ObjectMembers,
        $DSM7Objects,
        $DSM7ObjectsTargets,
        [switch]$resolvedName = $false
    )
    $AssignedObjectNameOld = "###"
    if (!$DSM7ObjectMembers) { $DSM7ObjectMembers = ($DSM7Object | Get-Member -MemberType Properties).Name }
    if ($resolvedName) {
        if (!$DSM7Objects) {
            $IDs = @() 
            $IDs += ($DSM7Object | Select-Object -ExpandProperty AssignedObjectID)
            $DSM7Objects = Get-DSM7ObjectsObject -IDs $IDs
        }
        if (!$DSM7ObjectsTargets) {
            $DSM7ObjectsTargetIDs = $DSM7Object | Select-Object -ExpandProperty TargetObjectList | Select-Object -ExpandProperty TargetObjectID -Unique
            foreach ($DSM7ObjectsTargetID in $DSM7ObjectsTargetIDs) {
                $filter = "$filter(ObjectID=$DSM7ObjectsTargetID)"
            }
            $filter = "(|$filter)"
            $DSM7ObjectsTargets = Get-DSM7ObjectList -Filter $filter
        }
    }

    $Raw = New-Object PSObject
    foreach ($DSM7ObjectMember in $DSM7ObjectMembers) {
        if ($DSM7ObjectMember -ne "GenTypeData" -and $DSM7ObjectMember -ne "TargetObjectList" -and $DSM7ObjectMember -ne "PropGroupList" -and $DSM7ObjectMember -ne "PolicyRestrictionList" -and $DSM7ObjectMember -ne "SwInstallationParameters") {
            if ($DSM7ObjectMember -like "*List") {
                $DSM7ObjectMemberLists = $DSM7Object.$DSM7ObjectMember
                if ($DSM7ObjectMemberLists.Count -gt 0) {
                    $DSM7ObjectMemberListsMembers = ($DSM7ObjectMemberLists | Get-Member -MemberType Properties).Name
                    foreach ($DSM7ObjectMemberListsMember in $DSM7ObjectMemberListsMembers) {
                        for ($I = 0; $I -lt $($DSM7ObjectMemberLists.Count) - 1; $I++) {
                            if ($DSM7ObjectMemberListsMember -eq "GenTypeData") {
                                foreach ($GenTypeData in $($DSM7ObjectMemberLists[$I].GenTypeData | get-member -membertype properties)) { 
                                    add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
                                }
                            } 
                            else {
                                add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.$DSM7ObjectMemberListsMember" -Value $DSM7ObjectMemberLists.$DSM7ObjectMemberListsMember[$I]
                            }
                        }
                    }
                }
                else {
                    add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember

                }
            }
            else {
                add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember
            }
        } 
    }
    if ($DSM7Object.GenTypeData) {
        foreach ($GenTypeData in $($DSM7Object.GenTypeData | get-member -membertype properties)) { 
            add-member -inputobject $Raw -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
        }
    }
    add-member -inputobject $Raw -MemberType NoteProperty -name "PolicyRestrictionList" -Value $DSM7Object.PolicyRestrictionList

    if ($resolvedName) {
        if ($AssignedObjectName -ne $AssignedObjectNameOld) {
            $AssignedObjectName = $($DSM7Objects | where { $_.ID -eq $Raw.AssignedObjectID }).Name 
            $AssignedObjectUniqueId = $($DSM7Objects | where { $_.ID -eq $Raw.AssignedObjectID }).UniqueId 
            $AssignedObjectSchemaTag = $($DSM7Objects | where { $_.ID -eq $Raw.AssignedObjectID }).SchemaTag
        }
        add-member -inputobject $Raw -MemberType NoteProperty -name AssignedObjectName -Value $AssignedObjectName
        add-member -inputobject $Raw -MemberType NoteProperty -name AssignedObjectSchemaTag -Value $AssignedObjectSchemaTag
        add-member -inputobject $Raw -MemberType NoteProperty -name AssignedObjectUniqueId -Value $AssignedObjectUniqueId 
        $AssignedObjectNameOld = $AssignedObjectName
    }

    if ($DSM7Object.SwInstallationParameters) {
        $SwInstallationParameterList = @()
        foreach ($SwInstallationParameter in $DSM7Object.SwInstallationParameters) {
            $SwInstallationParameterPSObject = New-Object PSObject
            $DSM7ObjectMemberListsMembers = ($DSM7Object.SwInstallationParameters | Get-Member -MemberType Properties).Name
            foreach ($DSM7ObjectMemberListsMember in $DSM7ObjectMemberListsMembers) {
                if ($DSM7ObjectMemberListsMember -eq "GenTypeData") {
                    foreach ($GenTypeData in $($SwInstallationParameter.GenTypeData | get-member -membertype properties)) { 
                        add-member -inputobject $SwInstallationParameterPSObject -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $SwInstallationParameter.GenTypeData.$($GenTypeData.Name)
                    }
                } 
                else {
                    add-member -inputobject $SwInstallationParameterPSObject -MemberType NoteProperty -name "$DSM7ObjectMemberListsMember" -Value $SwInstallationParameter.$DSM7ObjectMemberListsMember



                }
            }
            $SwInstallationParameterList += $SwInstallationParameterPSObject
        }

    }
    add-member -inputobject $Raw -MemberType NoteProperty -name "SwInstallationParameters" -Value $SwInstallationParameterList
    if ($DSM7Object.PropGroupList) {
        foreach ($PropGroup in $DSM7Object.PropGroupList) {
            $Groupname = $PropGroup.Tag
            foreach ($Prop in $PropGroup.PropertyList) {
                $TypedValue = $Prop.TypedValue
                if ($Prop.Type -eq "CatalogLink" -and $TypedValue -and $LDAP) {
                    add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag).Name" -Value (Get-DSM7ObjectObject -ID $TypedValue -ObjectGroupType "Catalog" ).Name
                }
                add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag)" -Value $Prop.TypedValue
            }
        }
    } 

    if ($DSM7Object.TargetObjectList) {
        $TargetObjectList = @()
        foreach ($TargetObject in $DSM7Object.TargetObjectList) {
            $TargetPSObject = New-Object PSObject
            if ($resolvedName) {
                $TargetObjectName = $($DSM7ObjectsTargets | where { $_.ID -eq $TargetObject.TargetObjectID }).Name 
                add-member -inputobject $TargetPSObject -MemberType NoteProperty -name TargetObjectName -Value $TargetObjectName
            }
            add-member -inputobject $TargetPSObject -MemberType NoteProperty -name TargetObjectID -Value $TargetObject.TargetObjectID
            $TargetObjectList += $TargetPSObject
        }
        add-member -inputobject $Raw -MemberType NoteProperty -name "TargetObjectList" -Value $TargetObjectList
    }
    return $Raw
}
function Convert-DSM7PolicyInstancetoPSObject {
    [CmdletBinding()] 
    param ( 
        $DSM7Object,
        $DSM7ObjectMembers,
        $DSM7Objects,
        $DSM7Configs,
        [switch]$resolvedName = $false
    )
    $AssignedObjectNameOld = "###"
    $Raw = New-Object PSObject
    foreach ($DSM7ObjectMember in $DSM7ObjectMembers) {
        if ($DSM7ObjectMember -ne "GenTypeData" -and $DSM7ObjectMember -ne "TargetObjectList") {
            if ($DSM7ObjectMember -like "*List") {
                $DSM7ObjectMemberLists = $DSM7Object.$DSM7ObjectMember
                if ($DSM7ObjectMemberLists.Count -gt 0) {
                    $DSM7ObjectMemberListsMembers = ($DSM7ObjectMemberLists | Get-Member -MemberType Properties).Name
                    foreach ($DSM7ObjectMemberListsMember in $DSM7ObjectMemberListsMembers) {
                        for ($I = 0; $I -lt $($DSM7ObjectMemberLists.Count) - 1; $I++) {
                            if ($DSM7ObjectMemberListsMember -eq "GenTypeData") {
                                foreach ($GenTypeData in $($DSM7ObjectMemberLists[$I].GenTypeData | get-member -membertype properties)) { 
                                    add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
                                }
                            } 
                            else {
                                add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.$DSM7ObjectMemberListsMember" -Value $DSM7ObjectMemberLists.$DSM7ObjectMemberListsMember[$I]
                            }
                        }
                    }
                }
                else {
                    add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember

                }
            }
            else {
                add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember
            }
        } 
    }
    if ($DSM7Version -gt "7.3.0") {
        $AssignedObjectID = $($DSM7Configs | where { $_.ID -eq $Raw.AssignedConfiguration }).SoftwareObjectID
        add-member -inputobject $Raw -MemberType NoteProperty -name AssignedObjectID -Value $AssignedObjectID
    } 

    if ($resolvedName) {
        if ($AssignedObjectName -ne $AssignedObjectNameOld) {
            $AssignedObjectName = $($DSM7Objects | where { $_.ID -eq $Raw.AssignedObjectID }).Name 
            $AssignedObjectSchemaTag = $($DSM7Objects | where { $_.ID -eq $Raw.AssignedObjectID }).SchemaTag 
            $AssignedObjectUniqueId = $($DSM7Objects | where { $_.ID -eq $Raw.AssignedObjectID }).UniqueId 
        }
        add-member -inputobject $Raw -MemberType NoteProperty -name AssignedObjectName -Value $AssignedObjectName
        add-member -inputobject $Raw -MemberType NoteProperty -name AssignedObjectSchemaTag -Value $AssignedObjectSchemaTag
        add-member -inputobject $Raw -MemberType NoteProperty -name AssignedObjectUniqueId -Value $AssignedObjectUniqueId 
        $AssignedObjectNameOld = $AssignedObjectName
        if ($DSM7Object.TargetObjectID) {
            $TargetObjectName = $($DSM7Objects | where { $_.ID -eq $DSM7Object.TargetObjectID }).Name 
            add-member -inputobject $Raw -MemberType NoteProperty -name TargetObjectName -Value $TargetObjectName
        }
    }
    if ($DSM7Object.GenTypeData) {
        foreach ($GenTypeData in $($DSM7Object.GenTypeData | get-member -membertype properties)) { 
            add-member -inputobject $Raw -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
        }
    }
    if ($DSM7Object.PropGroupList) {
        foreach ($PropGroup in $DSM7Object.PropGroupList) {
            $Groupname = $PropGroup.Tag
            foreach ($Prop in $PropGroup.PropertyList) {
                $TypedValue = $Prop.TypedValue
                if ($Prop.Type -eq "CatalogLink" -and $TypedValue -and $LDAP) {
                    add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag).Name" -Value (Get-DSM7ObjectObject -ID $TypedValue -ObjectGroupType "Catalog" ).Name
                }
                add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag)" -Value $Prop.TypedValue
            }
        }
    } 
    if ($DSM7Object.TargetObjectList) {
        $TargetObjectList = @()
        foreach ($TargetObject in $DSM7Object.TargetObjectList) {
            $TargetPSObject = New-Object PSObject
            $TargetObjectName = $($DSM7Objects | where { $_.ID -eq $TargetObject.TargetObjectID }).Name 
            add-member -inputobject $TargetPSObject -MemberType NoteProperty -name TargetObjectName -Value $TargetObjectName
            add-member -inputobject $TargetPSObject -MemberType NoteProperty -name TargetObjectID -Value $TargetObject.TargetObjectID
            $TargetObjectList += $TargetPSObject
        }
        add-member -inputobject $Raw -MemberType NoteProperty -name "TargetObjectList" -Value $TargetObjectList
    }
    return $Raw
}
function Convert-DSM7PolicyInstanceListtoPSObject {
    [CmdletBinding()] 
    param ( $ObjectList, [switch]$resolvedName = $false)
    $DSM7ConfigIDs = @()
    if ($DSM7Version -gt "7.3.0") {
        $DSM7ConfigIDs += ($ObjectList | where { $_.AssignedConfiguration } | Select-Object -ExpandProperty AssignedConfiguration)
        if ($DSM7ConfigIDs.count -gt 0) { 
            $DSM7Configs = Get-DSM7SwInstallationConfigurationsObject $DSM7ConfigIDs
        }
    } 
    if ($resolvedName) {
        $IDs = @() 
        if ($DSM7Version -gt "7.3.0") {
            $IDs += ($DSM7Configs | where { $_.SoftwareObjectID } | Select-Object -ExpandProperty SoftwareObjectID)
        }
        else {
            $IDs += ($ObjectList | Select-Object -ExpandProperty AssignedObjectID)
        }
        $IDs += ($ObjectList | Select-Object -ExpandProperty TargetObjectID)
        $DSM7Objects = Get-DSM7ObjectsObject -IDs $IDs
    } 
    $DSM7ObjectMembers = ($ObjectList | Get-Member -MemberType Properties).Name
    foreach ($DSM7Object in $ObjectList) {
        $DSM7Object = Convert-DSM7PolicyInstancetoPSObject -DSM7Object $DSM7Object -DSM7ObjectMembers $DSM7ObjectMembers -DSM7Objects $DSM7Objects -DSM7Configs $DSM7Configs -resolvedName:$resolvedName
        $DSM7ObjectList += @($DSM7Object)
    }
    return $DSM7ObjectList
}

function Convert-DSM7StatiscstoPSObject {
    [CmdletBinding()] 
    param ( 
        $DSM7Statistics
    )
    $Raw = New-Object PSObject
    foreach ($Stat in $DSM7Statistics) {
        add-member -inputobject $Raw -MemberType NoteProperty -name $Stat.Key -Value $Stat.Count
    }
    return $Raw
}
function Convert-DSM7VariableGrouptoPSObject {
    [CmdletBinding()] 
    param (
        $DSM7Objects
    ) 
    foreach ($DSM7Object in $DSM7Objects) {
        foreach ($Variable in $($DSM7Object.VariableList)) {
            $Raw = New-Object PSObject

            add-member -inputobject $Raw -MemberType NoteProperty -name GroupTag -Value $DSM7Object.Tag
            add-member -inputobject $Raw -MemberType NoteProperty -name GroupID -Value $DSM7Object.ID
            add-member -inputobject $Raw -MemberType NoteProperty -name GroupVisibility -Value $DSM7Object.Visibility
            add-member -inputobject $Raw -MemberType NoteProperty -name GroupIsSystem -Value $DSM7Object.IsSystem
            add-member -inputobject $Raw -MemberType NoteProperty -name Tag -Value $Variable.Tag
            add-member -inputobject $Raw -MemberType NoteProperty -name ID -Value $Variable.ID
            add-member -inputobject $Raw -MemberType NoteProperty -name IsDisabled -Value $Variable.IsDisabled
            add-member -inputobject $Raw -MemberType NoteProperty -name IsSystem -Value $Variable.IsSystem
            add-member -inputobject $Raw -MemberType NoteProperty -name AvailableOnClient -Value $Variable.AvailableOnClient
            add-member -inputobject $Raw -MemberType NoteProperty -name VariableType -Value $Variable.VariableType
            if ($Variable.GenTypeData) {
                foreach ($GenTypeData in $($Variable.GenTypeData | get-member -membertype properties)) { 
                    add-member -inputobject $Raw -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $Variable.GenTypeData.$($GenTypeData.Name)
                }
            }
            $AllVariable += @($Raw)
        } 
    }
    return $AllVariable
}
function Convert-DSM7VariabletoPSObject {
    [CmdletBinding()] 
    param (
        $DSM7Object,
        $DSM7VariableGroups
    )
    $DSM7VariableGroups = Convert-ArrayToHash -myArray $DSM7VariableGroups -myKey "ID"
    $Raw = New-Object PSObject
    add-member -inputobject $Raw -MemberType NoteProperty -name ID -Value $DSM7Object.ID
    add-member -inputobject $Raw -MemberType NoteProperty -name IsInherited -Value $DSM7Object.IsInherited
    add-member -inputobject $Raw -MemberType NoteProperty -name SchemaTag -Value $DSM7Object.SchemaTag
    add-member -inputobject $Raw -MemberType NoteProperty -name TargetObjectID -Value $DSM7Object.TargetObjectID
    add-member -inputobject $Raw -MemberType NoteProperty -name Value -Value $DSM7Object.Value
    add-member -inputobject $Raw -MemberType NoteProperty -name VariableID -Value $DSM7Object.VariableID
    add-member -inputobject $Raw -MemberType NoteProperty -name VariableName -Value $DSM7VariableGroups.Item($DSM7Object.VariableID).Tag
    add-member -inputobject $Raw -MemberType NoteProperty -name GroupID -Value $DSM7VariableGroups.Item($DSM7Object.VariableID).GroupID
    add-member -inputobject $Raw -MemberType NoteProperty -name GroupName -Value $DSM7VariableGroups.Item($DSM7Object.VariableID).GroupTag
    if ($DSM7Object.GenTypeData) {
        foreach ($GenTypeData in $($DSM7Object.GenTypeData | get-member -membertype properties)) { 
            add-member -inputobject $Raw -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
        }
    }

    return $Raw

}
function Convert-DSM7VariabletoPSObjects {
    [CmdletBinding()] 
    param (
        $DSM7Objects
    ) 
    $VariableGroups = Get-DSM7VariableGroups
    foreach ($DSM7Object in $DSM7Objects) {
        $DSM7Object = Convert-DSM7VariabletoPSObject -DSM7Object $DSM7Object -DSM7VariableGroups $VariableGroups
        $DSM7ObjectList += @($DSM7Object)
    }
    return $DSM7ObjectList
}
function Convert-DSM7SwInstallationParamDefinitionstoPSObject {
    [CmdletBinding()] 
    param (
        $DSM7Object,
        $DSM7ObjectMembers,
        [switch]$resolvedName = $false
    )
    $Raw = New-Object PSObject
    foreach ($DSM7ObjectMember in $DSM7ObjectMembers) {
        if ($DSM7ObjectMember -ne "GenTypeData") {
            if ($DSM7ObjectMember -like "*List" -or $DSM7ObjectMember -like "*Category" ) {
                $DSM7ObjectMemberLists = $DSM7Object.$DSM7ObjectMember
                $RawListArray = @()
                foreach ($DSM7ObjectMemberList in $DSM7ObjectMemberLists) {
                    $DSM7ObjectMemberListMembers = ($DSM7ObjectMemberList | Get-Member -MemberType Properties).Name

                    $RawList = New-Object PSObject
                    $RawListArrayListArray = @()
                    foreach ($DSM7ObjectMemberListMember in $DSM7ObjectMemberListMembers) {
                        $value = $DSM7ObjectMemberList.$DSM7ObjectMemberListMember
                        if ($DSM7ObjectMemberListMember -like "*List") {
                            $DSM7ObjectMemberListMemberLists = $DSM7ObjectMemberList.$DSM7ObjectMemberListMember
                            foreach ($DSM7ObjectMemberListMemberList in $DSM7ObjectMemberListMemberLists) {
                                $RawListList = New-Object PSObject
                                $DSM7ObjectMemberListMemberListMembers = ($DSM7ObjectMemberListMemberList | Get-Member -MemberType Properties).Name
                                foreach ($DSM7ObjectMemberListMemberListMember in $DSM7ObjectMemberListMemberListMembers) {
                                    if ($DSM7ObjectMemberListMemberListMember -eq "GenTypeData") {
                                        foreach ($GenTypeData in $($DSM7ObjectMemberListMemberList.GenTypeData | get-member -membertype properties)) { 
                                            add-member -inputobject $RawListList -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7ObjectMemberListMemberList.GenTypeData.$($GenTypeData.Name)
                                        }
                                    } 
                                    else {
                                        add-member -inputobject $RawListList -MemberType NoteProperty -name "$DSM7ObjectMemberListMemberListMember" -Value $DSM7ObjectMemberListMemberList.$DSM7ObjectMemberListMemberListMember
                                    }
                                }
                                $RawListArrayListArray += $RawListList
                            }
                            $value = $RawListArrayListArray
                        }
                        if ($DSM7ObjectMemberListMember -eq "GenTypeData") {
                            foreach ($GenTypeData in $($DSM7ObjectMemberList.GenTypeData | get-member -membertype properties)) { 
                                add-member -inputobject $RawList -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7ObjectMemberList.GenTypeData.$($GenTypeData.Name)
                            }
                        } 
                        else {
                            add-member -inputobject $RawList -MemberType NoteProperty -name "$DSM7ObjectMemberListMember" -Value $value
                        }
                    }
                    $RawListArray += $RawList
                }
                add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $RawListArray
            }
            else {
                add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember
            }
        } 
    }
    if ($DSM7Object.GenTypeData) {
        foreach ($GenTypeData in $($DSM7Object.GenTypeData | get-member -membertype properties)) { 
            add-member -inputobject $Raw -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
        }
    }
    if ($resolvedName -and $DSM7Object.InstallationParamType -eq "ObjectLink") {
        $filter = ($($DSM7Object.FrontEndData) -split "ObjectFilter>")[1].trimend("</")
        if ($DSM7Object.DefaultValue) {
            $DefaultValueName = (Get-DSM7Object -ID $DSM7Object.DefaultValue).Name
        }
        add-member -inputobject $Raw -MemberType NoteProperty -name "DefaultValueName" -Value $DefaultValueName
    }
    return $Raw
}

function Convert-DSM7SwInstallationParamDefinitionstoPSObjects {
    [CmdletBinding()] 
    param (
        $DSM7Objects,
        [switch]$resolvedName = $false
    )
    $DSM7ObjectMembers = ($DSM7Objects[0] | Get-Member -MemberType Properties).Name
    foreach ($DSM7Object in $DSM7Objects) {
        $DSM7Object = Convert-DSM7SwInstallationParamDefinitionstoPSObject -DSM7Object $DSM7Object -DSM7ObjectMembers $DSM7ObjectMembers -resolvedName:$resolvedName
        $DSM7ObjectList += @($DSM7Object)
    }
    return $DSM7ObjectList
}

function Convert-DSM7AssociationSchemaListtoPSObject {
    [CmdletBinding()] 
    param ( 
        $DSM7Object,
        $DSM7ObjectMembers
    )
    $Raw = New-Object PSObject
    foreach ($DSM7ObjectMember in $DSM7ObjectMembers) {
        if ($DSM7ObjectMember -ne "GenTypeData") {
            if ($DSM7ObjectMember -like "*List") {
                $DSM7ObjectMemberLists = $DSM7Object.$DSM7ObjectMember
                if ($DSM7ObjectMemberLists.Count -gt 0) {
                    $DSM7ObjectMemberListsMembers = ($DSM7ObjectMemberLists | Get-Member -MemberType Properties).Name
                    foreach ($DSM7ObjectMemberListsMember in $DSM7ObjectMemberListsMembers) {
                        for ($I = 0; $I -lt $DSM7ObjectMemberLists.Count; $I++) {
                            if ($DSM7ObjectMemberListsMember -eq "GenTypeData") {
                                foreach ($GenTypeData in $($DSM7ObjectMemberLists[$I].GenTypeData | get-member -membertype properties)) { 
                                    add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
                                }
                            } 
                            else {
                                add-member -inputobject $Raw -MemberType NoteProperty -name "$DSM7ObjectMember.$I.$DSM7ObjectMemberListsMember" -Value $DSM7ObjectMemberLists.$DSM7ObjectMemberListsMember[$I]
                            }
                        }
                    }
                }
                else {
                    add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember

                }
            }
            else {
                add-member -inputobject $Raw -MemberType NoteProperty -name $DSM7ObjectMember -Value $DSM7Object.$DSM7ObjectMember
            }
        } 
    }
    if ($DSM7Object.GenTypeData) {
        foreach ($GenTypeData in $($DSM7Object.GenTypeData | get-member -membertype properties)) { 
            add-member -inputobject $Raw -MemberType NoteProperty -name "GenTypeData.$($GenTypeData.Name)" -Value $DSM7Object.GenTypeData.$($GenTypeData.Name)
        }
    }
    if ($DSM7Object.PropGroupList) {
        foreach ($PropGroup in $DSM7Object.PropGroupList) {
            $Groupname = $PropGroup.Tag
            foreach ($Prop in $PropGroup.PropertyList) {
                $TypedValue = $Prop.TypedValue
                if ($Prop.Type -eq "CatalogLink" -and $TypedValue -and $LDAP) {
                    add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag).Name" -Value (Get-DSM7ObjectObject -ID $TypedValue -ObjectGroupType "Catalog" ).Name
                }
                add-member -inputobject $Raw -MemberType NoteProperty -name "$Groupname.$($Prop.Tag)" -Value $Prop.TypedValue
            }
        }
    } 

    return $Raw
}

function Convert-DSM7AssociationSchemaListtoPSObjects {
    [CmdletBinding()] 
    param ( 
        $DSM7Objects
    )
    $DSM7ObjectMembers = ($DSM7Objects | Get-Member -MemberType Properties).Name

    foreach ($DSM7Object in $DSM7Objects) {
        $DSM7Object = Convert-DSM7AssociationSchemaListtoPSObject -DSM7Object $DSM7Object -DSM7ObjectMembers $DSM7ObjectMembers
        $DSM7ObjectList += @($DSM7Object)
    }
    return $DSM7ObjectList
}
###############################################################################
# DSM7 Funktionen - Objekte
###############################################################################
function Get-DSM7ObjectList {
    <#
    .SYNOPSIS
        Gibt eine Liste von Objekten zurueck.
    .DESCRIPTION
        Gibt eine Liste von Objekten zurueck.
    .EXAMPLE
        Get-DSM7ObjectList -LDAPPath "Managed Users & Computers/OU1/OU2" -recursive
    .EXAMPLE
        Get-DSM7ObjectList -LDAProot "<LDAP://rootCatalog>" -Filter "(&(Name=Windows 10 \(x64\))(PatchCa
tegoryObject.RequiredLicense=DSM7_LUMENSION_PATCH))" -Attributes "PatchCategoryObject.RequiredLicense"
 
    .NOTES
        Nur benutzen wenn man die Objektstruktur genau kennt! Es kann sonst zu langen Anwortzeiten oder Fehlern kommen!
        Alternativen:
        Get-DSM7SoftwareList
        Get-DSM7ComputerList
    .LINK
        Get-DSM7ObjectList
    .LINK
        Get-DSM7Object
    .LINK
        Get-DSM7Objects
    #>
    [CmdletBinding()] 
    param ( 
        [system.string]$Attributes,
        [system.string]$Filter,
        [system.string]$LDAPPath = "", 
        [system.string]$LDAProot = "<LDAP://rootDSE>", 
        [int]$ParentContID,
        [switch]$GenTypeData = $false,
        [switch]$recursive = $false
    )
    if (Confirm-Connect) {
        try {
            if ($LDAPPath -or $ParentContID -gt 0) {
                if ($LDAPPath) {
                    $ParentContID = Get-DSM7LDAPPathID -LDAPPath $LDAPPath
                } 
                $Filternew = "(&(ParentContID=$ParentContID)$Filter)"
            }
            else {
                $Filternew = $Filter
            }
            if ($GenTypeData) {
                if ($Attributes) {
                    $Attributes = $Attributes + "," + $DSM7GenTypeData
                }
                else {
                    $Attributes = $DSM7GenTypeData
                }
            }
            $Webrequest = Get-DSM7RequestHeader -action "GetObjectList"
            $Webrequest.LdapQuery = "$LDAProot;$Filternew;BasePropGroupTag,Description,ParentContID,UniqueId,$Attributes;subtree" 
            $Webrequest.OrderBy = "Name" 
            $Webrequest.MaxResults = -1 
            $Webresult = $($DSM7WebService.GetObjectList($Webrequest)).ObjectList 
            if ($recursive -and $ParentContID) {
                foreach ($WebresultRaw in $Webresult) {
                    if ($WebresultRaw.SchemaTag -eq "Domain" -or $WebresultRaw.SchemaTag -eq "OU" -or $WebresultRaw.SchemaTag -eq "SwFolder" -or $WebresultRaw.SchemaTag -eq "CitrixFarm" -or $WebresultRaw.SchemaTag -eq "CitrixZone" -or $WebresultRaw.SchemaTag -eq "SwLibrary") {
                        $Webresultsub = Get-DSM7ObjectList -Attributes $Attributes -Filter $Filter -ParentContID $WebresultRaw.ID -recursive 
                        if ($Webresultsub) {
                            $Webresult += $Webresultsub
                        }
                    }
                }
            }
            if ($Webresult.count -gt 0) {
                $Webresult = Convert-DSM7ObjectListtoPSObject($Webresult) 
                Write-Log 0 "($Filter$LDAPPath) erfolgreich." $MyInvocation.MyCommand
                return $Webresult
            }
            else {
                Write-Log 1 "($Filter$LDAPPath) nicht gefunden!!!" $MyInvocation.MyCommand
                return $false
            }
        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Get-DSM7ObjectList
function Get-DSM7ObjectObject {
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [int]$ID, 
        [system.string]$ObjectGroupType = "Object"
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "GetObject"
        $Webrequest.ObjectId = $ID
        $Webrequest.RequestedObjectGroupType = $ObjectGroupType
        $Webresult = $DSM7WebService.GetObject($Webrequest).RetrievedObject
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
if ($Dev) { Export-ModuleMember -Function Get-DSM7ObjectObject }
function Get-DSM7Object {
    <#
    .SYNOPSIS
        Ermittelt DSM Objekt.
    .DESCRIPTION
        Ermittelt DSM Objekt.
    .EXAMPLE
        Get-DSM7Objekt -ID 123456
    .NOTES
    .LINK
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [int]$ID, 
        [system.string]$ObjectGroupType = "Object"
    )
    if (Confirm-Connect) {
        $return = Get-DSM7ObjectObject -ID $ID -ObjectGroupType $ObjectGroupType
        if ($return) {
            $return = Convert-DSM7ObjecttoPSObject($return)
            Write-Log 0 "ID ($ID) und Objectgruppe ($ObjectGroupType) erfolgreich." $MyInvocation.MyCommand
            return $return
        }
        else {
            Write-Log 2 "ID ($ID) und Objectgruppe ($ObjectGroupType) nicht erfolgreich!" $MyInvocation.MyCommand
            return $false
        }
    }
}
Export-ModuleMember -Function Get-DSM7Object
function Get-DSM7ObjectsObject {
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        $IDs, 
        [system.string]$ObjectGroupType = "Object"
    )
    try {
        $IDs = $IDs | Sort-Object | Get-Unique
        $Webrequest = Get-DSM7RequestHeader -action "GetObjects"
        $Webrequest.ObjectIds = $IDs
        $Webrequest.RequestedObjectGroupType = $ObjectGroupType
        $Webresult = $DSM7WebService.GetObjects($Webrequest).ObjectList
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function Get-DSM7Objects {
    <#
    .SYNOPSIS
        Gibt eine Liste von Objekten zurueck.
    .DESCRIPTION
        Gibt eine Liste von Objekten zurueck. Nur benutzen wenn man die Objektstruktur genau kennt!!!
    .EXAMPLE
        Get-DSM7Objects -IDs (1,2,3)
    .NOTES
    .LINK
        Get-DSM7ObjectList
    .LINK
        Get-DSM7Object
    .LINK
        Get-DSM7Objects
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [System.Array]$IDs, 
        [system.string]$ObjectGroupType = "Object"
    )
    $result = Get-DSM7ObjectsObject -IDs $IDs -ObjectGroupType $ObjectGroupType
    if ($result) {
        return Convert-DSM7ObjectListtoPSObject($result)
    }
    else {
        return $false
    }
}
Export-ModuleMember -Function Get-DSM7Objects
function Update-DSM7Object {
    [CmdletBinding()] 
    param ( 
        $Object,
        [string[]]$Values
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "UpdateObject"
        $WebrequestState = Get-DSM7RequestHeader -action "UpdateStateInfoOfObject"
        if ($DSM7Version -ne "7.4.3.0") {
            if (!$DSM7PropGroupDefList) {
                $global:DSM7PropGroupDefList = Convert-ArrayToHash -myArray (Get-DSM7PropGroupDefListObject) -myKey "Tag" 

            }
        }
        $groupkey = @{}
        $valueskey = @{}
        foreach ($Value in $Values) {
            $ValueName = $Value.split("=", 2)[0]
            $ValueValue = $Value.split("=", 2)[1]
            if ($ValueName.contains(".")) {
                $PropGroup = $ValueName.split(".")[0]
                $PropName = $ValueName.split(".")[1]
                $Valueskey[$PropName] = $ValueValue
                $groupkey[$PropGroup] += $Valueskey
                $valueskey = @{}
            }
            else {
                if (($ValueValue).contains(":String") -or ($ValueValue).contains(":Option")) {
                    $Object.$ValueName = $ValueValue.split(":")[0]
                }
                else {
                    $Object.$ValueName = $ValueValue
                }
            }
        }
        $StateInfo = $false
        $PropGroupList = @()
        $PropGroupListStateInfo = @()
        foreach ($Groupname in $groupkey.keys) {
            $PropertyList = @()
            foreach ($Valuename in $groupkey.$groupname.keys) {
                if (($groupkey.$groupname.$Valuename).contains(":String") -or ($groupkey.$groupname.$Valuename).contains(":Option") ) {
                    $Value = $groupkey.$groupname.$Valuename.split(":")[0]
                }
                else {
                    $Value = $groupkey.$groupname.$Valuename
                }
                Write-Log 0 "aendere $Groupname.$Valuename = $Value" $MyInvocation.MyCommand
                $PropertyListObject = New-Object $DSM7Types["MdsTypedPropertyOfString"]
                $PropertyListObject.Tag = $Valuename
                $PropertyListObject.Type = ((($Object.PropGroupList | Where Tag -EQ $Groupname).propertyList) | where Tag -EQ $Valuename).Type
                $PropertyListObject.TypedValue = $Value
                $PropertyList += $PropertyListObject
            }
            $PropGroupListObject = New-Object $DSM7Types["MdsPropGroup"]
            $PropGroupListObject.Tag = $Groupname
            $PropGroupListObject.PropertyList = $PropertyList
            $PropGroupList += $PropGroupListObject
            if ($DSM7PropGroupDefList.$Groupname.PropGroupInfoType -eq "StateInfo") {
                $StateInfo = $true
                $PropGroupListStateInfo += $PropGroupListObject
            }
        }
        $Webrequest.ObjectToUpdate = $Object

        $Webrequest.ObjectToUpdate.PropGroupList = $PropGroupList
        $Object = $DSM7WebService.UpdateObject($Webrequest).UpdatedObject
        if ($StateInfo) {
            $WebrequestState.ObjectToUpdate = $Object
            $WebrequestState.ObjectToUpdate.PropGroupList = $PropGroupListStateInfo
            $Object = $DSM7WebService.UpdateStateInfoOfObject($WebrequestState).UpdatedObject
        }
        Write-Log 0 "($($Object.Name)) erfolgreich." $MyInvocation.MyCommand
        return $Object 
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}

function Get-DSM7LDAPPath {
    <#
    .SYNOPSIS
        Gibt ein den LDAP Path zurueck.
    .DESCRIPTION
        Gibt ein den LDAP Path zurueck.
    .EXAMPLE
        Get-DSM7LDAPPath -ParentContID 1234
    .NOTES
    .LINK
        Get-DSM7ObjectList
    .LINK
        Get-DSM7Object
    .LINK
        Get-DSM7Objects
    #>
    [CmdletBinding()] 
    param ( 
        [int]$ParentContID = 0
    )
    [system.string]$LDAPPath = ""
    while ($ParentContID -ne 0) { 

        $Container = Get-DSM7OrgTreeContainerObject -ID $ParentContID
        $ParentContID = $Container.ParentContID
        $LDAPPath = "/" + $Container.Name + $LDAPPath
    } 
    return $LDAPPath.TrimStart("/")
}
Export-ModuleMember -Function Get-DSM7LDAPPath
function Get-DSM7LDAPPathID {
    [CmdletBinding()] 
    param ( [system.string]$LDAPPath, [int]$ParentContID)
    try {
        if ($LDAPPath.Contains("/")) {
            foreach ($ParentCont in $LDAPPath.split("/")) {

                if ($ParentContID -eq 0) {
                    $Filter = "(&(Name:IgnoreCase=$ParentCont)$DSM7Structure)"
                }
                else {
                    $Filter = "(&(Name:IgnoreCase=$ParentCont)(ParentContID=$ParentContID)$DSM7Structure)"
                }
                $result = Get-DSM7ObjectList -Filter $Filter
                if ($result) {
                    $ParentCont = $result.Name
                    $ParentContID = $result.ID
                }
                else {
                    $ParentContID = 0
                }
            } 
        }
        else {
            $Filter = "(&(Name:IgnoreCase=$LDAPPath)$DSM7Structure)"
            $result = Get-DSM7ObjectList -Filter $Filter
            if ($result) {
                $ParentCont = $result.Name
                $ParentContID = $result.ID
            }
            else {
                $ParentContID = 0
            }
        } 
        return $ParentContID
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function New-DSM7Object {
    [CmdletBinding()] 
    param (
        [system.string]$Name,
        [system.string]$Description,
        [int]$ParentContID,
        [system.string]$SchemaTag,
        $PropGroupList,
        [system.string]$GroupType = "Object",
        [system.string]$UniqueID
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "CreateObject"
        $Webrequest.NewObject = New-Object $DSM7Types["MdsObject"] 
        $Webrequest.NewObject.SchemaTag = $SchemaTag
        $Webrequest.NewObject.Name = $Name
        if ($DSM7Version -gt "7.4.0") {
            $Webrequest.NewObject.GenTypeData = new-object $DSM7Types["MdsGenType"]
            $CreationSource = $MyInvocation.MyCommand.Module.Name
            if ($DSM7CreationSource) { $CreationSource = $DSM7CreationSource }
            $Webrequest.NewObject.GenTypeData.CreationSource = $CreationSource
        }
        $Webrequest.NewObject.Description = $Description
        if ($SchemaTag -eq "ExternalGroup" ) {
            $Webrequest.NewObject.IdProvider = "AD"
            $Webrequest.NewObject.UniqueID = $UniqueID
        } 
        $Webrequest.NewObject.PropGroupList = $PropGroupList
        $Webrequest.NewObject.ParentContID = $ParentContID
        $Webrequest.NewObject.GroupType = $GroupType
        $Webresult = $DSM7WebService.CreateObject($Webrequest).CreatedObject
        Write-Log 0 "($Name) erfolgreich." $MyInvocation.MyCommand
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function New-DSM7InfrastructureJob {
    [CmdletBinding()] 
    param (
        [system.string]$SchemaTag,
        $PropGroupList,
        [system.string]$GroupType = "Object"
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "CreateInfrastructureJob"
        $Webrequest.JobDefinition = New-Object $DSM7Types["MdsObject"]
        $Webrequest.JobDefinition.SchemaTag = $SchemaTag
        $Webrequest.JobDefinition.Name = $DSM7CreationSource
        $Webrequest.JobDefinition.PropGroupList = $PropGroupList
        $Webresult = $DSM7WebService.CreateInfrastructureJob($Webrequest)
        Write-Log 0 "Job ($SchemaTag) erfolgreich." $MyInvocation.MyCommand
        return $true
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function Remove-DSM7Object {
    [CmdletBinding()] 
    param (
        $Object
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "DeleteObject"
        $Webrequest.ObjectToDelete = $Object
        $Webresult = $DSM7WebService.DeleteObject($Webrequest).DeleteObjectResult 
        Write-Log 0 "Loeschen Objekt $($Object.Name) ($($Object.ID)) erfolgreich." $MyInvocation.MyCommand
        return $true
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}

function Move-DSM7Object {
    [CmdletBinding()] 
    param (
        $Object,
        $ParentContID
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "MoveObject"
        $Webrequest.ObjectToMove = $Object
        $Webrequest.NewParentOrgTreeContainer = Get-DSM7OrgTreeContainerObject -ID $ParentContID
        $Webresult = $DSM7WebService.MoveObject($Webrequest).MovedObject
        Write-Log 0 "Verschieben von $($Object.Name) ($($Object.ID)) erfolgreich." $MyInvocation.MyCommand
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
###############################################################################
# DSM7 Funktionen - Association
###############################################################################
function Get-DSM7AssociationListObject {
    [CmdletBinding()] 
    param ( 
        [Parameter(Position = 0, Mandatory = $true)]
        [system.string]$SchemaTag,
        [system.string]$SourceObjectID = "*",
        [system.string]$TargetObjectID = "*",
        [system.string]$TargetSchemaTag = "*"
    )
    if (Confirm-Connect) {
        try {
            $IDs = @()
            $ObjectIDs = @()
            $Filter = "(&(SchemaTag=$SchemaTag)(TargetObjectID=$TargetObjectID)(SourceObjectID=$SourceObjectID)(TargetSchemaTag=$TargetSchemaTag))"
            $Webrequest = Get-DSM7RequestHeader -action "GetAssociationList"
            $Webrequest.LdapQuery = "<LDAP://rootDSE>;$Filter;;subtree" 
            $Webrequest.MaxResults = -1 
            $Webresult = $($DSM7WebService.GetAssociationList($Webrequest)).AssociationList 
            if ($Webresult.count -gt 0) {
                foreach ($DSM7Object in $Webresult) {
                    $IDs += $DSM7Object.ID
                }
                $IDs = $($IDs | sort -Unique)
                $Webresult = Get-DSM7AssociationsObject -IDs $IDs -SchemaTag $SchemaTag 
                return $Webresult
            }
            else {
                return $false
            }
        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
} 
function Get-DSM7AssociationList {
    <#
    .SYNOPSIS
        Gibt eine Liste von Association zurueck.
    .DESCRIPTION
        Gibt eine Liste von Association zurueck.
    .EXAMPLE
        Get-DSM7AssociationList -SchemaTag "ComputerAssociatedUser"
    .NOTES
    .LINK
        Get-DSM7AssociationList
    .LINK
        Get-DSM7AssociationschemaList
    .LINK
        New-DSM7Association
    #>

    [CmdletBinding()] 
    param ( 
        [Parameter(Position = 0, Mandatory = $true)]
        [system.string]$SchemaTag,
        [system.string]$SourceObjectID = "*",
        [system.string]$TargetObjectID = "*",
        [system.string]$TargetSchemaTag = "*",
        [switch]$resolvedName = $false
    )
    if (Confirm-Connect) {
        #workaround not work SchemaList with version 7.4.3
        $DSM7AssociationSchemaListCheck = $true
        if ($DSM7Version -ne "7.4.3.0") {
            if (!$DSM7AssociationSchemaList) {
                $global:DSM7AssociationSchemaList = Get-DSM7AssociationschemaList | select -ExpandProperty Tag
            }
            if ($DSM7AssociationSchemaList.Contains($SchemaTag)) {
                $DSM7AssociationSchemaListCheck = $true
            }
            else {
                $DSM7AssociationSchemaListCheck = $false
            }
        }
        if ($DSM7AssociationSchemaListCheck) {
            $result = Get-DSM7AssociationListObject -SchemaTag $SchemaTag -SourceObjectID $SourceObjectID -TargetObjectID $TargetObjectID -TargetSchemaTag $TargetSchemaTag
            if ($result) {
                $result = Convert-DSM7AssociationListtoPSObject -ObjectList $result -resolvedName:$resolvedName
                Write-Log 0 "Liste von $SchemaTag erfolgreich." $MyInvocation.MyCommand
                return $result
            }
        }
        else {
            Write-Log 1 "$SchemaTag nicht vorhanden!!! Bite folgende verwenden ($DSM7AssociationSchemaList)." $MyInvocation.MyCommand
            return $false
        }
    }
}
Export-ModuleMember -Function Get-DSM7AssociationList
function Get-DSM7AssociationschemaListObject {
    try {
        $Webrequest = Get-DSM7RequestHeader -action "GetAssociationSchemaList"
        $Webrequest.SchemaTags = @()
        $Webresult = $DSM7WebService.GetAssociationSchemaList($Webrequest).SchemaList
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function Get-DSM7AssociationschemaList {
    <#
    .SYNOPSIS
        Gibt eine Liste von Association Schemas zurueck.
    .DESCRIPTION
        Gibt eine Liste von Association Schemas zurueck.
    .EXAMPLE
        Get-DSM7AssociationList
    .NOTES
    .LINK
        Get-DSM7AssociationList
    .LINK
        Get-DSM7AssociationschemaList
    .LINK
        New-DSM7Association
    #>
    [CmdletBinding()] 
    param ( 
    )
    if (Confirm-Connect) {
        $result = Get-DSM7AssociationschemaListObject
        if ($result) {
            $result = Convert-DSM7AssociationSchemaListtoPSObjects -DSM7Objects $result
            Write-Log 0 " Liste von Association Schemas erfolgreich." $MyInvocation.MyCommand 
        }
        else {
            Write-Log 1 " Liste von Association Schemas konte nicht ermitteltwerden!" $MyInvocation.MyCommand 

        }
        return $result
    }

}
Export-ModuleMember -Function Get-DSM7AssociationschemaList
function Get-DSM7AssociationObject {
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [int]$ID, 
        [Parameter(Position = 1, Mandatory = $true)]
        [system.string]$SchemaTag
    )
    if (Confirm-Connect) {
        try {
            $Webrequest = Get-DSM7RequestHeader -action "GetAssociation"
            $Webrequest.AssociationId = $ID
            $Webrequest.SchemaTag = $SchemaTag
            $Webresult = $DSM7WebService.GetAssociation($Webrequest).RetrievedAssociation
            return $Webresult
        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
function Get-DSM7AssociationsObject {
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        $IDs ,
        [Parameter(Position = 1, Mandatory = $true)]
        [system.string]$SchemaTag
    )
    try {
        $IDs = $IDs | Sort-Object | Get-Unique
        $Webrequest = Get-DSM7RequestHeader -action "GetAssociations"
        $Webrequest.AssociationIds = $IDs
        $Webrequest.SchemaTag = $SchemaTag
        $Webresult = $DSM7WebService.GetAssociations($Webrequest).AssociationList
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function New-DSM7AssociationObject {
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [system.string]$SchemaTag,
        [Parameter(Position = 1, Mandatory = $true)]
        [Int]$SourceObjectID,
        [Parameter(Position = 2, Mandatory = $true)]
        [Int]$TargetObjectID,
        [Parameter(Position = 3, Mandatory = $true)]
        [system.string]$TargetSchemaTag
    ) 
    try {
        $Webrequest = Get-DSM7RequestHeader -action "CreateAssociation"
        $Webrequest.NewAssociation = New-Object $DSM7Types["MdsAssociation"]
        $Webrequest.NewAssociation.SchemaTag = $SchemaTag
        $Webrequest.NewAssociation.SourceObjectID = $SourceObjectID
        $Webrequest.NewAssociation.TargetObjectID = $TargetObjectID
        $Webrequest.NewAssociation.TargetSchemaTag = $TargetSchemaTag
        $Webresult = $DSM7WebService.CreateAssociation($Webrequest).CreatedAssociation
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function New-DSM7Association {
    <#
    .SYNOPSIS
        Neue Association wird erstellt.
    .DESCRIPTION
        Neue Association wird erstellt.
    .EXAMPLE
        New-DSM7Association -SchemaTag "Schema" -SourceObjectID 1234 -TargetSchemaTag "Schema" -TargetObjectID 1234
    .NOTES
    .LINK
        Get-DSM7AssociationList
    .LINK
        Get-DSM7AssociationschemaList
    .LINK
        New-DSM7Association
    #>

    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [system.string]$SchemaTag,
        [Parameter(Position = 1, Mandatory = $true)]
        [system.Int32]$SourceObjectID,
        [Parameter(Position = 2, Mandatory = $true)]
        [system.string]$TargetSchemaTag,
        [Parameter(Position = 3, Mandatory = $true)]
        [System.Int32]$TargetObjectID
    )
    if (Confirm-Connect) {
        #workaround not work GetAssociationSchemaList with version 7.4.3
        $DSM7AssociationSchemaListCheck = $true
        if ($DSM7Version -ne "7.4.3.0") {
            if (!$DSM7AssociationSchemaList) {
                $global:DSM7AssociationSchemaList = Get-DSM7AssociationschemaList | select -ExpandProperty Tag
            }
            if ($DSM7AssociationSchemaList.Contains($SchemaTag)) {
                $DSM7AssociationSchemaListCheck = $true
            }
            else {
                $DSM7AssociationSchemaListCheck = $false
            }
        }
        if ($DSM7AssociationSchemaListCheck -and $SourceObjectID -gt 0 -and $TargetObjectID - 0 -and $TargetSchemaTag) {
            $result = New-DSM7AssociationObject -SchemaTag $SchemaTag -SourceObjectID $SourceObjectID -TargetObjectID $TargetObjectID -TargetSchemaTag $TargetSchemaTag
            if ($result) {
                $result = Convert-DSM7AssociationtoPSObject($result)
                Write-Log 0 "Neue Association von $SchemaTag erfolgreich." $MyInvocation.MyCommand
                return $result
            }
        }
        else {
            Write-Log 1 "$SchemaTag nicht vorhanden!!! Bite folgende verwenden ($DSM7AssociationSchemaList)." $MyInvocation.MyCommand
            return $false
        }
    }
}
Export-ModuleMember -Function New-DSM7Association
function New-DSM7AssociationListObject {
    [CmdletBinding()] 
    param (
        [PSObject[]]$Objects
    ) 
    try {
        $Webrequest = Get-DSM7RequestHeader -action "CreateAssociationList AssociationListToCreate"
        $ObjectMdsAssociations = @()
        foreach ($Object in $Objects) {
            $ObjectMdsAssociation = New-Object $DSM7Types["MdsAssociation"]
            $ObjectMdsAssociation.SchemaTag = $Object.SchemaTag
            $ObjectMdsAssociation.SourceObjectID = $Object.SourceObjectID
            $ObjectMdsAssociation.TargetObjectID = $Object.TargetObjectID
            $ObjectMdsAssociation.TargetSchemaTag = $Object.TargetSchemaTag
            $ObjectMdsAssociations += $ObjectMdsAssociation
        }
        $Webrequest.AssociationListToCreate = $ObjectMdsAssociations
        $Webresult = $DSM7WebService.CreateAssociationList($Webrequest).CreatedListOfAssociations
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function Remove-DSM7AssociationObject {
    [CmdletBinding()] 
    param (
        $Object
    ) 
    try {
        $Webrequest = Get-DSM7RequestHeader -action "DeleteAssociation"
        $Webrequest.AssociationToDelete = $Object
        $Webresult = $DSM7WebService.DeleteAssociation($Webrequest)
        return $true
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
###############################################################################
# DSM7 Funktionen - NameList
###############################################################################
function Get-DSM7DisplayNameListsObject {
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        $IDs
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "GetDisplayNameLists"
        $Webrequest.DisplayNameIds = $IDs
        $Webresult = $DSM7WebService.GetDisplayNameLists($Webrequest).DisplayNames
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function Get-DSM7DisplayNameLists {
    <#
    .SYNOPSIS
        Gibt DisplayNameList zurueck.
    .DESCRIPTION
        Gibt DisplayNameList zurueck.
    .EXAMPLE
        Get-DSM7GetDisplayNameLists -IDs 1,2,3,4,5
    .NOTES
    .LINK
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        $IDs
    )
    if (Confirm-Connect) {
        try {
            $result = Get-DSM7DisplayNameListsObject
            if ($result) {
                Write-Log 0 "($IDs) erfolgreich." $MyInvocation.MyCommand
                return $Webresult
            }
            else {
                Write-Log 1 "($IDs) nicht gefunden!" $MyInvocation.MyCommand 
                return $false
            }
        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Get-DSM7DisplayNameLists
###############################################################################
# DSM7 Funktionen - Computer
###############################################################################
function Get-DSM7ComputerList {
    <#
    .SYNOPSIS
        Gibt eine Liste von Computern zurueck.
    .DESCRIPTION
        Gibt eine Liste von Computern zurueck.
    .EXAMPLE
        Get-DSM7ComputerList -LDAPPath "Managed Users & Computers/OU1/OU2" -recursive
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    #>
    [CmdletBinding()] 
    param ( 
        [system.string]$Attributes,
        [system.string]$Filter,
        [system.string]$LDAPPath = "",
        [int]$ParentContID,
        [switch]$GenTypeData = $false,
        [switch]$recursive = $false
    )
    if (Confirm-Connect) {
        if ($LDAPPath) {
            $ParentContID = Get-DSM7LDAPPathID -LDAPPath $LDAPPath
        }
        if ($recursive) {
            if ($ParentContID -gt 0) {
                $result = @()
                $resultComputer = Get-DSM7ObjectList -Attributes $Attributes -Filter "(&(SchemaTag=Computer)$Filter)" -ParentContID $ParentContID -GenTypeData:$GenTypeData
                if ($resultComputer) {
                    $result += $resultComputer
                } 
                $resultContainer = Get-DSM7ObjectList -Filter $DSM7Container -ParentContID $ParentContID -recursive -GenTypeData:$GenTypeData
                foreach ($Container in $resultContainer) {
                    $FilterContainer = "(&(ParentContID=$($Container.ID))(SchemaTag=Computer)$filter)"
                    $resultComputer = Get-DSM7ObjectList -Attributes $Attributes -Filter $FilterContainer -GenTypeData:$GenTypeData
                    if ($resultComputer) {
                        $result += $resultComputer
                    }
                } 
            }
            else {
                $result = Get-DSM7ObjectList -Attributes $Attributes -Filter "(&(SchemaTag=Computer)$Filter)" -ParentContID $ParentContID -GenTypeData:$GenTypeData
            }
        }
        else {
            if ($ParentContID -gt 0) {
                $result = Get-DSM7ObjectList -Attributes $Attributes -Filter "(&(SchemaTag=Computer)$Filter)" -ParentContID $ParentContID -GenTypeData:$GenTypeData
            }
            else {
                $result = Get-DSM7ObjectList -Attributes $Attributes -Filter "(&(SchemaTag=Computer)$Filter)" -GenTypeData:$GenTypeData
            }
        }
        if ($result) {
            return $result
        }
        else {
            return $false
        }
    }
}
Export-ModuleMember -Function Get-DSM7ComputerList
function Get-DSM7Computer {
    <#
    .SYNOPSIS
        Gibt das Computerobjekt zurueck.
    .DESCRIPTION
        Gibt das Computerobjekt zurueck.
    .EXAMPLE
        Get-DSM7Computer -Name "%Computername%"
        Get-DSM7Computer -ID 1234
        Get-DSM7Computer -Name "%Computername%" -LDAPPath "Managed Users & Computers/OU"
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    #>
    [CmdletBinding()] 
    param ( 
        [system.string]$Name,
        [int]$ID,
        [system.string]$LDAPPath,
        [switch]$LDAP = $false
    )
    if (Confirm-Connect) {
        try {
            if ($Name -or $ID -gt 0) {
                if ($ID -eq 0) {
                    $search = Get-DSM7ObjectList -Filter "(Name:IgnoreCase=$Name)(Schematag=Computer)" -LDAPPath $LDAPPath
                    if ($search.Count -lt 2) {
                        $ID = $search.ID
                    }
                    else {
                        Write-Log 1 "($Name) nicht eindeutig bitte LDAPPath benutzen!" $MyInvocation.MyCommand 
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    $result = Get-DSM7ObjectObject -ID $ID
                    if ($result) {
                        $result = Convert-DSM7ObjecttoPSObject($result) -LDAP:$LDAP
                        Write-Log 0 "($($result.Name)) erfolgreich." $MyInvocation.MyCommand
                        return $result
                    }
                    else {
                        Write-Log 1 "Computer nicht gefunden!" $MyInvocation.MyCommand 
                        return $false
                    }
                }
                else {
                    Write-Log 1 "Computer nicht gefunden!" $MyInvocation.MyCommand 
                    return $false
                }
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
            }
        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
} 
Export-ModuleMember -Function Get-DSM7Computer
function Update-DSM7Computer {
    <#
    .SYNOPSIS
        aendert das Computerobjekt.
    .DESCRIPTION
        aendert das Computerobjekt.
    .EXAMPLE
        Update-DSM7Computer -Name "%Computername%" -Values @("Computer.AssetTag=Test")
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    #>
    [CmdletBinding()] 
    param ( 
        [system.string]$Name,
        [int]$ID,
        [system.string]$LDAPPath,
        [string[]]$Values,
        [switch]$LDAP = $false
    ) 
    if (Confirm-Connect) {
        try {
            if ($Name -or $ID -gt 0) {
                if ($ID -eq 0) {
                    $search = Get-DSM7Computer -Name $Name -LDAPPath $LDAPPath
                    if ($search) {
                        $ID = $search.ID
                    }
                    else {
                        Write-Log 1 "Aenderung kann nicht erfolgen!" $MyInvocation.MyCommand 
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    $Computer = Get-DSM7ObjectObject -ID $ID
                    $result = Update-DSM7Object -Object $Computer -Values $Values
                    if ($result) { 
                        $result = Convert-DSM7ObjecttoPSObject($result) -LDAP:$LDAP
                        Write-Log 0 "($($Computer.Name)) erfolgreich." $MyInvocation.MyCommand
                        return $result
                    }
                    else {
                        return $false
                    }
                }
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
            }

        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Update-DSM7Computer

function Reset-DSM7ComputerInstallationOrder {
    [CmdletBinding()] 
    param ( [int]$ID)
    try {
        $Webrequest = Get-DSM7RequestHeader -action "ResetInstallationOrderOfNode"
        $Webrequest.NodeId = $ID
        $Webresult = $DSM7WebService.ResetInstallationOrderOfNode($Webrequest).ResetInstallationOrderOfNodeResult
        Write-Log 0 "Computer ($ID) neue Installationreihenfolge berechnet." $MyInvocation.MyCommand
        return $true
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function Install-DSM7ReinstallComputer {
    [CmdletBinding()] 
    param ( 
        $Computer ,
        [switch]$StartReinstallImmediately,
        [switch]$WakeUp,
        [System.String]$WakeUpTime,
        [switch]$UpdatePolicyInstancesToPolicyStatus
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "ReinstallComputer"
        $Webrequest.Computer = $Computer
        $Webrequest.Options = New-Object $DSM7Types["ReinstallComputerOptions"]
        $Webrequest.Options.StartReinstallImmediately = $StartReinstallImmediately
        if ($WakeUp) {
            $Webrequest.Options.WakeUpForExecutionOptions = New-Object $DSM7Types["WakeUpForExecutionOptions"]
            $Webrequest.Options.WakeUpForExecutionOptions.WakeUpComputer = $WakeUp
            if ($WakeUpTime) {
                $StartDate = $(Get-Date($WakeUpTime)) 
            }
            else {
                $StartDate = $(Get-Date) 
            }
            #$StartDate = $StartDate + [System.TimeZoneInfo]::Local.BaseUtcOffset
            Write-Log 0 "Start Datum ist:($StartDate)" $MyInvocation.MyCommand
            $Webrequest.Options.WakeUpForExecutionOptions.ExecutionStartDate = New-Object $DSM7Types["MdsDateTime"]
            $Webrequest.Options.WakeUpForExecutionOptions.ExecutionStartDate.DateTime = $StartDate
            $Webrequest.Options.WakeUpForExecutionOptions.ExecutionStartDate.IsLocalTime = $true
        }
        $Webrequest.Options.UpdatePolicyInstancesToPolicyStatus = $UpdatePolicyInstancesToPolicyStatus
        $Webresult = $DSM7WebService.ReinstallComputer($Webrequest).ReinstallComputerResult
        Write-Log 0 "Computer auf Reinstall gesetzt." $MyInvocation.MyCommand
        return $true
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function Install-DSM7Computer {
    <#
    .SYNOPSIS
        Installiert den Computer neu.
    .DESCRIPTION
        Installiert den Computer neu.
    .EXAMPLE
        Install-DSM7Computer -Name "%Computername%" -UpgradePolicyInstances -RecalculateInstallationOrder -UpdatePolicyInstancesActive
    .EXAMPLE
        Install-DSM7Computer -Name "%Computername%" -WakeUp
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    #>
    [CmdletBinding()] 
    param ( 
        [system.string]$Name,
        [system.int32]$ID,
        [switch]$RecalculateInstallationOrder,
        [switch]$UpgradePolicyInstances,
        [switch]$UpdatePolicyInstancesActive,
        [switch]$WakeUp,
        [System.string]$WakeupTime
    )
    if (Confirm-Connect) {
        try {
            if ($Name -or $ID -gt 0) {
                if ($ID -eq 0) {
                    $search = Get-DSM7Computer -Name $Name
                    if ($search) {
                        $ID = $search.ID
                    }
                    else {
                        Write-Log 1 "Installation kann nicht erfolgen!" $MyInvocation.MyCommand 
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    if (!($DSM7Version -gt "7.3.0")) {
                        $result = Update-DSM7Computer -ID $ID -Values @("Computer.OperationMode=2")
                    }
                    else {
                        $result = Update-DSM7Computer -ID $ID -Values @("Computer.OperationMode=0")

                    }
                    if ($RecalculateInstallationOrder) {
                        $result = Reset-DSM7ComputerInstallationOrder -ID $ID
                    }
                    if ($UpgradePolicyInstances) {
                        $result = Upgrade-DSM7PolicyInstancesByNodeObject -NodeId $ID
                    } 
                    if ($UpdatePolicyInstancesActive) {
                        $result = Update-DSM7PolicyInstancesActive -ID $ID
                    }
                    if ($DSM7Version -gt "7.3.0") {
                        if (Install-DSM7ReinstallComputer -Computer $(Get-DSM7ObjectObject -ID $ID) -StartReinstallImmediately -UpdatePolicyInstancesToPolicyStatus -WakeUp:$WakeUp -WakeUpTime $WakeupTime) {
                            Write-Log 0 "Computer ($ID) auf Neuinstallation gesetzt." $MyInvocation.MyCommand
                            return $true
                        }
                    } 
                    else {
                        if (Update-DSM7Computer -ID $ID -Values @("Computer.OperationMode=1")) {
                            Write-Log 0 "Computer ($ID) auf Neuinstallation gesetzt." $MyInvocation.MyCommand
                            return $true
                        }
                    }
                }
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
            }
        } 
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Install-DSM7Computer 
function Send-DSM7ComputerWakeUP {
    <#
    .SYNOPSIS
        WakeUP (WOL) den Computer.
    .DESCRIPTION
        WakeUP (WOL) den Computer.
    .EXAMPLE
        WakeUp-DSM7Computer -Name "%Computername%"
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    .LINK
        WakeUp-DSM7Computer
    #>
    [CmdletBinding()] 
    param ( 
        [system.string]$Name,
        [system.int32]$ID
    )
    if (Confirm-Connect) {
        try {
            if ($Name -or $ID -gt 0) {
                if ($ID -eq 0) {
                    $search = Get-DSM7Computer -Name $Name
                    if ($search) {
                        $ID = $search.ID
                    }
                    else {
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    $PropGroupList = @()
                    $computerIdProperty = New-Object $DSM7Types["MdsTypedPropertyOfNullableOfInt32"]
                    $computerIdProperty.Tag = "ComputerId"
                    $computerIdProperty.Type = "ObjectLink"
                    $computerIdProperty.TypedValue = $ID

                    $computerRelatedJobPropGroup = New-Object $DSM7Types["MdsPropGroup"]
                    $computerRelatedJobPropGroup.Tag = "ComputerRelatedJob";
                    $computerRelatedJobPropGroup.PropertyList = @()
                    $computerRelatedJobPropGroup.PropertyList += $computerIdProperty;
                    $PropGroupList += $computerRelatedJobPropGroup

                    $result = New-DSM7InfrastructureJob -PropGroupList $PropGroupList -SchemaTag "WakeUpOnLanJob"
                    if ($result) {
                        Write-Log 0 "WOL erfolgreich versendet." $MyInvocation.MyCommand
                        return $true 
                    }
                }
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
            }
        } 
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Set-Alias WakeUp-DSM7Computer Send-DSM7ComputerWakeUP
Export-ModuleMember -Function Send-DSM7ComputerWakeUP -Alias WakeUp-DSM7Computer
function Send-DSM7ComputerFastInstall {
    <#
    .SYNOPSIS
        FastInstall für den Computer oder PolicyInstanzen.
    .DESCRIPTION
        FastInstall für den Computer oder PolicyInstanzen.
    .EXAMPLE
        Send-DSM7ComputerFastInstall -Name "%Computername%"
    .EXAMPLE
        Send-DSM7ComputerFastInstall -Name "%Computername%" -PolicyInstanceIDs 1,2,3,4
    .EXAMPLE
        Send-DSM7ComputerFastInstall -Name "%Computername%" -IgnoreMaintenanceWindow
    .EXAMPLE
        Send-DSM7ComputerFastInstall -Name "%Computername%" -ShutdownAfterInstallation
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    .LINK
        WakeUp-DSM7Computer
    .LINK
        Send-DSM7ComputerFastInstall
    #>
    [CmdletBinding()] 
    param ( 
        [Parameter(Position = 0, Mandatory = $false)]
        [system.string]$Name,
        [Parameter(Position = 0, Mandatory = $false)]
        [system.int32]$ID,
        [Parameter(Position = 1, Mandatory = $false)]
        [System.Array]$PolicyInstanceIDs,
        [Parameter(Position = 2, Mandatory = $false)]
        [ValidateSet("User", "Service", "Auto")]
        [System.String]$ExecutionContext = "Auto",
        [Parameter(Position = 3, Mandatory = $false)]
        [switch]$IgnoreMaintenanceWindow,
        [Parameter(Position = 4, Mandatory = $false)]
        [switch]$ShutdownAfterInstallation
    )
    if (Confirm-Connect) {
        try {
            if ($Name -or $ID -gt 0) {
                if ($ID -eq 0) {
                    $search = Get-DSM7Computer -Name $Name
                    if ($search) {
                        $ID = $search.ID
                    }
                    else {
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    $PropGroupList = @()
                    $computerIdProperty = New-Object $DSM7Types["MdsTypedPropertyOfNullableOfInt32"]
                    $computerIdProperty.Tag = "ComputerId"
                    $computerIdProperty.Type = "ObjectLink"
                    $computerIdProperty.TypedValue = $ID

                    $executionContextProperty = New-Object $DSM7Types["MdsTypedPropertyOfString"]
                    $executionContextProperty.Tag = "ExecutionContext"
                    $executionContextProperty.Type = "Option"
                    $executionContextProperty.TypedValue = $ExecutionContext
                    
                    $ignoreMaintenanceWindowProperty = New-Object $DSM7Types["MdsTypedPropertyOfNullableOfBoolean"]
                    $ignoreMaintenanceWindowProperty.Tag = "IgnoreMaintenanceWindow"
                    $ignoreMaintenanceWindowProperty.Type = "Bool"
                    $ignoreMaintenanceWindowProperty.TypedValue = $IgnoreMaintenanceWindow

                    $policyInstancesToExecuteProperty = New-Object $DSM7Types["MdsTypedPropertyOfMdsCollectionOfInt"]
                    $policyInstancesToExecuteProperty.Tag = "PolicyInstancesToExecute"
                    $policyInstancesToExecuteProperty.Type = "CollectionOfInt"
                    $policyInstancesToExecuteProperty.TypedValue = $policyInstancesToExecute

                    $computerRelatedJobPropGroup = New-Object $DSM7Types["MdsPropGroup"]
                    $computerRelatedJobPropGroup.Tag = "ComputerRelatedJob";
                    $computerRelatedJobPropGroup.PropertyList = @()
                    $computerRelatedJobPropGroup.PropertyList += $computerIdProperty

                    $fastInstallJobPropGroup = New-Object $DSM7Types["MdsPropGroup"]
                    $fastInstallJobPropGroup.Tag = "FastInstallJob"
                    $fastInstallJobPropGroup.PropertyList = @()
                    $fastInstallJobPropGroup.PropertyList += $executionContextProperty
                    $fastInstallJobPropGroup.PropertyList += $ignoreMaintenanceWindowProperty
                    $fastInstallJobPropGroup.PropertyList += $policyInstancesToExecuteProperty

                    $PropGroupList += $fastInstallJobPropGroup
                    $PropGroupList += $computerRelatedJobPropGroup
                    
                    $result = New-DSM7InfrastructureJob -PropGroupList $PropGroupList -SchemaTag "FastInstallJob"
                    if ($result) {
                        Write-Log 0 "Fastinstall erfolgreich versendet zu ID($ID)." $MyInvocation.MyCommand
                        return $true 
                    }
                }
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
            }
        } 
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Set-Alias FastInstall-DSM7Computer Send-DSM7ComputerFastInstall
Export-ModuleMember -Function Send-DSM7ComputerFastInstall -Alias FastInstall-DSM7Computer
function New-DSM7Computer {
    <#
    .SYNOPSIS
        Legt ein neues Computerobjekt an.
    .DESCRIPTION
        Legt ein neues Computerobjekt an.
    .EXAMPLE
        New-DSM7Computer -Name "%Computername%" -LDAPPath "Managed Users & Computers/OU1/OU2" -InitialMACAddress "012345678912" -Values @("Computer.ComputerType=Server","Description=Test123")
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    #>
    [CmdletBinding()] 
    param (
        [system.string]$Name,
        [system.string]$LDAPPath,
        [int]$ParentContID,
        [string[]]$Values,
        [system.string]$InitialMACAddress
    )
    if (Confirm-Connect) {
        try {
            $result = Get-DSM7ComputerList -Filter "(BasicInventory.InitialMACAddress:IgnoreCase=$InitialMACAddress)"
            if (!$result) {
                $SchemaTag = "Computer"
                if ($ParentContID -eq 0) {
                    $ParentContID = Get-DSM7LDAPPathID -LDAPPath $LDAPPath
                } 
                $result = New-DSM7Object -Name $Name -ParentContID $ParentContID -SchemaTag $SchemaTag
                $Values += "BasicInventory.InitialMACAddress=" + $InitialMACAddress
                $result = Update-DSM7Object -Object $result -Values $Values
                if ($result) { 
                    $result = Convert-DSM7ObjecttoPSObject($result) -LDAP
                    Write-Log 0 "($Name) erfolgreich in OU ($($result.LDAPPath))." $MyInvocation.MyCommand
                    return $result
                }
                else {
                    return $false
                }
            }
            else {
                Write-Log 1 "Computer mit MAC ($InitialMACAddress) existiert schon!" $MyInvocation.MyCommand
                return $false
            }
        } 
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function New-DSM7Computer 
function Remove-DSM7Computer {
    <#
    .SYNOPSIS
        Loescht ein Computerobjekt.
    .DESCRIPTION
        Loescht ein Computerobjekt.
    .EXAMPLE
         Remove-DSM7Computer -Name "%Computername%"
    .EXAMPLE
         Remove-DSM7Computer -InitialMACAddress "012345678912"
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    #>
    [CmdletBinding()] 
    param (
        [system.string]$Name = "*",
        [int]$ID,
        [system.string]$LDAPPath, 
        [system.string]$InitialMACAddress = "*"
    )
    if (Confirm-Connect) {
        try {
            if ($Name -ne "*" -or $InitialMACAddress -ne "*" -or $ID -gt 0) {
                if ($ID -eq 0) {
                    $search = Get-DSM7ComputerList -Filter "(&(BasicInventory.InitialMACAddress:IgnoreCase=$InitialMACAddress)(Name:IgnoreCase=$Name))" -LDAPPath $LDAPPath
                    if ($search.Count -lt 2) {
                        $ID = $search.ID
                    }
                    else {
                        Write-Log 1 "Loeschen kann nicht erfolgen! Bitte LDAPPath benutzen." $MyInvocation.MyCommand 
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    $Computer = Get-DSM7ObjectObject -ID $ID
                    $result = Remove-DSM7Object -Object $Computer 
                    Write-Log 0 "Computer ($($Computer.Name)) geloescht." $MyInvocation.MyCommand
                    return $true
                }
                else {
                    Write-Log 1 "Computer nicht gefunden!!!" $MyInvocation.MyCommand 
                    return $false
                }
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
                return $false
            }
        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Remove-DSM7Computer 
function Move-DSM7Computer {
    <#
    .SYNOPSIS
        Verschiebt ein Computerobjekt.
    .DESCRIPTION
        Verschiebt ein Computerobjekt.
    .EXAMPLE
        Move-DSM7Computer -Name "%Computername%" -toLDAPPath "Managed Users & Computers/OU1/OU2"
    .NOTES
    .LINK
        Get-DSM7ComputerList
    .LINK
        Get-DSM7Computer
    .LINK
        Update-DSM7Computer
    .LINK
        Install-DSM7Computer
    .LINK
        New-DSM7Computer
    .LINK
        Remove-DSM7Computer
    .LINK
        Move-DSM7Computer
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $false)]
        [system.string]$Name,
        [Parameter(Position = 1, Mandatory = $false)]
        [int]$ID,
        [Parameter(Position = 2, Mandatory = $false)]
        [system.string]$LDAPPath,
        [Parameter(Position = 3, Mandatory = $false)]
        [system.string]$toLDAPPath,
        [Parameter(Position = 4, Mandatory = $false)]
        [Int]$toLDAPPathID
    )
    if (Confirm-Connect) {
        try {
            if (($Name -or $ID -gt 0) -and ($toLDAPPath -or $toLDAPPathID -gt 0) ) {
                if ($ID -eq 0) {
                    $search = Get-DSM7Computer -Name $Name -LDAPPath $LDAPPath
                    if ($search) {
                        $ID = $search.ID
                    }
                    else {
                        Write-Log 1 "Computer kann nicht nach ($toLDAPPath) verschoben werden!" $MyInvocation.MyCommand 
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    if ($toLDAPPathID -gt 0) {
                        $ParentContID = $toLDAPPathID
                    }
                    else {
                        $ParentContID = Get-DSM7LDAPPathID -LDAPPath $toLDAPPath
                    } 
                    $Object = Get-DSM7ObjectObject -ID $ID
                    if ($Object) {
                        if ($Object.ParentContID -eq $ParentContID) {
                            Write-Log 1 "Computer ($Name) befindet sich schon in ($($Object.ParentContID)." $MyInvocation.MyCommand
                            return $false
                        }
                        else {
                            $result = Move-DSM7Object -Object $Object -ParentContID $ParentContID
                            if ($result) { 
                                $result = Convert-DSM7ObjecttoPSObject($result)
                                Write-Log 0 "Computer ($($result.Name)) erfolgreich nach ($($result.ParentContID)) verschoben." $MyInvocation.MyCommand
                                return $true
                            }
                            else {
                                return $false
                            }
                        }
                    }
                    else {
                        Write-Log 1 "Computer kann nicht nach ($toLDAPPath$toLDAPPathID) verschoben werden." $MyInvocation.MyCommand
                    }
                } 
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
                return $false
            }

        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Move-DSM7Computer 
###############################################################################
# DSM7 Funktionen - OrgObjekte
function Get-DSM7OrgTreeContainerObject {
    [CmdletBinding()] 
    param (
        [int]$ID
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "GetOrgTreeContainer"
        $Webrequest.OrgTreeContainerId = $ID
        $Webresult = $DSM7WebService.GetOrgTreeContainer($Webrequest).RetrievedOrgTreeContainer
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function Get-DSM7OrgTreeContainer {
    <#
    .SYNOPSIS
        Gibt ein Containerobjekt zurueck.
    .DESCRIPTION
        Gibt ein Containerobjekt zurueck.
    .EXAMPLE
        Get-DSM7OrgTreeContainer -LDAPPATH "Global Software Library"
    .NOTES
    .LINK
        Get-DSM7OrgTreeContainer
    .LINK
        New-DSM7OrgTreeContainer
    .LINK
        Move-DSM7OrgTreeContainer
    .LINK
        Remove-DSM7OrgTreeContainer
    .LINK
        Update-DSM7OrgTreeContainer
    #>
    [CmdletBinding()] 
    param (
        [system.string]$LDAPPath,
        [int]$ID
    )
    if (Confirm-Connect) {
        try {
            if ($ID -eq 0) {
                $ID = Get-DSM7LDAPPathID -LDAPPath $LDAPPath
            }
            $result = Get-DSM7OrgTreeContainerObject -ID $ID
            if ($result) {
                Write-Log 0 "($LDAPPath) -> ($ID) erfolgreich." $MyInvocation.MyCommand
                $result = Convert-DSM7ObjecttoPSObject($result) -LDAP
                return $result
            }
            else {
                Write-Log 1 "Konnte kein Object finden!" $MyInvocation.MyCommand
            }

        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Get-DSM7OrgTreeContainer 
function Get-DSM7OrgTreeContainersObject {
    [CmdletBinding()] 
    param (
        [System.Array]$IDs
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "GetOrgTreeContainers"
        $Webrequest.OrgTreeContainerIds = $IDs
        $Webresult = $DSM7WebService.GetOrgTreeContainers($Webrequest).OrgTreeContainerList
        return $Webresult
    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 

}
function Get-DSM7OrgTreeContainers {
    <#
    .SYNOPSIS
        Gibt ein Containerobjekt zurueck.
    .DESCRIPTION
        Gibt ein Containerobjekt zurueck.
    .EXAMPLE
        Get-DSM7OrgTreeContainers -IDs (xxx,yyy)
    .NOTES
    .LINK
        Get-DSM7OrgTreeContainer
    .LINK
        New-DSM7OrgTreeContainer
    .LINK
        Move-DSM7OrgTreeContainer
    .LINK
        Remove-DSM7OrgTreeContainer
    .LINK
        Update-DSM7OrgTreeContainer
    #>
    [CmdletBinding()] 
    param (
        [System.Array]$IDs
    )
    if (Confirm-Connect) {
        try {
            $result = Get-DSM7OrgTreeContainersObject -IDs $IDs
            if ($result) {
                Write-Log 0 "($IDs) erfolgreich." $MyInvocation.MyCommand
                $result = Convert-DSM7ObjectListtoPSObject($result) 
                return $result
            }
            else {
                Write-Log 1 "Konnte kein Object finden!" $MyInvocation.MyCommand
            }

        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Get-DSM7OrgTreeContainers 

function New-DSM7OrgTreeContainerObject {
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true)]
        [system.string]$Name,
        [Parameter(Position = 1, Mandatory = $false)]
        [system.string]$Description,
        [Parameter(Position = 2, Mandatory = $false)]
        [system.string]$SchemaTag = "OU",
        [Parameter(Position = 3, Mandatory = $true)]
        [system.string]$ParentContID
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "CreateOrgTreeContainer"
        $Webrequest.NewOrgTreeContainer = New-Object $DSM7Types["MdsOrgTreeContainer"]
        $Webrequest.NewOrgTreeContainer.Name = $Name
        $Webrequest.NewOrgTreeContainer.SchemaTag = $SchemaTag
        $Webrequest.NewOrgTreeContainer.Description = $Description
        $Webrequest.NewOrgTreeContainer.ParentContID = $ParentContID
        if ($DSM7Version -gt "7.4.0") {
            $Webrequest.NewOrgTreeContainer.GenTypeData = new-object $DSM7Types["MdsGenType"]
            $CreationSource = $MyInvocation.MyCommand.Module.Name
            if ($DSM7CreationSource) { $CreationSource = $DSM7CreationSource }
            $Webrequest.NewOrgTreeContainer.GenTypeData.CreationSource = $CreationSource
        }
        $Webresult = $DSM7WebService.CreateOrgTreeContainer($Webrequest).CreatedOrgTreeContainer
        Write-Log 0 "($($Webresult.Name)) ($($Webresult.ID)) erfolgreich." $MyInvocation.MyCommand
        return $Webresult

    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function New-DSM7OrgTreeContainer {
    <#
    .SYNOPSIS
        Erstellt ein Containerobjekt.
    .DESCRIPTION
        Erstellt ein Containerobjekt.
    .EXAMPLE
        New-DSM7OrgTreeContainer -Name "OU2" -LDAPPATH "Managed Users & Computers/OU1"
    .NOTES
    .LINK
        Get-DSM7OrgTreeContainer
    .LINK
        New-DSM7OrgTreeContainer
    .LINK
        Move-DSM7OrgTreeContainer
    .LINK
        Remove-DSM7OrgTreeContainer
    .LINK
        Update-DSM7OrgTreeContainer
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $true, HelpMessage = "Name der OU")]
        [system.string]$Name,
        [Parameter(Position = 1, Mandatory = $false)]
        [system.string]$Description,
        [Parameter(Position = 2, Mandatory = $false)]
        [ValidateSet("OU", "Domain", "CitrixFarm", "CitrixZone", "SwFolder")]
        [system.string]$SchemaTag = "OU",
        [Parameter(Position = 3, Mandatory = $true)]
        [system.string]$LDAPPath
    )
    if (Confirm-Connect) {
        try {
            $ParentContID = Get-DSM7LDAPPathID -LDAPPath $LDAPPath
            $result = New-DSM7OrgTreeContainerObject -Name $Name -Description $Description -SchemaTag $SchemaTag -ParentContID $ParentContID
            if ($result) {
                Write-Log 0 "($Name) ($LDAPPath) erfolgreich erstellt." $MyInvocation.MyCommand
                $result = Convert-DSM7ObjecttoPSObject($result) -LDAP
                return $result
            }
            else {
                Write-Log 1 "Kein Objekt erzeugt!" $MyInvocation.MyCommand
            }
        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function New-DSM7OrgTreeContainer

function Move-DSM7OrgTreeContainerObject {
    [CmdletBinding()] 
    param (
        $Object,
        [system.string]$ParentContID
    )
    try {
        $ParentContObject = Get-DSM7OrgTreeContainerObject -ID $ParentContID
        $Webrequest = Get-DSM7RequestHeader -action "MoveOrgTreeContainer"
        $Webrequest.OrgTreeContainerToMove = $Object
        $Webrequest.NewParentOrgTreeContainer = $ParentContObject
        $Webresult = $DSM7WebService.MoveOrgTreeContainer($Webrequest).MovedOrgTreeContainer 
        Write-Log 0 "($Name) ($($Webresult.ID)) erfolgreich." $MyInvocation.MyCommand
        return $Webresult

    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function Move-DSM7OrgTreeContainer {
    <#
    .SYNOPSIS
        Verschiebt ein Containerobjekt.
    .DESCRIPTION
        Verschiebt ein Containerobjekt.
    .EXAMPLE
        Move-DSM7OrgTreeContainer -Name "OU2" -toLDAPPath "Managed Users & Computers/OU1"
    .NOTES
    .LINK
        Get-DSM7OrgTreeContainer
    .LINK
        New-DSM7OrgTreeContainer
    .LINK
        Move-DSM7OrgTreeContainer
    .LINK
        Remove-DSM7OrgTreeContainer
    .LINK
        Update-DSM7OrgTreeContainer
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $false)]
        [system.string]$Name,
        [Parameter(Position = 1, Mandatory = $false)]
        [int]$ID,
        [Parameter(Position = 2, Mandatory = $false)]
        [system.string]$LDAPPath,
        [Parameter(Position = 3, Mandatory = $true)]
        [system.string]$toLDAPPath
    )
    if (Confirm-Connect) {
        try {
            if ($Name -or $ID -gt 0) {
                if ($ID -eq 0) {
                    $search = Get-DSM7ObjectList -Filter "(&(Name:IgnoreCase=$Name)$DSM7Structure)" -LDAPPath $LDAPPath
                    if ($search) {
                        $ID = $search.ID
                    }
                    else {
                        Write-Log 1 "Container nicht gefunden, kann nicht nach ($toLDAPPath) verschoben werden!" $MyInvocation.MyCommand 
                        return $false
                    }
                }
                if ($ID -gt 0) {
                    $Object = Get-DSM7OrgTreeContainerObject -ID $ID
                    if ($Object) {
                        $ParentContID = Get-DSM7LDAPPathID -LDAPPath $toLDAPPath
                        if ($ParentContID) {
                            $result = Move-DSM7OrgTreeContainerObject -Object $Object -ParentContID $ParentContID
                            if ($result) {
                                Write-Log 0 "($($Object.Name)) ($toLDAPPath) erfolgreich verschoben." $MyInvocation.MyCommand
                                $result = Convert-DSM7ObjecttoPSObject($result) -LDAP
                                return $result
                            }
                            else {
                                Write-Log 1 "($($Object.Name)) ($toLDAPPath) konnte nicht ausgefuehrt werden." $MyInvocation.MyCommand
                                return $false
                            }
                        }
                        else {
                            Write-Log 1 "Ziel Container ($LDAPPATH) nicht vorhanden." $MyInvocation.MyCommand
                            return $false
                        }
                    }
                }
            }
            else {
                Write-Log 1 "Name oder ID nicht angegeben!!!" $MyInvocation.MyCommand 
                return $false
            }

        }
        catch [system.exception] {
            Write-Log 2 $_ $MyInvocation.MyCommand 
            return $false 
        } 
    }
}
Export-ModuleMember -Function Move-DSM7OrgTreeContainer
function Update-DSM7OrgTreeContainerObject {
    [CmdletBinding()] 
    param (
        $Object
    )
    try {
        $Webrequest = Get-DSM7RequestHeader -action "UpdateOrgTreeContainer"
        $Webrequest.OrgTreeContainerToUpdate = $Object
        $Webresult = $DSM7WebService.UpdateOrgTreeContainer($Webrequest).UpdatedOrgTreeContainer
        Write-Log 0 "($Name) ($($Webresult.ID)) erfolgreich." $MyInvocation.MyCommand
        return $Webresult

    }
    catch [system.exception] {
        Write-Log 2 $_ $MyInvocation.MyCommand 
        return $false 
    } 
}
function Update-DSM7OrgTreeContainer {
    <#
    .SYNOPSIS
        aendert ein Containerobjekt.
    .DESCRIPTION
        aendert ein Containerobjekt.
    .EXAMPLE
        Update-DSM7OrgTreeContainer -Name "OU2" -Description "OU" -LDAPPath "Managed Users & Computers/OU1"
    .NOTES
    .LINK
        Get-DSM7OrgTreeContainer
    .LINK
        New-DSM7OrgTreeContainer
    .LINK
        Move-DSM7OrgTreeContainer
    .LINK
        Remove-DSM7OrgTreeContainer
    .LINK
        Update-DSM7OrgTreeContainer
    #>
    [CmdletBinding()] 
    param (
        [Parameter(Position = 0, Mandatory = $false)]
        [system.string]$Name,
        [Parameter(Position = 1, Mandatory = $false)]
        [int]$ID,
        [Parameter(Position =