# PowerShell 4.0 Script
# EMC² QuickScan Job Script zur automatischen
# Abarbeitung von Scan Dateien.

# Digital Data
# Ludwig-Rinn-Strasse 16
# 35452 Heuchelheim
# Tel.: 0641 / 202360
# E-Mail: info@didalog.de
 
# Version 1.0
# Letzte Aktualisierung: 05.08.2014

# Mindestanforderung für dieses Skript:
# Microsoft Windows 7 SP1 / Server 2008 R2 SP1 -> siehe KB976932
# Microsoft .NET Framework 4.5 -> siehe KB2858728
# Microsoft PowerShell 4.0 -> siehe KB2819745

# WICHTIG: Falls sich dieses Skript nicht ausführen lässt, 
# muss dieser PS-Befehl noch mit administrativen Rechten ausgeführt werden:
# set-executionpolicy unrestricted

#Requires –Version 4.0

#-----------------------------------------------------------------------------------------------------
############################ Zusätzliche Assemblys hinzufügen bzw. laden. ############################
#-----------------------------------------------------------------------------------------------------

#-----------------------------------------------------------------------------------------------------
######################################## Variablen definieren. #######################################
#-----------------------------------------------------------------------------------------------------

Set-Variable -Name ScriptName                            -Value (($MyInvocation.MyCommand.Name) -split "\.")[0].ToString()	-Scope script
Set-Variable -Name ScriptPath                            -Value (Split-Path ($MyInvocation.MyCommand.Path))                 -Scope script
Set-Variable -Name ConfigFile                            -Value "$ScriptPath\$ScriptName`_Settings.ini"                     -Scope script
Set-Variable -Name ConfigValues                          -Value $NULL                                                       -Scope script
Set-Variable -Name Timestamp1                            -Value $(Get-Date -Format 'ddMMyyyy_HHmmss')	                    -Scope script
Set-Variable -Name Fehler                                -Value $NULL                                                       -Scope local
Set-Variable -Name LogDatei                              -Value "$ScriptName`_$ZeitStempel1.log"        	                -Scope script
Set-Variable -Name LogEintrag	                         -Value $NULL 									                    -Scope local
Set-Variable -Name LogPathListe 	                     -Value $NULL                                       		        -Scope script
Set-Variable -Name LogPath                               -Value $NULL                                                       -Scope script
Set-Variable -Name LogPathEintrag                        -Value $NULL									                    -Scope script
Set-Variable -Name LogKeepTime                           -Value 60                                                          -Scope script
Set-Variable -Name FileDelayAge                          -Value 5                                                           -Scope script
Set-Variable -Name Item 		                         -Value $NULL									                    -Scope local
Set-Variable -Name Items 		                         -Value $NULL									                    -Scope local
Set-Variable -Name Path 		                         -Value $NULL									                    -Scope local
Set-Variable -Name PathTest		                         -Value $NULL									                    -Scope local
Set-Variable -Name ProzessTest                           -Value $NULL									                    -Scope local
Set-Variable -Name VersionSeperator                      -Value '~'   									                    -Scope local
Set-Variable -Name FileSeperator                         -Value ''

Set-Variable -Name QSEXEFile                             -Value $NULL                                                       -Scope script
Set-Variable -Name QSProcess                             -Value $NULL                                                       -Scope script
Set-Variable -Name QSEXEArgument1                        -Value $NULL                                                       -Scope script
Set-Variable -Name QSEXEArgument2                        -Value $NULL                                                       -Scope script
Set-Variable -Name QSEXEArgument3                        -Value $NULL                                                       -Scope script
Set-Variable -Name QSFileWhiteList                       -Value $NULL                                                       -Scope script
Set-Variable -Name QSFileBlackList                       -Value $NULL                                                       -Scope script
Set-Variable -Name QSProfileExtension                    -Value *.qsp                                                       -Scope script
Set-Variable -Name QSProfilePath                         -Value $NULL                                                       -Scope script
Set-Variable -Name QSProfileListe                        -Value $NULL									                    -Scope script
Set-Variable -Name QSProfileEintrag                      -Value $NULL                                                       -Scope script

Set-Variable -Name PDFCreatorEXE                         -Value $NULL                                                       -Scope script
Set-Variable -Name PDFCreatorConvertMasterSwitch         -Value $NULL                                                       -Scope script
Set-Variable -Name PDFCreatorConvertGlobal               -Value $NULL                                                       -Scope script
Set-Variable -Name PDFCreatorFileWhiteList               -Value $NULL                                                       -Scope script
Set-Variable -Name PDFCreatorFileBlackList               -Value $NULL                                                       -Scope script
Set-Variable -Name PDFCreatorProcess                     -Value $NULL                                                       -Scope script
Set-Variable -Name PDFCreatorEXEArgument1                -Value '/NOSTART /IF"'                                             -Scope script
Set-Variable -Name PDFCreatorEXEArgument2                -Value ""                                                          -Scope script
Set-Variable -Name PDFCreatorEXEArgument3                -Value '"/OF"'                                                     -Scope script
Set-Variable -Name PDFCreatorEXEArgument4                -Value ""                                                          -Scope script
Set-Variable -Name PDFCreatorEXEArgument5                -Value '"/DeleteIF /OutputSubFormat"PDF/A-1b"'                     -Scope script

Set-Variable -Name InputPath                             -Value "E:\Dokumentverarbeitung\Input"                             -Scope script
Set-Variable -Name TempPath                              -Value "E:\Dokumentverarbeitung\Temp"                              -Scope script
Set-Variable -Name OutputPath                            -Value "E:\Dokumentverarbeitung\Output"                            -Scope script
Set-Variable -Name ArchivPath                            -Value "E:\Dokumentverarbeitung\Archiv"                            -Scope script
Set-Variable -Name ArchivRemove                          -Value 60                                                          -Scope script

Set-Variable -Name RunEXE                                -Value $NULL                                                       -Scope script
Set-Variable -Name RunEXETimeout                         -Value 300                                                         -Scope script
Set-Variable -Name RunEXEZeile                           -Value $NULL                                                       -Scope script
Set-Variable -Name RunEXEListe                           -Value $NULL                                                       -Scope script
Set-Variable -Name RunCMD                                -Value $NULL                                                       -Scope script
Set-Variable -Name RunCMDTimeout                         -Value 300                                                         -Scope script
Set-Variable -Name RunCMDZeile                           -Value $NULL                                                       -Scope script
Set-Variable -Name RunCMDListe                           -Value $NULL                                                       -Scope script
Set-Variable -Name RunVBS                                -Value $NULL                                                       -Scope script
Set-Variable -Name RunVBSTimeout                         -Value 300                                                         -Scope script
Set-Variable -Name RunVBSZeile                           -Value $NULL                                                       -Scope script
Set-Variable -Name RunVBSListe                           -Value $NULL                                                       -Scope script
Set-Variable -Name RunPSS                                -Value $NULL                                                       -Scope script
Set-Variable -Name RunPSSTimeout                         -Value 300                                                         -Scope script
Set-Variable -Name RunPSSZeile                           -Value $NULL                                                       -Scope script
Set-Variable -Name RunPSSListe                           -Value $NULL                                                       -Scope script

#-----------------------------------------------------------------------------------------------------
####################################### Funktionen definieren. #######################################
#-----------------------------------------------------------------------------------------------------

Function Func-Path-Check {
  	<#
	  	.SYNOPSIS
	  	Function will check the given Path for existence.
	  	.DESCRIPTION
	  	Function will check the given Path for existence. If Path isn´t existence Function will try to create it.
	  	.REQUIREMENT
		PowerShell V2 and Function "Func-Write-Logfile".
		.VERSION
		1.0 / 06.11.2014
		.EXAMPLE
	  	Func-Path-Check -Path "E:\Path\to\check"
	  	.EXAMPLE
	  	Func-Path-Check -Path "E:\Path\to\create"
	  	.PARAMETER Path
		Give the full Path you want to check or create.
	#>
	
	Param
  	(
		[String]$Path
    )
	
    $PathTest = Test-Path -PathType Container $Path
	Func-Write-Logfile -LogEintrag "Checking Path $Path for existence."
	IF ($PathTest -eq "True")
		{
			Func-Write-Logfile -LogEintrag "Path $Path is already existence and can be used."
		}
	ELSE
		{
            Try
                {			
                    Func-Write-Logfile -LogEintrag "Path $Path has to been created."
			        New-Item -Path $Path -ItemType directory -force -ErrorAction Stop
                }

            Catch
                {
                    Func-Write-Logfile -LogEintrag "ERROR: Unable to create Path."
                    Func-Write-Logfile -LogEintrag "INFO: Maybe there is an access or rights Problem."
                    Func-Write-Logfile -LogEintrag "Application was unplannd terminated."
                    EXIT
                }
		}
}

# Funktion um Logdateien zu schreiben. 
Function Func-Write-Logfile {

  	<#
	  	.SYNOPSIS
	  	Function will write a given string to a logfile.
	  	.DESCRIPTION
	  	Function will write a given string to a logfile. 
	  	.REQUIREMENT
		PowerShell V2 and Function "Func-Write-Logfile".
		.VERSION
		1.0 / 06.11.2014
		.EXAMPLE
	  	Func-Path-Check -Path "E:\Path\to\check"
	  	.EXAMPLE
	  	Func-Path-Check -Path "E:\Path\to\create"
	  	.PARAMETER Path
		Give the full Path you want to check or create.
	#>

	Param 
	(
		[String]$LogEintrag
	)

        # Der Fehlerindikator ($?) muss bereits zu Anfang abgefragt werden, 
        # da er von JEDEM funktionierenden Befehl wieder auf True gesetzt wird.
        IF ($? -ne 'True')
            {
                Set-Variable -Name Fehler -Value 1
            }

        IF ($LogPath -eq $NULL)
            {
                
                Set-Variable -Name LogPathListe -Value @($LogPathListe)
                Set-Variable -Name LogPathListe -Value  ($LogPathListe += "$ScriptPath\Logs","$env:temp")  
                
                FOREACH ($LogPathEintrag in $LogPathListe)
                    {
                        $PathTest = Test-Path  -PathType Container "$LogPathEintrag"
	                    Write-Host "Pathüberprüfung: Prüfe ob LogPath bereits angelegt ist: $LogPathEintrag"
	                        IF ($PathTest -eq "True")
		                        {
			                        Write-Host "Pathüberprüfung: LogPath $LogPathEintrag ist bereits angelegt!"
                                    Set-Variable -Name LogPath     -Value $LogPathEintrag 
                                    break
		                        }
	                        ELSE
		                        {
			                        Write-Host "Pathüberprüfung: LogPath $LogPathEintrag muss angelegt werden."
			                        New-Item -Path $LogPathEintrag -ItemType directory -force -ErrorAction SilentlyContinue | Out-Null
			                        $PathTest = Test-Path  -PathType Container $LogPathEintrag
			                        Write-Host "Pathüberprüfung: Prüfe ob Path erfolgreich angelegt werden konnte."
			                            IF ($PathTest -eq "True")
				                            {
					                            Write-Host "Pathüberprüfung: Path $LogPathEintrag wurde erfolgreich angelegt."
                                                Set-Variable -Name LogPath     -Value $LogPathEintrag
                                                break
				                            }
			                            ELSE
				                            {
					                            Write-Host "Pathüberprüfung: Path $LogPathEintrag konnte nicht angelegt werden."
                                                Set-Variable -Name LogPath     -Value $LogPathEintrag
				                            }
		                        }    
                    }  
            }

        ELSEIF ($LogPath -eq $env:temp)
            {
                Write-Warning "FEHLER: LogPath nicht zugreifbar oder nicht korrekt konfiguriert!"
                Write-Warning "INFO: $LogPath - wird nun verwendet!"
                Write-Warning "Programm wird trotzdem fortgesetzt."
            }

    Set-Variable -Name LogPath -Value $LogPath -scope script

	Write-Host $LogEintrag
    Add-content $LogPath\$LogDatei 	-value "$(Get-Date -Format 'dd.MM.yyyy')-$(Get-Date -Format 'HH:mm:ss'): $LogEintrag"

    IF ($Fehler -eq 1)
        {
            Write-Host "Fehlermeldung: $error"
            Add-content $LogPath\$LogDatei 	-value "$(Get-Date -Format 'dd.MM.yyyy')-$(Get-Date -Format 'HH:mm:ss'): Fehlermeldung: $error"
            # Setze Fehlerspeicher zurück
            $error.clear()
        }
}

# Funktion um aus einer kompletten Pathangabe, nur den Dateinamen ohne Endung ausgegeben zu bekommen.
# Bespiel: Eingabe -> "D:\ProgramPath\ProgramName.exe" | Ausgabe -> "ProgrammName"
Function Func-Dateiname_aus_Path
{
    Param
    (
        [Array]$FuncVar
    )

        Write-Host ""
        Write-Host "Pathkonvertierung: Eingabewert - $FuncVar"
        $FuncVar = (split-path "$FuncVar" -Leaf)
        Write-Host "Pathkonvertierung: Path entfernt - $FuncVar"
        $FuncVar = ($FuncVar -split '\.')
        Write-Host "Pathkonvertierung: Dateiname getrennt - $FuncVar"
        $FuncVar = ($FuncVar[0].ToString())
        Write-Host "Pathkonvertierung: Erster Wert aus Array - $FuncVar"

        return $FuncVar
}

# Funktion um einen Dateinamen der Trennzeichen enthält, nur den ersten Wert vor dem ersten Trennzeichen ausgegeben zu bekommen.
# Beispiel: Eingabe -> "Dateiname_4711_1606.pdf" | Ausgabe -> "Dateiname"
Function Func-Dateiname_zerlegen_Dateianfang
{
    Param
    (
        [Array]$FuncVar
    )
        
        write-host ""
        write-host "Dateinamenssplit: Eingabewert - $FuncVar"
        $FuncVar = ($FuncVar -split "$FileSeperator")
        write-host "Dateinamenssplit: Nach dem Split - $FuncVar"
        $FuncVar = ($FuncVar[0].ToString())
        write-host "Dateinamenssplit: Erster Wert aus Array - $FuncVar"
        $FuncVar = ($FuncVar -split "$VersionSeperator")
        write-host "Dateinamenssplit: Nach dem Split - $FuncVar"
        $FuncVar = ($FuncVar[0].ToString())
        write-host "Dateinamenssplit: Erster Wert aus Array - $FuncVar"

        return $FuncVar
}

# Funktion um einen Dateinamen der Trennzeichen enthält, nur den ersten Wert vor dem ersten Trennzeichen ausgegeben zu bekommen.
# Beispiel: Eingabe -> "4711_1606_Dateiname.pdf" | Ausgabe -> "Dateiname"
Function Func-Dateiname_zerlegen_Dateiende
{
    Param
    (
        [Array]$FuncVar
    )
        
        write-host ""
        write-host "Dateinamenssplit: Eingabewert - $FuncVar"
        $FuncVar = ($FuncVar -split "$FileSeperator")
        write-host "Dateinamenssplit: Nach dem Split - $FuncVar"
        $FuncVar = ($FuncVar[-1].ToString())
        write-host "Dateinamenssplit: Letzter Wert aus Array - $FuncVar"
        $FuncVar = ($FuncVar -split "$VersionSeperator")
        write-host "Dateinamenssplit: Nach dem Split - $FuncVar"
        $FuncVar = ($FuncVar[0].ToString())
        write-host "Dateinamenssplit: Erster Wert aus Array - $FuncVar"

        return $FuncVar
}

# Funktion um eine Textdatei (ASCII), komplett einzulesen.
Function Func-ReadConfigFile
{
    Param
    (
        [String]$ConfigFile
    )

        Write-Host ""
		Write-Host "Prüfe ob Konfigurationsdatei: $ConfigFile vorhanden ist."
        $DateiTest = Test-Path  -PathType Leaf $ConfigFile
		    IF ($DateiTest -eq "True")
				{
					Write-Host "Konfigurationsdatei ist vorhanden, fahre fort."
				}
			ELSE
				{
					Func-Write-Logfile -LogEintrag "FEHLER: Konfigurationsdatei ist nicht vorhanden!"
					Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
                    EXIT
				}

        Write-Host "Konfigurationsdatei wird nun eingelesen."
        Set-Variable -Name ConfigValues -Value (Select-String -path $ConfigFile -pattern "=" | where {-not($_-match  "#")})
            IF ($ConfigValues -eq $Null)
                {
                    Write-Host "Keine gültigen Werte in Konfigurationsdatei erkannt!"
                }
            ELSE
                {
                    Write-Host "Es wurden"$ConfigValues.count"Zeilen aus der Konfigurationsdatei eingelesen."
                    #Write-Host "Folgende Werte wurden eingelesen:" 
                    #Write-Host "$ConfigValues"
                }

        Set-Variable -Name ConfigValues -Value $ConfigValues -Scope script
}

# Funktion um eine Textdatei (ASCII), komplett einzulesen.
# Gibt immer nur einen Wert zurück!
Function Func-ReadConfigValue
{
    Param
    (
        [String]$KonfigBezeichner
    )

        $Items = ($ConfigValues.line | select-string -pattern "$KonfigBezeichner")
            IF ($Items -eq $NULL)
                {
                    Write-Host "Der gesuchte Bezeichner ($KonfigBezeichner) konnte nicht gefunden werden!"
                    Write-Host "Standardwert wird verwendet!"
                    $KonfigBezeichner = (Get-Variable -Name $KonfigBezeichner -ValueOnly)
                    return $KonfigBezeichner
                }

            ELSEIF ($Items.GetType() -like "*Microsoft.PowerShell.Commands.MatchInfo*" -or $Items.GetType() -like "*String*")
                {
                    $Items = ($Items -split "=")
                    $Items = @($Items)
                    $Items = $Items[1]
                    $Items = ($Items.TrimStart())
                    $Items = ($Items.TrimEnd())
                    return $Items
                }

            ELSEIF ($Items -is [Array])
                {
                    return $Items
                }
}

Function Func-Dateien-zusammensuchen
{
    Param
    (
        [String]$SuchPath,
        [Array]$SuchWhiteList,
        [Array]$SuchBlackList
    )

        Set-Variable -Name SuchWhiteList -Value ($SuchWhiteList -Replace " ","") 
        Set-Variable -Name SuchWhiteList -Value ($SuchWhiteList -Split ",")
        Set-Variable -Name SuchWhiteList -Value ($SuchWhiteList -Split ";")

        Set-Variable -Name SuchBlackList -Value ($SuchBlackList -Replace " ","") 
        Set-Variable -Name SuchBlackList -Value ($SuchBlackList -Split ",")
        Set-Variable -Name SuchBlackList -Value ($SuchBlackList -Split ";")

        $Items = Get-ChildItem -Path "$SuchPath" -include $SuchWhiteList -exclude $SuchBlackList
            IF ($Items -eq $NULL) 
                {
                    Func-Write-Logfile -LogEintrag "Could not find any File(s) in Path: $SuchPath (regard on White and Black Lists)."
                }
            ELSE
                {
                    Func-Write-Logfile -LogEintrag "Could find some File(s) in Path: $SuchPath (regard on White and Black Lists) ..."
                    FOREACH ($Item in $Items)
                        {
                            Func-Write-Logfile -LogEintrag "...one Found is: $Item"
                        }
                    return $Items
                }
}


Function Func-Dateien-Versionieren {

  	<#
	  	.SYNOPSIS
	  	Function will copy or move File(s).
	  	.DESCRIPTION
	  	Function will copy or move File(s). If File already exists in target Path new File will get a Version ~2.
	  	.REQUIREMENT General
		PowerShell V2
		.REQUIREMENT Variables
		Datei, Datei1, DateiName, DateiEndung, DateiTest, DateiVersion,ZielPath, MoveorCopy, QuellPath
		.VERSION
		1.0 / 10.11.2014
		.EXAMPLE
	  	Func-Dateien-Versionieren -Datei "E:\Quellpfad\Test.txt" -ZielPath "E:\Zielpfad" -MoveorCopy move
	  	.EXAMPLE
	  	Func-Dateien-Versionieren -Datei "E:\Quellpfad\Test.txt" -ZielPath "E:\Zielpfad" -MoveorCopy copy
	  	.PARAMETER $Datei
		Give the full Path to an File.
        .PARAMETER $ZielPath
        Give the Target path you want to move or copy the specified File.
        .PARAMETER $MoveOrCopy
        Give this Parameter to determ a copy or a move Order.
	#>

    Param
    (
        [String]$Datei,
        [String]$ZielPath,
        [String]$MoveorCopy
    )

        IF (($MoveorCopy -ne 'move') -and ($MoveorCopy -ne 'copy'))
            {
                    Func-Write-Logfile -LogEintrag "ERROR: Wrong Function call."
                    Func-Write-Logfile -LogEintrag "INFO: Parameter MoveorCopy accepts only 'move' or 'copy'."
                    Func-Write-Logfile -LogEintrag "Application will use the copy Order by default."
                    Set-Variable -Name MoveOrCopy -Value copy -Scope local
            }

        IF (($VersionSeperator -eq $null) -or ($VersionSeperator -eq ''))
            {
                Func-Write-Logfile -LogEintrag "ERROR: Wrong Function call."
                Func-Write-Logfile -LogEintrag "INFO: Variable VersionSeperator is not valid."
                Func-Write-Logfile -LogEintrag "Application was unplannd terminated."
                EXIT
            }


        $QuellPath = (split-path "$Datei")
        $Datei     = (split-path "$Datei" -Leaf)
        
        $DateiTest = Test-Path -PathType Leaf "$ZielPath\$Datei" 
            IF ($DateiTest -eq 'True')
                {
                    Func-Write-Logfile -LogEintrag ""
                    Func-Write-Logfile -LogEintrag "The File already exists in the Target Directory, starting Version Check."

                    $Datei1 = ($Datei -split "$VersionSeperator")
                    $DateiVersion = $Datei1[1]

                    IF ($DateiVersion -eq $NULL)
                        {
                            Func-Write-Logfile -LogEintrag "Sourcefile imcludes no VersionSeperator."
                            
                            $Datei1 = ($Datei -split "\.")
                            
                            $DateiName   = $Datei1[0]
                            $DateiEndung = $Datei1[1]

                            # Um Version ~1 zu überspringen.
                            $DateiVersion++
                        }
                    ELSE
                        {
                            Func-Write-Logfile -LogEintrag "Sourcefile imcludes VersionSeperator."

                            $Datei1 = ($Datei1 -split "\.")

                            $DateiName    = $Datei1[0]
                            $DateiVersion = $Datei1[1]
                            $DateiEndung  = $Datei1[2]

                            $DateiVersion  = $DateiVersion -as [Int]
                        }

                    DO 
                        {
                            Write-Host $DateiVersion; $DateiVersion++
                        }

                    while 
                        (
                            ($DateiTest = Test-Path -Path "$ZielPath\$Dateiname$VersionSeperator$DateiVersion.$DateiEndung") -eq 'True'
                        )


                    IF ($MoveorCopy -eq 'move')
                        {
                             Rename-Item -Path "$QuellPath\$Datei" -NewName "$DateiName$VersionSeperator$DateiVersion.$DateiEndung"
                             Move-Item -Path "$QuellPath\$Dateiname$VersionSeperator$DateiVersion.$DateiEndung" -Destination "$ZielPath" -Force
                             Func-Write-Logfile -LogEintrag "File: $Dateiname$VersionSeperator$DateiVersion.$DateiEndung was moved,"
                        }

                    ELSEIF ($MoveorCopy -eq 'copy')
                        {
                            Copy-Item -Path "$QuellPath\$Datei" -Destination "$QuellPath\$Timestamp1´_$Datei" -Force
                            Rename-Item -Path "$QuellPath\$Timestamp1´_$Datei" -NewName "$DateiName$VersionSeperator$DateiVersion.$DateiEndung"
                            Move-Item -Path "$QuellPath\$Dateiname$VersionSeperator$DateiVersion.$DateiEndung" -Destination "$ZielPath" -Force
                            Func-Write-Logfile -LogEintrag "File: $Dateiname$VersionSeperator$DateiVersion.$DateiEndung was copied,"    
                        }

                    Func-Write-Logfile -LogEintrag "from: $QuellPath to: $ZielPath"

                    Return "$ZielPath\$Dateiname$VersionSeperator$DateiVersion.$DateiEndung"
                }

            ELSE
                {
                    Write-Host "Die Datei ist im ZielPath noch nicht vorhanden, Versionierung wird nicht verwendet."
                    Move-Item -Path "$QuellPath\$Datei" -Destination "$ZielPath" -Force
                    Func-Write-Logfile -LogEintrag "Datei: $Datei wird verschoben."
                    Func-Write-Logfile -LogEintrag "Von: $QuellPath nach: $ZielPath"

                    Return "$ZielPath\$Datei"
                }
}

Function Func-PDFAKonvertierung
{
    Param
    (
        [String]$Datei
    )

        Func-Write-Logfile ""
        Func-Write-Logfile "PDFCreator - PDF/A Konvertierung wird verwendet, bzw. gestartet:"
        Func-Write-Logfile "Now processing this File:"
        Func-Write-Logfile "$Datei"

        $DateiPath = (split-path "$Datei")

        Func-Path-Check -Path "$TempPath\Datei\PDFCreatorKonvertierung"
        $Datei = (Func-Dateien-Versionieren -Datei "$Datei" -ZielPath "$TempPath\Datei\PDFCreatorKonvertierung" -MoveorCopy move )
        
        $PDFCreatorEXEArgument2 = "$Datei"
        $PDFCreatorEXEArgument4 = (split-path "$Datei" -Leaf)
        $PDFCreatorEXEArgument4 = "$DateiPath\$PDFCreatorEXEArgument4"

        Try
            {
                Func-Write-Logfile -LogEintrag "Folgende Datei wird verarbeitet: $PDFCreatorEXEArgument2"
                Start-Process -FilePath "$PDFCreatorEXE" -wait -ArgumentList $PDFCreatorEXEArgument1$PDFCreatorEXEArgument2$PDFCreatorEXEArgument3$PDFCreatorEXEArgument4$PDFCreatorEXEArgument5 -ErrorAction Stop
                Func-Write-Logfile -LogEintrag "Die Datei wurde konvertiert und an ihren Ursprungsort zurück verschoben."
            }

        Catch
            {
				Func-Write-Logfile -LogEintrag "FEHLER: Konvertierung ist fehlgeschlagen!."
                Func-Write-Logfile -LogEintrag "INFO: Bitte überprüfen Sie die PDFCreator Einstellungen!"
                Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
                EXIT
            }

        $Items = (Func-Dateien-zusammensuchen -SuchPath "$TempPath\Datei\PDFCreatorKonvertierung\*" -SuchWhiteList $PDFCreatorFileWhiteList -SuchBlackList $PDFCreatorFileBlackList)
            IF ($Items -ne $Null)
                {
                    Func-Write-Logfile -LogEintrag "ACHTUNG: Möglicherweise gab es einen Verarbeitungsfehler, es sind noch Dateien im Path: $TempPath\Datei\PDFCreatorKonvertierung vorhanden!"
                    Func-Write-Logfile -LogEintrag "Dieser sollte aber nach erfolgreicher Verarbeitung wieder leer sein!"
                }

        Func-Write-Logfile "PDFCreator - PDF/A Konvertierung ist beendet."
}

Function Func-RunCMD
{
    FOREACH ($RunCMDZeile in $RunCMDListe)
        {
            Func-Write-Logfile -LogEintrag ""
            Func-Write-Logfile -LogEintrag "Running specified CMD-Files."
            Write-Host "Folgende Zeilen wurden ausgelesen: --> $RunCMDZeile <--"

            $RunCMDZeile =  ($RunCMDZeile -split "''")
            $RunCMDZeile =  ($RunCMDZeile -split "' '")
            $RunCMDZeile =  ($RunCMDZeile -split "'  '")

            IF ($RunCMDZeile[0] -gt "")
                {
                    Write-Host "Erster übergebender Wert: $($RunCMDZeile[0])"
                    $RunCMDZeile[0] = $RunCMDZeile[0] -replace ("'","")
                    IF ($RunCMDZeile[1] -gt "")
                        {
                            Write-Host "Zweiter übergebender Wert: $($RunCMDZeile[1])"
                            $RunCMDZeile[1] = $RunCMDZeile[1] -replace ("'","")
                            IF ($RunCMDZeile[2] -gt "")
                                {
                                    Write-Host "Dritter übergebender Wert: $($RunCMDZeile[2])"
                                    $RunCMDZeile[2] = $RunCMDZeile[2] -replace ("'","")
                                }
                        }

                    IF ((Test-Path -Path "$($RunCMDZeile[0])" -PathType Leaf) -eq "True")
                        {
                            Try
                                {
                                    Func-Write-Logfile -LogEintrag "Now running CMD-File: $($RunCMDZeile[0])."
                                    write-host "$($RunCMDZeile[0]) $($RunCMDZeile[1]) $($RunCMDZeile[2])"
                                    $RunCMD = Start-Process cmd.exe -ArgumentList "/c $($RunCMDZeile[0]) $($RunCMDZeile[1]) $($RunCMDZeile[2])" -Passthru
                                    Wait-Process -ID $RunCMD.Id -Timeout $RunCMDTimeout -ErrorAction Stop
                                }

                            Catch
                                {
                                    Try
                                        {
                                            Func-Write-Logfile -LogEintrag "Da der definierte Timeout überschritten wurde ($RunCMDTimeout Sekunden), wird nun versucht die Datei / das Programm zu beenden."
                                            Stop-Process -ID $RunCMD.Id -Force -ErrorAction Stop
                                        }

                                    Catch
                                        {
                                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunCMDZeile[0]) - kann nicht beendet werden."
                                            Func-Write-Logfile -LogEintrag "INFO: Möglicherweise müssen Sie den Computer neustarten!"
                                            Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
                                            break
                                        }
                
                                }
                        }

                    ELSE
                        {
                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunCMDZeile[0]) - kann nicht ausgeführt werden."
                            Func-Write-Logfile -LogEintrag "INFO: Die Datei / das Programm ist nicht vorhanden oder es kann nicht auf sie zugegiffen werden."
                            Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                        }
                }

            ELSE
                {
                    Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE es wurde keine Datei / oder ein Programm zur Ausführung angegeben."
                    Func-Write-Logfile -LogEintrag "INFO: Überprüfen Sie Ihre Konfigurationsdatei!"
                    Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                }
        }
}

Function Func-RunEXE
{
    FOREACH ($RunEXEZeile in $RunEXEListe)
        {
            Func-Write-Logfile -LogEintrag ""
            Func-Write-Logfile -LogEintrag "Starte Ausführung für EXE-Dateien."
            Write-Host "Folgende Zeilen wurden ausgelesen: --> $RunEXEZeile <--"

            $RunEXEZeile =  ($RunEXEZeile -split "''")
            $RunEXEZeile =  ($RunEXEZeile -split "' '")
            $RunEXEZeile =  ($RunEXEZeile -split "'  '")

            IF ($RunEXEZeile[0] -ne "")
                {
                    $RunEXEZeile[0] = $RunEXEZeile[0] -replace ("'","")
                    IF ($RunEXEZeile[1] -ne $NULL)
                        {
                            $RunEXEZeile[1] = $RunEXEZeile[1] -replace ("'","")
                            IF ($RunEXEZeile[2] -ne "")
                                {
                                    $RunEXEZeile[2] = $RunEXEZeile[2] -replace ("'","")
                                }
                        }

                    IF ((Test-Path -Path "$($RunEXEZeile[0])" -PathType Leaf) -eq "True")
                        {
                            Try
                                {
                                    Func-Write-Logfile -LogEintrag "Starte die Datei / das Programm $($RunEXEZeile[0])."
                                    $RunEXE = Start-Process "$($RunEXEZeile[0])" -ArgumentList "$RunEXEZeile[1] $RunEXEZeile[2]" -Passthru
                                    Wait-Process -ID $RunEXE.Id -Timeout $RunEXETimeout -ErrorAction Stop
                                }

                            Catch
                                {
                                    Try
                                        {
                                            Func-Write-Logfile -LogEintrag "Da der definierte Timeout überschritten wurde ($RunEXETimeout Sekunden), wird nun versucht die Datei / das Programm zu beenden."
                                            Stop-Process -ID $RunEXE.Id -Force -ErrorAction Stop
                                        }

                                    Catch
                                        {
                                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunEXEZeile[0]) - kann nicht beendet werden."
                                            Func-Write-Logfile -LogEintrag "INFO: Möglicherweise müssen Sie den Computer neustarten!"
                                            Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
                                            break
                                        }
                
                                }
                        }

                    ELSE
                        {
                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunEXEZeile[0]) - kann nicht ausgeführt werden."
                            Func-Write-Logfile -LogEintrag "INFO: Die Datei / das Programm ist nicht vorhanden oder es kann nicht auf sie zugegiffen werden."
                            Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                        }
                }

            ELSE
                {
                    Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE es wurde keine Datei / oder ein Programm zur Ausführung angegeben."
                    Func-Write-Logfile -LogEintrag "INFO: Überprüfen Sie Ihre Konfigurationsdatei!"
                    Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                }
        }
}

Function Func-RunVBS
{
    FOREACH ($RunVBSZeile in $RunVBSListe)
        {
            Func-Write-Logfile -LogEintrag ""
            Func-Write-Logfile -LogEintrag "Starte Ausführung für VB-Skripte."
            Write-Host "Folgende Zeilen wurden ausgelesen: --> $RunVBSZeile <--"

            $RunVBSZeile =  ($RunVBSZeile -split "''")
            $RunVBSZeile =  ($RunVBSZeile -split "' '")
            $RunVBSZeile =  ($RunVBSZeile -split "'  '")

            IF ($RunVBSZeile[0] -gt "")
                {
                    Write-Host "Erster übergebender Wert: $($RunVBSZeile[0])"
                    $RunVBSZeile[0] = $RunVBSZeile[0] -replace ("'","")
                    IF ($RunVBSZeile[1] -gt "")
                        {
                            Write-Host "Zweiter übergebender Wert: $($RunVBSZeile[1])"
                            $RunVBSZeile[1] = $RunVBSZeile[1] -replace ("'","")
                            IF ($RunVBSZeile[2] -gt "")
                                {
                                    Write-Host "Dritter übergebender Wert: $($RunVBSZeile[2])"
                                    $RunVBSZeile[2] = $RunVBSZeile[2] -replace ("'","")
                                }
                        }

                    IF ((Test-Path -Path "$($RunVBSZeile[0])" -PathType Leaf) -eq "True")
                        {
                            Try
                                {
                                    Func-Write-Logfile -LogEintrag "Starte die Datei / das Programm $($RunVBSZeile[0])."
                                    $RunVBS = Start-Process wscript.exe -ArgumentList "$($RunVBSZeile[0]) $($RunVBSZeile[1]) $($RunVBSZeile[2])" -Passthru
                                    Wait-Process -ID $RunVBS.Id -Timeout $RunVBSTimeout -ErrorAction Stop
                                }

                            Catch
                                {
                                    Try
                                        {
                                            Func-Write-Logfile -LogEintrag "Da der definierte Timeout überschritten wurde ($RunVBSTimeout Sekunden), wird nun versucht die Datei / das Programm zu beenden."
                                            Stop-Process -ID $RunVBS.Id -Force -ErrorAction Stop
                                        }

                                    Catch
                                        {
                                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunVBSZeile[0]) - kann nicht beendet werden."
                                            Func-Write-Logfile -LogEintrag "INFO: Möglicherweise müssen Sie den Computer neustarten!"
                                            Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
                                            break
                                        }
                
                                }
                        }

                    ELSE
                        {
                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunVBSZeile[0]) - kann nicht ausgeführt werden."
                            Func-Write-Logfile -LogEintrag "INFO: Die Datei / das Programm ist nicht vorhanden oder es kann nicht auf sie zugegiffen werden."
                            Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                        }
                }

            ELSE
                {
                    Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE es wurde keine Datei / oder ein Programm zur Ausführung angegeben."
                    Func-Write-Logfile -LogEintrag "INFO: Überprüfen Sie Ihre Konfigurationsdatei!"
                    Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                }
        }
}

Function Func-RunPSS
{
    FOREACH ($RunPSSZeile in $RunPSSListe)
        {
            Func-Write-Logfile -LogEintrag ""
            Func-Write-Logfile -LogEintrag "Starte Ausführung für PS-Skripte."
            Write-Host "Folgende Zeilen wurden ausgelesen: --> $RunPSSZeile <--"

            $RunPSSZeile =  ($RunPSSZeile -split "''")
            $RunPSSZeile =  ($RunPSSZeile -split "' '")
            $RunPSSZeile =  ($RunPSSZeile -split "'  '")

            IF ($RunPSSZeile[0] -gt "")
                {
                    Write-Host "Erster übergebender Wert: $($RunPSSZeile[0])"
                    $RunPSSZeile[0] = $RunPSSZeile[0] -replace ("'","")
                    IF ($RunPSSZeile[1] -gt "")
                        {
                            Write-Host "Zweiter übergebender Wert: $($RunPSSZeile[1])"
                            $RunPSSZeile[1] = $RunPSSZeile[1] -replace ("'","")
                            IF ($RunPSSZeile[2] -gt "")
                                {
                                    Write-Host "Dritter übergebender Wert: $($RunPSSZeile[2])"
                                    $RunPSSZeile[2] = $RunPSSZeile[2] -replace ("'","")
                                }
                        }

                    IF ((Test-Path -Path "$($RunPSSZeile[0])" -PathType Leaf) -eq "True")
                        {
                            Try
                                {
                                    Func-Write-Logfile -LogEintrag "Starte die Datei / das Programm $($RunPSSZeile[0])."
                                    write-host "$($RunPSSZeile[0]) $($RunPSSZeile[1]) $($RunPSSZeile[2])"
                                    $RunPSS = Start-Process powershell.exe -ArgumentList "$($RunPSSZeile[0]) $($RunPSSZeile[1]) $($RunPSSZeile[2])" -Passthru
                                    Wait-Process -ID $RunPSS.Id -Timeout $RunPSSTimeout -ErrorAction Stop
                                }

                            Catch
                                {
                                    Try
                                        {
                                            Func-Write-Logfile -LogEintrag "Da der definierte Timeout überschritten wurde ($RunPSSTimeout Sekunden), wird nun versucht die Datei / das Programm zu beenden."
                                            Stop-Process -ID $RunPSS.Id -Force -ErrorAction Stop
                                        }

                                    Catch
                                        {
                                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunPSSZeile[0]) - kann nicht beendet werden."
                                            Func-Write-Logfile -LogEintrag "INFO: Möglicherweise müssen Sie den Computer neustarten!"
                                            Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
                                            break
                                        }
                
                                }
                        }

                    ELSE
                        {
                            Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE die Datei / das Programm - $($RunPSSZeile[0]) - kann nicht ausgeführt werden."
                            Func-Write-Logfile -LogEintrag "INFO: Die Datei / das Programm ist nicht vorhanden oder es kann nicht auf sie zugegiffen werden."
                            Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                        }
                }

            ELSE
                {
                    Func-Write-Logfile -LogEintrag "FEHLER: bei RunEXE es wurde keine Datei / oder ein Programm zur Ausführung angegeben."
                    Func-Write-Logfile -LogEintrag "INFO: Überprüfen Sie Ihre Konfigurationsdatei!"
                    Func-Write-Logfile -LogEintrag "Programm wird trotzdem fortgesetzt."
                }
        }
}

#-----------------------------------------------------------------------------------------------------
####################################### Vorbereitende Arbeiten. ######################################
#-----------------------------------------------------------------------------------------------------

# Lösche evtl. anzeigen. 
Clear-Host

# Konfigurationsdatei komplett einlesen.
Func-ReadConfigFile -ConfigFile $ConfigFile

# Werte aus Konfigurationsdatei bereitstellen.
$LogPathListe                          = (Func-ReadConfigValue -KonfigBezeichner LogPath)
$LogKeepTime                           = (Func-ReadConfigValue -KonfigBezeichner LogKeepTime)
$FileDelayAge                          = (Func-ReadConfigValue -KonfigBezeichner FileDelayAge)
$VersionSeperator                      = (Func-ReadConfigValue -KonfigBezeichner VersionSeperator)

$QSEXEFile                             = (Func-ReadConfigValue -KonfigBezeichner QSEXEFile)
$QSEXESingleInstance                   = (Func-ReadConfigValue -KonfigBezeichner QSEXESingleInstance)
$QSProfilePath                         = (Func-ReadConfigValue -KonfigBezeichner QSProfilePath)
$QSProfileExtension                    = (Func-ReadConfigValue -KonfigBezeichner QSProfileExtension)
$QSFileWhiteList                       = (Func-ReadConfigValue -KonfigBezeichner QSFileWhiteList)
$QSFileBlackList                       = (Func-ReadConfigValue -KonfigBezeichner QSFileBlackList)

$PDFCreatorEXE                         = (Func-ReadConfigValue -KonfigBezeichner PDFCreatorEXE)
$PDFCreatorEXESingleInstance           = (Func-ReadConfigValue -KonfigBezeichner PDFCreatorEXESingleInstance)
$PDFCreatorConvertMasterSwitch         = (Func-ReadConfigValue -KonfigBezeichner PDFCreatorConvertMasterSwitch)
$PDFCreatorConvertGlobal               = (Func-ReadConfigValue -KonfigBezeichner PDFCreatorConvertGlobal)
$PDFCreatorFileWhiteList               = (Func-ReadConfigValue -KonfigBezeichner PDFCreatorFileWhiteList)
$PDFCreatorFileBlackList               = (Func-ReadConfigValue -KonfigBezeichner PDFCreatorFileBlackList)

$InputPath                             = (Func-ReadConfigValue -KonfigBezeichner InputPath)
$TempPath                              = (Func-ReadConfigValue -KonfigBezeichner TempPath)
$OutputPath                            = (Func-ReadConfigValue -KonfigBezeichner OutputPath)
$ArchivPath                            = (Func-ReadConfigValue -KonfigBezeichner ArchivPath)
$ArchivRemove                          = (Func-ReadConfigValue -KonfigBezeichner ArchivRemove)

$RunCMDListe                           = (Func-ReadConfigValue -KonfigBezeichner RunCMDEntry?)
$RunCMDTimeout                         = (Func-ReadConfigValue -KonfigBezeichner RunCMDTimeout)
$RunEXEListe                           = (Func-ReadConfigValue -KonfigBezeichner RunEXEEntry?)
$RunEXETimeout                         = (Func-ReadConfigValue -KonfigBezeichner RunEXETimeout)
$RunVBSListe                           = (Func-ReadConfigValue -KonfigBezeichner RunVBSEntry?)
$RunVBSTimeout                         = (Func-ReadConfigValue -KonfigBezeichner RunVBSTimeout)
$RunPSSListe                           = (Func-ReadConfigValue -KonfigBezeichner RunPSSEntry?)
$RunPSSTimeout                         = (Func-ReadConfigValue -KonfigBezeichner RunPSSTimeout)

#-----------------------------------------------------------------------------------------------------
####################################### Hauptprogramm starten. #######################################
#-----------------------------------------------------------------------------------------------------
Write-Host ""
Func-Write-Logfile -LogEintrag "*******************************************************************************************"
Func-Write-Logfile -LogEintrag "Program Startup: $ScriptName on $env:computername from Account $env:USERDOMAIN\$env:USERNAME."
Func-Write-Logfile -LogEintrag "*******************************************************************************************"

# Prüfe ob der hinterlegte Path für das QuickScan gültig ist.
$DateiTest = Test-Path  -PathType Leaf $QSEXEFile
	IF ($DateiTest -eq "True")
		{
			Write-Host "QuickScan seems to exist, going ahead with Application."
		}
	ELSE
		{
			Func-Write-Logfile -LogEintrag "FEHLER: QuickScan ist nicht vorhanden!"
            Func-Write-Logfile -LogEintrag "INFO: Überprüfen Sie die Path-Einstellungen in der Konfigurationsdatei!"
			Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
            EXIT
		}

# Setze QuickScan Profil-Path anhand der QSEXE und prüfe ob der Path vorhanden ist.
$QSProfilePath = (split-path "$QSEXEFile")
Set-Variable -Name QSProfilePath -Value $QSProfilePath\Profiles\Scan

Write-Host ""
Write-Host "Prüfe ob QuickScan Profil-Path vorhanden ist: $QSProfilePath"
$PathTest = Test-Path  -PathType Container $QSProfilePath
    IF ($PathTest -eq "True")
		{
			Write-Host "Path ist vorhanden, fahre fort."
		}
	ELSE
        {
            Func-Write-Logfile -LogEintrag "FEHLER: QuickScan-ProfilPath ist nicht vorhanden!"
            Func-Write-Logfile -LogEintrag "INFO: Überprüfen Sie die Path-Einstellungen in der Konfigurationsdatei!"
            Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
            EXIT
        }

# Suche. bzw. trage QuickScan Profile zusammen.
Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-Logfile -LogEintrag "Searching for QuickScan Profiles - File Extension: $QSProfileExtension"
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"

$QSProfileListe = (Func-Dateien-zusammensuchen -SuchPath "$QSProfilePath\*" -SuchWhiteList $QSProfileExtension)

    IF ($QSProfileListe -eq $null)
        {
            Func-Write-Logfile -LogEintrag "ERROR: Cannot find any valid QuickScan Profil!"
            Func-Write-Logfile -LogEintrag "INFO: Profile die den Textstring - Test - enthalten werden ignoriert!." 
            Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
            EXIT
        }

# Ordnerstruktur anhand gefundene QuickScan Profile überprüfen bzw. anlegen.
Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-Logfile -LogEintrag "Auf Grundlage der QuickScan Profile, müssen folgende Verzeichnisse im Dokumentverarbeitung Verzeichnis vorhanden sein."
Func-Write-Logfile -LogEintrag "Sind sie nicht vorhanden, werden sie automatisch angelegt."
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"

FOREACH ($QSProfileEintrag in $QSProfileListe)
    {
        $QSProfileEintrag = Func-Dateiname_aus_Path -FuncVar $QSProfileEintrag
        Func-Write-Logfile -LogEintrag "Verzeichnisse für QuickScan Profil - $QSProfileEintrag - werden nun bearbeitet:"
        Func-Path-Check -Path $InputPath\Datei\$QSProfileEintrag
        Func-Path-Check -Path $TempPath\Datei\$QSProfileEintrag
        Func-Path-Check -Path $OutputPath\Datei
        Func-Path-Check -Path $ArchivPath\Datei\$QSProfileEintrag
    }

# Prüfe ob bereits eine QuickScan Instanz gestartet ist, falls ja -> sofort beenden.
Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-Logfile -LogEintrag "Checking for an running QuickScan Instance."
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"

Set-Variable -Name QSProzess -Value (Func-Dateiname_aus_Path -FuncVar $QSEXEFile)
$ProzessTest = get-process $QSProzess -ErrorAction SilentlyContinue
    IF ($ProzessTest -eq $null)
        {
            Func-Write-Logfile -LogEintrag "It seems there is currently no QuickScan Instance runnnig, going ahead with Application."
        }
    ELSE
        {
            Func-Write-Logfile -LogEintrag "QuickScan Instance found, trying Stop this Instance."
            Stop-Process -InputObject (get-process $QSProzess -ErrorAction SilentlyContinue) -Force      -ErrorAction SilentlyContinue
            Wait-Process -InputObject (get-process $QSProzess -ErrorAction SilentlyContinue) -timeout 60 -ErrorAction SilentlyContinue
            Start-Sleep -s 3
            $ProzessTest = get-process $QSProzess -ErrorAction SilentlyContinue
                IF ($ProzessTest -ne $null)
                    {
                        Func-Write-Logfile -LogEintrag "FEHLER: Es konnten nicht alle QuickScan Instanzen beendet werden."
                        Func-Write-Logfile -LogEintrag "Programm wird ungeplant beendet."
                        EXIT
                    }
         }

# Prüfe anhand des Input Verzeichnisses, ob abzuarbeitende Dateien vorhanden sind und starte Abarbeitung dieser, mit QuickScan.
Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-Logfile -LogEintrag "Prüfen ob abzuarbeitende Dateien vorhanden sind und starte ggf. Abarbeitung."
Func-Write-Logfile -LogEintrag "Berücksichtigt werden Dateien, mit folgenden DateiEndungen: $QSFileWhiteList."
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"

Func-Write-Logfile -LogEintrag "Depending on your configuration, the processing will be compound on multiple Steps:"
Func-Write-Logfile -LogEintrag "Step 1 QuickScan-Job, Step 2 possibly PDF/A Convert and Step 3. possibly processing by further 3rd Party Program(s)."
Func-Write-Logfile -LogEintrag "All of these Steps will be run through an whole QuickScan Profile."

    FOREACH ($QSProfileEintrag in $QSProfileListe)
        {
            # Warte bis gefundene Dateien ein gewisses Alter erreicht haben, bevor Sie verarbeitet werden.
            Set-Variable -Name QSProfile -Value (Func-Dateiname_aus_Path -FuncVar $QSProfileEintrag)

            Func-Write-Logfile -LogEintrag ""
            Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
            Func-Write-Logfile -LogEintrag "QuickScan Profile $($QSProfile): Will now beginn the processing."

            Func-Write-Logfile -LogEintrag "Checking this Input Path for unprocessed Files:"
            Func-Write-Logfile -LogEintrag "$InputPath\Datei\$QSProfile"

            $Items = (Func-Dateien-zusammensuchen -SuchPath "$InputPath\Datei\$QSProfile\*" -SuchWhiteList $QSFileWhiteList  -SuchBlackList $QSFileBlackList | where-object {$_.lastwritetime -lt (get-date).addminutes(-$FileDelayAge)} )#| Foreach-Object { $_.FullName } )
                IF ($Items -eq $null)
                    {
                        Func-Write-Logfile -LogEintrag "Currently there are no unprocessed Files."
                    }

                ELSE
                    {
                        Func-Write-Logfile -LogEintrag "Starting QuickScan with Profile: $QSProfile."
                        FOREACH ($Item in $Items)
                            {
                                Func-Dateien-Versionieren -Datei $Item -ZielPath "$ArchivPath\Datei\$QSProfile" -MoveorCopy copy
                                Func-Write-Logfile -LogEintrag "QuickScan Profile $QSProfile is now processing File: $Item"
                                Start-Process -FilePath "$QSEXEFile" -wait -ArgumentList "/open filename=$Item /scan profile=$QSProfile"  -PassThru
                            }

                        Func-Write-Logfile -LogEintrag ""
                        Func-Write-Logfile -LogEintrag "QuickScan Profile $($QSProfile): Checking for PDF/A convert."

                        # Konvertiere (sofern eingeschaltet) Dateien in PDF/A-1B.
                        # Dateien müssen nach diesem Schritt unbedingt verschoben verschoben werden, sonst werden sie immer wieder und wieder konvertiert.
                        IF (($PDFCreatorConvertMasterSwitch -like 'Eingeschaltet') -or ($PDFCreatorConvertMasterSwitch -like 'Engaged'))
                            {

                                Func-Write-Logfile -LogEintrag "PDF/A-1B Convert with PDFCreator is enabled."
                                Func-Write-Logfile -LogEintrag "Check the Configuration of the PDFCreator, please:"
                                Func-Write-Logfile -LogEintrag "It is important to disable the automatically Update Function."

                                # Prüfe ob der hinterlegte Path für den PDFCreator gültig ist.
                                $DateiTest = Test-Path  -PathType Leaf $PDFCreatorEXE
		                            IF ($DateiTest -eq "True")
				                        {
					                        Write-Host "It seems that the PDFCreator exists, going ahead with Application."
                                            # Prüfe ob PDFCreator bereits läuft und versuche ihn zu beenden.
                                            Set-Variable -Name PDFCreatorProzess -Value (Func-Dateiname_aus_Path -FuncVar $PDFCreatorEXE)
                                            $ProzessTest = get-process $PDFCreatorProzess -ErrorAction SilentlyContinue
                                                IF ($ProzessTest -ne $null)
                                                    {
                                                        Func-Write-Logfile -LogEintrag "PDFCreator Instanz vorhanden, versuche diese nun zu beenden."
                                                        Stop-Process -InputObject (get-process $PDFCreatorProzess -ErrorAction SilentlyContinue) -Force       -ErrorAction SilentlyContinue
                                                        Wait-Process -InputObject (get-process $PDFCreatorProzess -ErrorAction SilentlyContinue) -timeout 60  -ErrorAction SilentlyContinue
                                                        Start-Sleep -s 3
                                                        $ProzessTest = get-process $PDFCreatorProzess -ErrorAction SilentlyContinue
                                                            IF ($ProzessTest -ne $null)
                                                                {
                                                                    Func-Write-Logfile -LogEintrag "FEHLER: Es konnten nicht alle PDFCreator Instanzen beendet werden."
                                                                    Func-Write-Logfile -LogEintrag "Konvertierung wird vorsichtshalber übersprungen."
                                                                    break
                                                                }
                                                    }

                                                IF (($PDFCreatorConvertGlobal -like 'Ja') -or ($PDFCreatorConvertGlobal -like 'Yes'))
                                                    {
                                                        Func-Write-Logfile -LogEintrag "PDF/A-1B Konvertierung mithilfe des PDFCreators, ist eingeschaltet."
                                                        Func-Write-Logfile -LogEintrag "Durchsuche $OutputPath\Datei nach zu konvertierenden Dateien. Es werden nur $PDDFCreatorDateiEndung-Dateien berücksichtigt! "
                                                        Func-Path-Check -Path "$TempPath\Datei\PDFCreatorKonvertierung"
                                                        $Items = (Func-Dateien-zusammensuchen -SuchPath "$OutputPath\Datei\*" -SuchWhiteList $PDFCreatorFileWhiteList -SuchBlackList $PDFCreatorFileBlackList)
                                                            IF ($Items -eq $Null)
                                                                {
                                                                    Func-Write-Logfile -LogEintrag "Keine zu konvertierenden Dateien gefunden."
                                                                }

                                                            ELSE
                                                                {
                                                                    FOREACH ($Item in $Items)
                                                                        {
                                                                            Func-PDFAKonvertierung -Datei "$Item"
                                                                        }
                                                                }
                                                    }
				                        }

			                        ELSE
				                        {
					                        Func-Write-Logfile -LogEintrag "FEHLER: PDFCreator ist nicht vorhanden!"
					                        Func-Write-Logfile -LogEintrag "Konvertierung wird vorsichtshalber übersprungen."
				                        }
                            }


                        ELSE
                            {
                                Func-Write-Logfile "PDF/A-1B convert with PDFCreator is disabled."
                            }   

                        Func-Write-Logfile -LogEintrag ""
                        Func-Write-Logfile -LogEintrag "QuickScan Profile $($QSProfile): Starting possibly 3.rd Party Application (EXE-File, CMD-Script, VB-Script or/and PS-Script)."

                        # Starte Funktionen um Fremd-Programme aufzurufen.
                        Func-RunEXE
                        Func-RunCMD
                        Func-RunVBS
                        Func-RunPSS

                        Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
                    }
        }

#-----------------------------------------------------------------------------------------------------
####################################### Abschließende Arbeiten. ######################################
#-----------------------------------------------------------------------------------------------------

# Temp Dateien nach Verarbeitung löschen 
Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-Logfile -LogEintrag "Checking for temporary Files and if exists delete them."
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
FOREACH ($QSProfileEintrag in $QSProfileListe)
    {
        $QSProfile = Func-Dateiname_aus_Path -FuncVar $QSProfileEintrag
        Func-Write-Logfile -LogEintrag "Checking the path below for temporary Files:"
        Func-Write-Logfile -LogEintrag " $TempPath\Datei\$QSProfile"
        $Items = (Func-Dateien-zusammensuchen -SuchPath "$TempPath\Datei\$QSProfile\*" )
        IF ($Items -ne $null)
            {
                FOREACH ($Item in $Items)
                    {
                        Try
                            {
                                Func-Write-Logfile -LogEintrag "Removing File: $Item."
                                Remove-Item -Path "$Item" -Force -Verbose -ErrorAction Stop
                            }

                        Catch
                            {
                                Func-Write-Logfile -LogEintrag "ERROR: Unable to remove File!"
                                Func-Write-Logfile -LogEintrag "INFO: Maybe there is an access or rights Problem."
                                Func-Write-Logfile -LogEintrag "Going ahead with Application."
                            }
                    }
            }

        ELSE
            {
                Func-Write-Logfile -LogEintrag "Currently there are no temporary Files in this Folder."
            }

    }

Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-Logfile -LogEintrag "Checking for expiered archived Files and if exists delete them."
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
    IF ($ArchivRemove -gt 0)
        {
            FOREACH ($QSProfileEintrag in $QSProfileListe)
                {
                    $QSProfile = Func-Dateiname_aus_Path -FuncVar $QSProfileEintrag
                    Func-Write-Logfile -LogEintrag "Checking the path below for temporary Files:"
                    Func-Write-Logfile -LogEintrag " $TempPath\Datei\$QSProfile"
                    $Items = (Func-Dateien-zusammensuchen -SuchPath "$ArchivPath\Datei\$QSProfile\*" | where {$_.lastwritetime -lt $((Get-Date).AddDays(-$ArchivRemove)) -and -not $_.psiscontainer})
                    IF ($Items -ne $null)
                        {
                            FOREACH ($Item in $Items)
                                {
                                    Try
                                        {
                                            Func-Write-Logfile -LogEintrag "Removing File: $Item."
                                            Remove-Item -Path "$Item" -Force -Verbose -ErrorAction Stop
                                        }

                                    Catch
                                        {
                                            Func-Write-Logfile -LogEintrag "ERROR: Unable to remove File!"
                                            Func-Write-Logfile -LogEintrag "INFO: Maybe there is an access or rights Problem."
                                            Func-Write-Logfile -LogEintrag "Going ahead with Application."
                                        }
                                }
                        }

                    ELSE
                        {
                            Func-Write-Logfile -LogEintrag "Currently there are no archived Files in this Folder."
                        }
                }
        }

    ELSE
        {
            Func-Write-Logfile -LogEintrag "The configuration says, never remove any archived Files!"
        }


# Löschen alter Log-Dateien.
Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-Logfile -LogEintrag "Prüfe ob zu löschende Log-Dateien vorhanden sind."
Func-Write-Logfile -LogEintrag "-------------------------------------------------------------------------------------------"
    IF ($LogKeepTime -gt 0)
        {
            Func-Write-Logfile -LogEintrag "Log Files should be removed which are older than $LogKeepTime Day(s)."
            $Items = (Func-Dateien-zusammensuchen -SuchPath "$LogPath\*" -SuchWhiteList *.log | where {$_.Name -like "*$ScriptName*" -and $_.lastwritetime -lt $((Get-Date).AddDays(-$LogKeepTime)) -and -not $_.psiscontainer})
                IF ($Items -eq $null)
                    {
                        Func-Write-Logfile -LogEintrag "Keine zu löschenden Log-Dateien vorhanden."
                    }
                ELSE
                    {
                        Func-Write-Logfile -LogEintrag "Dateien gefunden, folgende Log-Dateien werden aufgund ihres alters gelöscht:"
                        FOREACH ($Item in $Items)
                            {
                                Func-Write-Logfile -LogEintrag "Log-Datei: $Item wird entfernt."
                                Remove-Item -Path $Item -Force -Verbose
                            }
                    }
        }
    ELSE
        {
            Func-Write-Logfile -LogEintrag "Sie haben in der Konfigurationsdatei angegeben, das Log Dateien nicht automatisch gelöscht werden sollen!"
        }

Func-Write-Logfile -LogEintrag ""
Func-Write-Logfile -LogEintrag "*******************************************************************************************"
Func-Write-Logfile -LogEintrag "Program Finish: $ScriptName on $env:computername from Account $env:USERDOMAIN\$env:USERNAME."
Func-Write-Logfile -LogEintrag "*******************************************************************************************"

# Definierte Variablen wieder löschen, damit sie nicht im Arbeitsspeicher verbleiben.
Remove-Variable -Name Skript*                 -Force
Remove-Variable -name Konfig*                 -Force
Remove-Variable -name ZeitStempel*            -Force
Remove-Variable -name Log*                    -Force
Remove-Variable -name FileDelayAge            -Force
Remove-Variable -Name Item*		              -Force
#Remove-Variable -Name *Path*	              -Force
Remove-Variable -Name *Datei*	              -Force
Remove-Variable -Name *Test*	              -Force

Remove-Variable -Name QSEXE*                  -Force
Remove-Variable -Name QSProfile*               -Force

Remove-Variable -Name PDFCreator*             -Force

Remove-Variable -Name RunEXE*                 -Force
Remove-Variable -Name RunCMD*                 -Force
Remove-Variable -Name RunVBS*                 -Force
Remove-Variable -Name RunPSS*                 -Force

$error.clear()