# PowerShell 4.0 Script
# EMC² QuickScan Job Script zur automatischen
# Abarbeitung und Sortierung 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 XP SP3 / 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. ############################
#-----------------------------------------------------------------------------------------------------

[void][System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic')
[void][System.Reflection.Assembly]::LoadwithPartialName("System.Windows.Forms") 

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

Set-Variable -Name SkriptName                       -Value (($MyInvocation.MyCommand.Name) -split "\.")[0].ToString()	 -Scope script
Set-Variable -Name SkriptPfad                       -Value (Split-Path ($MyInvocation.MyCommand.Path))                   -Scope script
Set-Variable -Name KonfigDatei                      -Value "$SkriptPfad\$SkriptName`_Settings.ini"                       -Scope script
Set-Variable -Name KonfigWerte                      -Value $NULL                                                         -Scope script
Set-Variable -Name ZeitStempel1                     -Value $(Get-Date -Format 'ddMMyyyy_HHmmss')	                     -Scope script
Set-Variable -Name ZeitStempel2                     -Value $NULL                                                         -Scope script
Set-Variable -Name Fehler                           -Value $NULL                                                         -Scope local
Set-Variable -Name FehlerOrdnerSchalter             -Value $NULL                                                         -Scope local
Set-Variable -Name LogDatei                         -Value "$SkriptName`_$ZeitStempel1.log"        	                     -Scope script
Set-Variable -Name LogEintrag	                    -Value $NULL 									                     -Scope local
Set-Variable -Name LogPfadListe 	                -Value $NULL                                       		             -Scope script
Set-Variable -Name LogPfad                          -Value $NULL                                                         -Scope script
Set-Variable -Name LogPfadEintrag                   -Value $NULL									                     -Scope script
Set-Variable -Name LogEntfernen                     -Value 60                                                            -Scope script
Set-Variable -Name DateiTrennzeichen                -Value "_"                                                           -Scope script
Set-Variable -Name DateiVerzögerung                 -Value 5                                                             -Scope script
Set-Variable -Name Funde 		                    -Value $NULL									                     -Scope local
Set-Variable -Name Fund 		                    -Value $NULL									                     -Scope local
Set-Variable -Name Pfad 		                    -Value $NULL									                     -Scope local
Set-Variable -Name PfadTest		                    -Value $NULL									                     -Scope local
Set-Variable -Name Zähler                           -Value 0                                                             -Scope local

Set-Variable -Name QSEXE                            -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 QSProfilEndung                   -Value qsc                                                           -Scope script
Set-Variable -Name QSProfilPfad                     -Value $NULL                                                         -Scope script
Set-Variable -Name QSProfilListe                    -Value $NULL									                     -Scope script
Set-Variable -Name QSProfilEintrag                  -Value $NULL                                                         -Scope script

Set-Variable -Name PDFCreatorEXE                    -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 InputPfad                        -Value "E:\Dokumentenverarbeitung\Input"                             -Scope script
Set-Variable -Name ArchivPfad                       -Value "E:\Dokumentenverarbeitung\Archiv"                            -Scope script
Set-Variable -Name TempPfad                         -Value "E:\Dokumentenverarbeitung\Temp"                              -Scope script
Set-Variable -Name OutputPfad                       -Value "E:\Dokumentenverarbeitung\Output"                            -Scope script
Set-Variable -Name OutputPfadArbeitsOrdnernZuletzt  -Value $NULL                                                         -Scope script
Set-Variable -Name OutputPfadArbeitsOrdnernAktuell  -Value $NULL                                                         -Scope script
Set-Variable -Name OutputPfadArbeitsOrdnernZunächst -Value $NULL                                                         -Scope script
Set-Variable -Name ArchivEntfernen                  -Value 60                                                            -Scope script
Set-Variable -Name FehlerOrdner                     -Value "unklassifiziert"                                             -Scope script

Set-Variable -Name OutputRegelZeile                 -Value $NULL                                                         -Scope script
Set-Variable -Name OutputRegelListe                 -Value $NULL                                                         -Scope script

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

# Funktion um einen Pfad zu überprüfen und ggf. neu anzulegen, inkl. Fehlerbehandlung.
# Ruft Funktion "Func-Write-LogDatei -LogEintrag" auf, um Aktivitäten zu protokollieren.
Function Func-Pfadüberprüfung
{
	Param
  	(
		[String]$Pfad
    )
	
    $PfadTest = Test-Path  -PathType Container $Pfad
	Func-Write-LogDatei -LogEintrag "Pfadüberprüfung: Prüfe ob Pfad bereits angelegt ist: $Pfad"
	IF ($PfadTest -eq "True")
		{
			Func-Write-LogDatei -LogEintrag "Pfadüberprüfung: Pfad  $Pfad  ist bereits angelegt."
		}
	ELSE
		{
			Func-Write-LogDatei -LogEintrag "Pfadüberprüfung: Pfad  $Pfad  muss angelegt werden."
			New-Item -Path $Pfad -ItemType directory -force -ErrorAction SilentlyContinue | Out-Null
			$PfadTest1 = Test-Path  -PathType Container $Pfad
			Func-Write-LogDatei -LogEintrag "Pfadüberprüfung: Prüfe ob Pfad erfolgreich angelegt werden konnte."
			IF ($PfadTest1 -eq "True")
				{
					Func-Write-LogDatei -LogEintrag "Pfadüberprüfung: Pfad $Pfad wurde erfolgreich angelegt."
				}
			ELSE
				{
					Func-Write-LogDatei -LogEintrag "FEHLER: Pfad $Pfad konnte nicht angelegt werden."
                    Func-Write-LogDatei -LogEintrag "INFO: Bitte überprüfen Sie Ihre Dateisystem Rechte!"
                    Func-Write-LogDatei -LogEintrag "Programm wird ungeplant beendet."
                    EXIT
				}
		}
}

# Funktion um Logdateien zu schreiben. 
Function Func-Write-LogDatei
{
	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 ($LogPfad -eq $NULL)
            {
                
                Set-Variable -Name LogPfadListe -Value @($LogPfadListe)
                Set-Variable -Name LogPfadListe -Value  ($LogPfadListe += "$SkriptPfad\Logs","$env:temp")  
                
                FOREACH ($LogPfadEintrag in $LogPfadListe)
                    {
                        $PfadTest = Test-Path  -PathType Container "$LogPfadEintrag"
	                    Write-Host "Pfadüberprüfung: Prüfe ob LogPfad bereits angelegt ist: $LogPfadEintrag"
	                        IF ($PfadTest -eq "True")
		                        {
			                        Write-Host "Pfadüberprüfung: LogPfad $LogPfadEintrag ist bereits angelegt!"
                                    Set-Variable -Name LogPfad     -Value $LogPfadEintrag 
                                    break
		                        }
	                        ELSE
		                        {
			                        Write-Host "Pfadüberprüfung: LogPfad $LogPfadEintrag muss angelegt werden."
			                        New-Item -Path $LogPfadEintrag -ItemType directory -force -ErrorAction SilentlyContinue | Out-Null
			                        $PfadTest = Test-Path  -PathType Container $LogPfadEintrag
			                        Write-Host "Pfadüberprüfung: Prüfe ob Pfad erfolgreich angelegt werden konnte."
			                            IF ($PfadTest -eq "True")
				                            {
					                            Write-Host "Pfadüberprüfung: Pfad $LogPfadEintrag wurde erfolgreich angelegt."
                                                Set-Variable -Name LogPfad     -Value $LogPfadEintrag
                                                break
				                            }
			                            ELSE
				                            {
					                            Write-Host "Pfadüberprüfung: Pfad $LogPfadEintrag konnte nicht angelegt werden."
                                                Set-Variable -Name LogPfad     -Value $LogPfadEintrag
				                            }
		                        }    
                    }  
            }

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

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

	Write-Host $LogEintrag
    Add-content $LogPfad\$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 $LogPfad\$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 Pfadangabe, nur den Dateinamen ohne Endung ausgegeben zu bekommen.
# Bespiel: Eingabe -> "D:\Programpfad\ProgramName.exe" | Ausgabe -> "ProgrammName"
Function Func-Dateiname_aus_Pfad
{
    Param
    (
        [Array]$FuncVar
    )

        Write-Host ""
        Write-Host "Pfadkonvertierung: Eingabewert - $FuncVar"
        $FuncVar = (split-path "$FuncVar" -Leaf)
        Write-Host "Pfadkonvertierung: Pfad entfernt - $FuncVar"
        $FuncVar = ($FuncVar -split '\.')
        Write-Host "Pfadkonvertierung: Dateiname getrennt - $FuncVar"
        $FuncVar = ($FuncVar[0].ToString())
        Write-Host "Pfadkonvertierung: 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 "$DateiTrennzeichen")
        write-host "Dateinamenssplit: Nach dem Split - $FuncVar"
        $FuncVar = ($FuncVar[0].ToString())
        write-host "Dateinamenssplit: Erster Wert aus Array - $FuncVar"
        $FuncVar = ($FuncVar -split "$VersionsTrennzeichen")
        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 "$DateiTrennzeichen")
        write-host "Dateinamenssplit: Nach dem Split - $FuncVar"
        $FuncVar = ($FuncVar[-1].ToString())
        write-host "Dateinamenssplit: Letzter Wert aus Array - $FuncVar"
        $FuncVar = ($FuncVar -split "$VersionsTrennzeichen")
        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-KonfigDateiEinlesen
{
    Param
    (
        [String]$KonfigDatei
    )

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

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

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

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

        $Funde = ($KonfigWerte.line | select-string -pattern "$KonfigBezeichner")
            IF ($Funde -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 ($Funde.GetType() -like "*Microsoft.PowerShell.Commands.MatchInfo*" -or $Funde.GetType() -like "*String*")
                {
                    $Funde = ($Funde -split "=")
                    $Funde = @($Funde)
                    $Funde = $Funde[1]
                    $Funde = ($Funde.TrimStart())
                    $Funde = ($Funde.TrimEnd())
                    return $Funde
                }

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

# Funktion für eine VBScript-typische Messagebox. Der Inhalt der Meldung wird in die Log Datei geschrieben.
Function Show-MsgBox 
{
  Param
  (
	[Parameter(Mandatory=$true)]
    [String]$Text,  
    [String]$Title = 'Message',
    [String]$Icon = 'YesNo,Information'
  )

 # Add-Type -AssemblyName 'Microsoft.VisualBasic'
  Func-Write-LogDatei -LogEintrag -LogEintrag "MessageBox-Inhalt: $Text"
  [Microsoft.VisualBasic.Interaction]::MsgBox($text, $icon, $title)
}

# Funktion für eine VBScript-typische Inputbox.  Der Inhalt der Abfrage wird in die Log Datei geschrieben.
Function Show-Inputbox 
{
  Param
  (
    [Parameter(Mandatory=$true)]
    [String]$Text,
    [String]$Example,  
    [String]$Title
  )
  Func-Write-LogDatei -LogEintrag -LogEintrag "InputBox-Inhalt: $Text"
  # Add-Type -AssemblyName 'Microsoft.VisualBasic'  
  [Microsoft.VisualBasic.Interaction]::Inputbox($Text, $Title, $Example)
}

Function Func-Dateien-zusammensuchen
{
    Param
    (
        [String]$SuchPfad,
        [String]$SuchDateiEndung
    )
        $Funde = Get-ChildItem -Path $SuchPfad -include *.$SuchDateiEndung -exclude *Test*.$SuchDateiEndung
            IF ($Funde -eq $NULL) 
                {
                    Func-Write-LogDatei -LogEintrag "Im Pfad $SuchPfad, wurden keine Dateien gefunden!"
                }
            ELSE
                {
                    Func-Write-LogDatei -LogEintrag "Im Pfad $SuchPfad, wurde..."
                    FOREACH ($Fund in $Funde)
                        {
                            Func-Write-LogDatei -LogEintrag "...folgende Datei gefunden: $Fund"
                        }
                    return $Funde
                }
}

Function Func-Ordner-zusammensuchen
{
    Param
    (
        [String]$SuchPfad,
        [String]$SuchAusnahme
    )
        $Funde = (Get-ChildItem -Path "$SuchPfad" -Exclude $SuchAusnahme | where {$_.attributes -match "Directory"})
            IF ($Funde -eq $NULL) 
                {
                    Func-Write-LogDatei -LogEintrag "Im Pfad $SuchPfad, wurden keine Ordner gefunden!"
                }
            ELSE
                {
                    Func-Write-LogDatei -LogEintrag "Im Pfad $SuchPfad, wurde..."
                    FOREACH ($Fund in $Funde)
                        {
                            Func-Write-LogDatei -LogEintrag "...folgende Ordner gefunden: $Fund"
                        }
                    return $Funde
                }

}

Function Func-Dateien-Versionieren
{
    Param
    (
        [String]$Datei,
        [String]$ZielPfad
    )

        $QuellPfad = (split-path "$Datei")
        $Datei     = (split-path "$Datei" -Leaf)
        
        $DateiTest = Test-Path -PathType Leaf "$ZielPfad\$Datei" 
            IF ($DateiTest -eq 'True')
                {
                    Func-Write-LogDatei -LogEintrag ""
                    Func-Write-LogDatei -LogEintrag "Die Datei ist im Zielpfad bereits vorhanden, Versionierung wird verwendet."

                    $Datei1 = ($Datei -split "$VersionsTrennZeichen")
                    $DateiVersion = $Datei1[1]
                    
                    IF ($DateiVersion -eq $NULL)
                        {
                            Func-Write-LogDatei -LogEintrag "Quelldatei enthält kein Versionszeichen."
                            
                            $Datei1 = ($Datei -split "\.")
                            
                            $DateiName   = $Datei1[0]
                            $DateiEndung = $Datei1[1]

                            # Um Version ~1 zu überspringen.
                            $DateiVersion++
                        }
                    ELSE
                        {
                            Func-Write-LogDatei -LogEintrag "Quelldatei enthält Versionszeichen."

                            $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 "$ZielPfad\$Dateiname$VersionsTrennZeichen$DateiVersion.$DateiEndung") -eq 'True'
                        )

                    Rename-Item -Path "$QuellPfad\$Datei" -NewName "$DateiName$VersionsTrennZeichen$DateiVersion.$DateiEndung"
                    Move-Item -Path "$QuellPfad\$Dateiname$VersionsTrennZeichen$DateiVersion.$DateiEndung" -Destination "$ZielPfad" -Force
                    Func-Write-LogDatei -LogEintrag "Datei: $Dateiname$VersionsTrennZeichen$DateiVersion.$DateiEndung wird verschoben."
                    Func-Write-LogDatei -LogEintrag "Von: $QuellPfad nach: $ZielPfad"

                    Return "$ZielPfad\$Dateiname$VersionsTrennZeichen$DateiVersion.$DateiEndung"
                }

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

                    Return "$ZielPfad\$Datei"
                }
}

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

        Func-Write-LogDatei ""
        Func-Write-LogDatei "PDFCreator - PDF/A Konvertierung wird verwendet, bzw. gestartet:"
        Func-Write-LogDatei "Folgende Datei wird nun konvertiert:"
        Func-Write-LogDatei "$Datei"

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

        Func-Pfadüberprüfung -Pfad "$TempPfad\Datei\PDFCreatorKonvertierung"
        $Datei = (Func-Dateien-Versionieren -Datei "$Datei" -ZielPfad "$TempPfad\Datei\PDFCreatorKonvertierung")
        
        $PDFCreatorEXEArgument2 = "$Datei"
        $PDFCreatorEXEArgument4 = (split-path "$Datei" -Leaf)
        $PDFCreatorEXEArgument4 = "$DateiPfad\$PDFCreatorEXEArgument4"

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

        $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$TempPfad\Datei\PDFCreatorKonvertierung\*" -SuchDateiEndung $DateiEndung)
            IF ($Funde -ne $Null)
                {
                    Func-Write-LogDatei -LogEintrag "ACHTUNG: Möglicherweise gab es einen Verarbeitungsfehler, es sind noch Dateien im Pfad: $TempPfad\Datei\PDFCreatorKonvertierung vorhanden!"
                    Func-Write-LogDatei -LogEintrag "Dieser sollte aber nach erfolgreicher Verarbeitung wieder leer sein!"
                }
            ELSE
                {
                    Func-Write-LogDatei -LogEintrag "So sollte es nach erfolgreicher Konvertierung auch sein!"
                }

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


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

# Lösche evtl. anzeigen. 
Clear-Host

# Konfigurationsdatei komplett einlesen.
Func-KonfigDateiEinlesen -KonfigDatei $KonfigDatei

# Werte aus Konfigurationsdatei bereitstellen.
$LogPfadliste                          = (Func-KonfigWertAuslesen -KonfigBezeichner LogPfad)
$LogEntfernen                          = (Func-KonfigWertAuslesen -KonfigBezeichner LogEntfernen)
$DateiTrennzeichen                     = (Func-KonfigWertAuslesen -KonfigBezeichner DateiTrennzeichen)
$VersionsTrennzeichen                  = (Func-KonfigWertAuslesen -KonfigBezeichner VersionsTrennzeichen)
$DateiEndung                           = (Func-KonfigWertAuslesen -KonfigBezeichner DateiEndung)
$DateiVerzögerung                      = (Func-KonfigWertAuslesen -KonfigBezeichner DateiVerzögerung)
$QSEXE                                 = (Func-KonfigWertAuslesen -KonfigBezeichner QSEXE)
$QSProfilEndung                        = (Func-KonfigWertAuslesen -KonfigBezeichner QSProfilEndung)

$PDFCreatorEXE                         = (Func-KonfigWertAuslesen -KonfigBezeichner PDFCreatorEXE)
$PDFCreatorKonvertierung_Hauptschalter = (Func-KonfigWertAuslesen -KonfigBezeichner PDFCreatorKonvertierung_Hauptschalter)
$PDFCreatorKonvertierung_Global        = (Func-KonfigWertAuslesen -KonfigBezeichner PDFCreatorKonvertierung_Global)

$InputPfad                             = (Func-KonfigWertAuslesen -KonfigBezeichner InputPfad)
$TempPfad                              = (Func-KonfigWertAuslesen -KonfigBezeichner TempPfad)
$ArchivPfad                            = (Func-KonfigWertAuslesen -KonfigBezeichner ArchivPfad)
$OutputPfad                            = (Func-KonfigWertAuslesen -KonfigBezeichner OutputPfad)
$ArchivEntfernen                       = (Func-KonfigWertAuslesen -KonfigBezeichner ArchivEntfernen)

$FehlerOrdner                          = (Func-KonfigWertAuslesen -KonfigBezeichner FehlerOrdner)
$OutputRegelListe                      = (Func-KonfigWertAuslesen -KonfigBezeichner OutputRegel?)

FOREACH ($OutputRegelZeile in $OutputRegelListe)
    {
        Write-Host ""
        Write-Host "Folgende Zeilen wurden ausgelesen: --> $OutputRegelZeile <--"

        $Zähler++

        IF ($OutputRegelZeile -is [String])
            {
                $OutputRegelZeile = @($OutputRegelZeile)
                $OutputRegelZeile =  ($OutputRegelZeile -split ";")
                $OutputRegelZeile =  ($OutputRegelZeile -split ",")
            }

        ELSE
            {
                $OutputRegelZeile = @($OutputRegelZeile)
                $OutputRegelZeile =  ($OutputRegelZeile -Split "=" )
                $OutputRegelZeile =  ($OutputRegelZeile[1])
                $OutputRegelZeile =  ($OutputRegelZeile -split ";")
                $OutputRegelZeile =  ($OutputRegelZeile -split ",")
            }

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

            # Werte in Array werden auseinandergenommen und neu zusammengefügt, um Leerzeichen zu entfernen.
            FOREACH ($OutputRegelWert in $OutputRegelZeile)
                {
                    $OutputRegelWert = ($OutputRegelWert.TrimStart())
                    $OutputRegelWert = ($OutputRegelWert.TrimEnd())
                    $OutputRegelWerte.Add($OutputRegelWert) 
                }

            IF ($OutputRegelWerte -eq $NULL) 
                {
                    Write-Host "Der erwarteter Wert ist leer!"
                    Write-Host "Standardwert wird eingetragen!"
                        
                    Set-Variable -Name ("OutputRegel"+$Zähler) -value "Standard" -Scope script
                }

            ELSE
                {
                    Write-Host ("OutputRegel"+$Zähler) wurde als Variable gesetzt und hat folgende Werte bekommen: $OutputRegelWerte
                    Set-Variable -Name ("OutputRegel"+$Zähler) -value $OutputRegelWerte -Scope script
                }
    }

#-----------------------------------------------------------------------------------------------------
####################################### Hauptprogramm starten. #######################################
#-----------------------------------------------------------------------------------------------------
Write-Host ""
Func-Write-LogDatei -LogEintrag "*******************************************************************************************"
Func-Write-LogDatei -LogEintrag "Programmstart von $Skriptname auf $env:computername unter dem Konto: $env:USERDOMAIN\$env:USERNAME."
Func-Write-LogDatei -LogEintrag "*******************************************************************************************"

# Prüfe ob der hinterlegte Pfad für das QuickScan gültig ist.
$DateiTest = Test-Path  -PathType Leaf $QSEXE
	IF ($DateiTest -eq "True")
		{
			Write-Host "QuickScan ist vorhanden, fahre fort."
		}
	ELSE
		{
			Func-Write-LogDatei -LogEintrag "FEHLER: QuickScan ist nicht vorhanden!"
			Func-Write-LogDatei -LogEintrag "Programm wird ungeplant beendet."
            EXIT
		}

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

Write-Host ""
Write-Host "Prüfe ob QuickScan Profil-Pfad vorhanden ist: $QSProfilPfad"
$PfadTest = Test-Path  -PathType Container $QSProfilPfad
    IF ($PfadTest -eq "True")
		{
			Write-Host "Pfad ist vorhanden, fahre fort."
		}
	ELSE
        {
            Func-Write-LogDatei -LogEintrag "FEHLER: QuickScan-Pfad ist nicht vorhanden!"
            Func-Write-LogDatei -LogEintrag "Programm wird ungeplant beendet."
            EXIT
        }

# Suche. bzw. trage QuickScan Profile zusammen.
Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-LogDatei -LogEintrag "Suche nach QuickScan Profilen - Dateiendung: $QSProfilEndung"
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"

$QSProfilListe = (Func-Dateien-zusammensuchen -SuchPfad $QSProfilPfad\* -SuchDateiEndung $QSProfilEndung)
    IF ($QSProfilListe -eq $null)
        {
            Func-Write-LogDatei -LogEintrag "FEHLER: Es konnten keine gültigen QuickScan Profile gefunden werden!"
            Func-Write-LogDatei -LogEintrag "INFO: Profile die den Textstring - Test - enthalten werden ignoriert!." 
            Func-Write-LogDatei -LogEintrag "Programm wird ungeplant beendet."
            EXIT
        }

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

    FOREACH ($QSProfilEintrag in $QSProfilListe)
        {
            $QSProfilEintrag = Func-Dateiname_aus_Pfad -FuncVar $QSProfilEintrag
            Func-Write-LogDatei -LogEintrag "Verzeichnisse für QuickScan Profil - $QSProfilEintrag - werden nun bearbeitet:"
            Func-Pfadüberprüfung -Pfad $InputPfad\Datei\$QSProfilEintrag
            Func-Pfadüberprüfung -Pfad $TempPfad\Datei\$QSProfilEintrag
            Func-Pfadüberprüfung -Pfad $OutputPfad\Datei
            Func-Pfadüberprüfung -Pfad $ArchivPfad\Datei\$QSProfilEintrag
        }

# Prüfe ob bereits eine QuickScan Instanz gestartet ist, falls ja -> sofort beenden.
Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-LogDatei -LogEintrag "Prüfe ob QuickScan bereits läuft."
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"

Set-Variable -Name QSProzess -Value (Func-Dateiname_aus_Pfad -FuncVar $QSEXE)
$ProzessTest = get-process $QSProzess -ErrorAction SilentlyContinue
    IF ($ProzessTest -eq $null)
        {
            Func-Write-LogDatei -LogEintrag "Es scheint keine QuickScan Instanz vorhanden zu sein, fahre fort."
        }
    ELSE
        {
            Func-Write-LogDatei -LogEintrag "QuickScan Instanz vorhanden, versuche diese nun zu beenden."
            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-LogDatei -LogEintrag "FEHLER: Es konnten nicht alle QuickScan Instanzen beendet werden."
                        Func-Write-LogDatei -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-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-LogDatei -LogEintrag "Prüfen ob abzuarbeitende Dateien vorhanden sind und starte ggf. Abarbeitung."
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"

    FOREACH ($QSProfilEintrag in $QSProfilListe)
        {
            # Warte bis gefundene Dateien ein gewisses Alter erreicht haben, bevor Sie verarbeitet werden.
            $QSProfil = Func-Dateiname_aus_Pfad -FuncVar $QSProfilEintrag
            Func-Write-LogDatei -LogEintrag "Es wird geprüft ob in folgendem Pfad, abzuarbetende Dateien bereitliegen:"
            Func-Write-LogDatei -LogEintrag "$InputPfad\Datei\$QSProfil"
            $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$InputPfad\Datei\$QSProfil\*" -SuchDateiEndung pdf | where-object {$_.lastwritetime -lt (get-date).addminutes(-$DateiVerzögerung)} | Foreach-Object { $_.FullName } )
                IF ($Funde -eq $null)
                    {
                        Func-Write-LogDatei -LogEintrag "In diesem Ordner liegen derzeit keine abzuarbeitenden Dateien."
                    }
                ELSE
                    {
                        Func-Write-LogDatei -LogEintrag "Folgende Datei(en) wurden gefunden:"
                        FOREACH ($Fund in $Funde)
                            {
                                Func-Write-LogDatei -LogEintrag $Fund
                            }
                        Func-Write-LogDatei -LogEintrag "QuickScan wird gestartet, Profil - $QSProfilEintrag - wird abgearbeitet."
                      # Start-Process -FilePath "$QSEXE" -wait "$QSProfilEintrag"   # /scan profile=Eingangsdokumente_per_Scan /exit
                        #$QSRückgabeCode =(start-process -FilePath "$QSEXE" -ArgumentList "/open filename=$Fund ,profile=$QSProfilEintrag /exit" -wait -Passthru).ExitCode
                        #$QSRückgabeCode =(start-process -FilePath "$QSEXE" -ArgumentList "/scan profile=$QSProfilEintrag /exit" -wait -Passthru).ExitCode
                        Func-Write-LogDatei -LogEintrag "QuickScan Verarbeitung abgeschlossen - Der RückgabeCode lautet: $LastExitCode."    
                    }
        }

Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-LogDatei -LogEintrag "Prüfe ob PDF/A Konvertierung durchgeführt werden soll."
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"

# 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 ($PDFCreatorKonvertierung_Hauptschalter -like 'ein')
    {

        Func-Write-LogDatei -LogEintrag "PDF/A-1B Konvertierung mithilfe des PDFCreators, ist eingeschaltet."
        Func-Write-LogDatei -LogEintrag "Bitte kontrollieren Sie die Einstellungen Ihres PDF Creators:"
        Func-Write-LogDatei -LogEintrag "Automatisch Updateüberprüfung muss abgeschaltet werden."

        # Prüfe ob der hinterlegte Pfad für den PDFCreator gültig ist.
        $DateiTest = Test-Path  -PathType Leaf $PDFCreatorEXE
		    IF ($DateiTest -eq "True")
				{
					Write-Host "PDFCreator ist vorhanden, fahre fort."
                    # Prüfe ob PDFCreator bereits läuft und versuche ihn zu beenden.
                    Set-Variable -Name PDFCreatorProzess -Value (Func-Dateiname_aus_Pfad -FuncVar $PDFCreatorEXE)
                    $ProzessTest = get-process $PDFCreatorProzess -ErrorAction SilentlyContinue
                        IF ($ProzessTest -ne $null)
                            {
                                Func-Write-LogDatei -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-LogDatei -LogEintrag "FEHLER: Es konnten nicht alle PDFCreator Instanzen beendet werden."
                                            Func-Write-LogDatei -LogEintrag "Konvertierung wird vorsichtshalber übersprungen."
                                            break
                                        }
                            }

                        IF ($PDFCreatorKonvertierung_Global -like 'Ja')
                            {
                                Func-Write-LogDatei -LogEintrag "PDF/A-1B Konvertierung mithilfe des PDFCreators, ist eingeschaltet."
                                Func-Write-LogDatei -LogEintrag "Durchsuche $OutputPfad\Datei nach zu konvertierenden Dateien. Es werden nur $DateiEndung-Dateien berücksichtigt! "
                                Func-Pfadüberprüfung -Pfad "$TempPfad\Datei\PDFCreatorKonvertierung"
                                $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$OutputPfad\Datei\*" -SuchDateiEndung $DateiEndung)
                                    IF ($Funde -eq $Null)
                                        {
                                            Func-Write-LogDatei -LogEintrag "Keine zu konvertierenden Dateien gefunden."
                                        }

                                    ELSE
                                        {
                                            FOREACH ($Fund in $Funde)
                                                {
                                                    Func-PDFAKonvertierung -Datei "$Fund"
                                                }
                                        }
                            }
				}

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


ELSE
    {
        Func-Write-LogDatei "PDF/A-1B Konvertierung mithilfe des PDFCreators, ist ausgeschaltet."
    }   

# Nach Verarbeitung der Dateien, werden diese von QuickScan in ...\Output\Datei abgelegt.
# Folgendes Regelwerk wird anhand der Variablen OutputRegel aktiv.
# Dieses ist in der Lage, die verarbetieten Dateien anhand ihres Namens in entsprechende Unterordner zu sortieren oder/und umzubenennen.
Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-LogDatei -LogEintrag "Prüfe ob weitere Verarbeitungsschritte erfolgen sollen."
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"

IF ($($OutputRegelListe.count) -gt 0)
    {
        Func-Write-LogDatei -LogEintrag "Es wurde(n) $($OutputRegelListe.count) von maximal 9 OutputRegeln definiert, diese wird/werden nun abgearbeitet."
        
        # Dynamische Arrays vorbereiten
        [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @()
        [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @() 
        [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()

        # Array mit Default Wert füllen
        $OutputPfadArbeitsOrdnernAktuell.Add("$OutputPfad\Datei")

        # Zähler zurücksetzen
        $Zähler = $NULL

            # Schleife für jede OuputRegel bzw. Zeile in der Konfigurationsdatei wird eingeleitet.
            FOREACH ($OutputRegel in $(get-variable -Name OutputRegel?))
                {
                    $Zähler++ | out-null

                    Func-Write-LogDatei -LogEintrag ""
                    Func-Write-LogDatei -LogEintrag "--> Verarbeitung von $((Get-Variable -name ("OutputRegel"+$Zähler)).name) wird gestartet."
                    Func-Write-LogDatei -LogEintrag "Folgende Werte wurden übergeben: $(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)."
                        IF ($OutputPfadArbeitsOrdnernZuletzt -ne $NULL)
                            {
                                    $TempOutputPfadArbeitsOrdnernZuletzt = ($OutputPfadArbeitsOrdnernZuletzt  | select -uniq)
                                    [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernZuletzt)

                                    Func-Write-LogDatei -LogEintrag "Für den letzten Durchlauf, wurde/wurden folgende Ordner Inhalte geprüft:"
                                    Func-Write-LogDatei -LogEintrag $OutputPfadArbeitsOrdnernZuletzt
                            }

                    $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                    [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                    Func-Write-LogDatei -LogEintrag "Für diesen Durchlauf, wird/werden folgende Ordner Inhalte geprüft:"
                    Func-Write-LogDatei -LogEintrag $OutputPfadArbeitsOrdnernAktuell

                        # Prüfe ob es sich um Sortiermethode1 handelt, jede Sortiermethode arbeitet anders und muss anders konfiguriert werden!
                        IF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Sortiermethode1')
                            {
                                $OutputRegelWert = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWert -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    ELSEIF ($OutputRegelWert -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    IF ($OutputRegelWert -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                                                                
                                [Array]$OutputRegelWert = $OutputRegelWert | where {$_ -ne "Sortiermethode1" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                Func-Write-LogDatei -LogEintrag ""
                                Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                Func-Write-LogDatei -LogEintrag "Es werden alle Dateien berücksichtigt, die Zielordner werden anhand des ersten Wertes, vor dem ersten Datei-Trennzeichen im Dateinamen gebildet."
                                    FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                            Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()
                                            
                                                IF ($OutputRegelWert[1] -ne $NULL)
                                                    {
                                                        Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[1]
                                                        Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                        Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                    }

                                            Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                            Func-Write-LogDatei -LogEintrag ($Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”)
                                                IF ($Funde -eq $null)
                                                    {
                                                        Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                    }

                                                ELSE
                                                    {
                                                        Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                            FOREACH ($Fund in $Funde)
                                                                {
                                                                    IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                        {
                                                                            Func-PDFAKonvertierung -Datei "$Fund"
                                                                        }

                                                                    Set-Variable -Name Dokumentart -Value (Func-Dateiname_aus_Pfad -FuncVar $Fund)
                                                                    Set-Variable -Name Dokumentart -Value (Func-Dateiname_zerlegen_Dateianfang -FuncVar $Dokumentart)

                                                                    IF ($OutputRegelZielPfad  -like '*\*')
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag ""
                                                                            Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                            Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad\$Dokumentart"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad\$Dokumentart"
                                                                    
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelZielPfad\$Dokumentart"
                                                                            $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                        }

                                                                    ELSE
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag ""
                                                                            Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$Dokumentart"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$Dokumentart"
                                                                    
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$Dokumentart"
                                                                            $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$Dokumentart")
                                                                        }
                                                                }
                                                    }
                                        }

                                Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                                $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()

                            }
                        
                        # Prüfe ob es sich um Sortiermethode2 handelt, jede Sortiermethode arbeitet anders und muss anders konfiguriert werden!
                        ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Sortiermethode2')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, werden in diesen verschoben verschoben."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "a"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen,"
                                            Func-Write-LogDatei "werden aber bei der nächsten Regel wieder versucht zu verarbeiten."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "b"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung3")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "c"
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                        
                                # Filtere Array Inhalte                                                 
                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Sortiermethode2" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                    FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im ersten Schritt werden nur Dateien verschoben verschoben, die der OutputRegel1 entsprechen.

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")

                                                        IF ($OutputRegelWert[1] -ne $NULL)
                                                            {
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelWert[0]
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimEnd()
                                                                
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[1]
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                            }
                                                        
                                                        ELSE
                                                            {
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelWert
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimEnd()
                                                            }

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Es werden nur Dateien berücksichtigt, bei denen - $OutputRegelDateiString - am Anfang des Dateinamens steht."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung” -Include $OutputRegelDateiString$DateiTrennzeichen*
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                                IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                                    {
                                                                                        Func-PDFAKonvertierung -Datei "$Fund"
                                                                                    } 

                                                                                IF ($OutputRegelZielPfad  -like '*\*')
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                                        Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelZielPfad"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                                    }

                                                                                ELSE
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$OutputRegelDateiString")
                                                                                    }
                                                                        }
                                                            }
                                                }
                                        
                                            IF ($FehlerOrdnerSchalter -eq "a" )
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im zweiten Schritt werden alle übrigen Dateien verschoben verschoben.

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Nun werden noch die nicht klassifizierten Dateien verschoben verschoben."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }
                                                        ELSE
                                                            {
                                                                Write-host "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                        }
                                                            }
                                                }
                                        

                                            ELSEIF ($FehlerOrdnerSchalter -eq "b")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben, jedoch bei der nächsten Regel nochmal mitverarbeitet."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu inkonsistenz in Ihre Ordnerstruktur führen."
                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner")
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "c")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu Dateileichen in Ihre Ordnerstruktur führen."
                                                }
                                        }

                                Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)

                                $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()
                            }

                        # Prüfe ob es sich um Sortiermethode3 handelt, jede Sortiermethode arbeitet anders und muss anders konfiguriert werden!
                        ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Sortiermethode3')
                            {
                                $OutputRegelWerte = ($(get-variable -Name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, werden in diesen verschoben verschoben."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "a"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen,"
                                            Func-Write-LogDatei "werden aber bei der nächsten Regel wieder versucht zu verarbeiten."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "b"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung3")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "c"
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                                                                
                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Sortiermethode3" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                    FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im ersten Schritt werden nur Dateien verschoben verschoben, die der OutputRegel1 entsprechen.
                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")

                                                        IF ($OutputRegelWert[1] -ne $NULL)
                                                            {
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelWert[0]
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimEnd()
                                                                
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[1]
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                            }

                                                        ELSE
                                                            {
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelWert
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimEnd()
                                                            }

                                                    Func-Write-LogDatei -LogEintrag "Es werden nur Dateien berücksichtigt, bei denen - $OutputRegelDateiString - irgendwo im Dateinamen vorkommt."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung” -Include *$OutputRegelDateiString*
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }
                                                        ELSE
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                                IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                                    {
                                                                                        Func-PDFAKonvertierung -Datei "$Fund"
                                                                                    }
                                                                            
                                                                                IF ($OutputRegelZielPfad -like '*\*')
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                                        Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelZielPfad"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                                    }

                                                                                ELSE
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$OutputRegelDateiString")
                                                                                    }
                                                                        }
                                                            }
                                                }

                                            IF ($FehlerOrdnerSchalter -eq "a")
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im zweiten Schritt werden alle übrigen Dateien verschoben verschoben.
                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Nun werden noch die nicht klassifizierten Dateien verschoben verschoben."

                                                    $OutputPfadArbeitsOrdner = $OutputPfadArbeitsOrdner.TrimStart()
                                                    $OutputPfadArbeitsOrdner = $OutputPfadArbeitsOrdner.TrimEnd()
                                                    
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Write-host "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                        }
                                                            }
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "b")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben, jedoch bei der nächsten Regel nochmal mitverarbeitet."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu inkonsistenz in Ihre Ordnerstruktur führen."
                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner")
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "c")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu Dateileichen in Ihre Ordnerstruktur führen."
                                                }
                                            }

                                        Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                        $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                        [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                                        $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                        [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                        [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()
                            }

                        # Prüfe ob es sich um Sortiermethode4 handelt, jede Sortiermethode arbeitet anders und muss anders konfiguriert werden!
                        ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Sortiermethode4')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, werden in diesen verschoben verschoben."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "a"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen,"
                                            Func-Write-LogDatei "werden aber bei der nächsten Regel wieder versucht zu verarbeiten."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "b"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung3")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "c"
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                                                                
                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Sortiermethode4" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                    FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im ersten Schritt werden nur Dateien verschoben verschoben, die der OutputRegel1 entsprechen.
                                                    
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")

                                                        IF ($OutputRegelWert[1] -ne $NULL)
                                                            {
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelWert[0]
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimEnd()
                                                                
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[1]
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                            }

                                                        ELSE
                                                            {
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelWert
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimEnd()
                                                            }

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Es werden nur Dateien berücksichtigt, bei denen - $OutputRegelDateiString - am Ende des Dateinamens steht."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung” -Include *$DateiTrennzeichen$OutputRegelDateiString.$DateiEndung
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                                IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                                    {
                                                                                        Func-PDFAKonvertierung -Datei "$Fund"
                                                                                    }
                                                                            
                                                                                IF ($OutputRegelZielPfad -like '*\*')
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                                        Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelZielPfad"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                                    }

                                                                                ELSE
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$OutputRegelDateiString"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$OutputRegelDateiString")
                                                                                    }
                                                                        }
                                                            }
                                                }

                                            IF ($FehlerOrdnerSchalter -eq "a")
                                                { 
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im zweiten Schritt werden alle übrigen Dateien verschoben verschoben.
                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Nun werden noch die nicht klassifizierten Dateien verschoben verschoben."
                                                    
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()
                                                    
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Write-host "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                        }
                                                            }
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "b")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben, jedoch bei der nächsten Regel nochmal mitverarbeitet."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu inkonsistenz in Ihre Ordnerstruktur führen."
                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner")
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "c")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu Dateileichen in Ihre Ordnerstruktur führen."
                                                }
                                        }

                                Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                                $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()
                            }
                        
                        # Prüfe ob es sich um Sortiermethode5 handelt, jede Sortiermethode arbeitet anders und muss anders konfiguriert werden!
                        ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Sortiermethode5')
                            {
                                $OutputRegelWert = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWert -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    ELSEIF ($OutputRegelWert -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    IF ($OutputRegelWert -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                                                                
                                [Array]$OutputRegelWert = $OutputRegelWert | where {$_ -ne "Sortiermethode5" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()
                                
                                    IF ($OutputRegelWert[1] -ne $NULL)
                                        {
                                            Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[1]
                                            Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                            Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                        }

                                Func-Write-LogDatei -LogEintrag ""                    
                                Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                Func-Write-LogDatei -LogEintrag "Es werden alle Dateien berücksichtigt, die Zielordner werden anhand des letzten Wertes, nach dem letzten Datei-Trennzeichen im Dateinamen gebildet."
                                Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                $Funde = (get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”)
                                    IF ($Funde -eq $null)
                                        {
                                            Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                        }

                                    ELSE
                                        {
                                            Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                FOREACH ($Fund in $Funde)
                                                    {
                                                            IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                {
                                                                    Func-PDFAKonvertierung -Datei "$Fund"
                                                                }

                                                            Set-Variable -Name Dokumentart -Value (Func-Dateiname_aus_Pfad -FuncVar $Fund)
                                                            Set-Variable -Name Dokumentart -Value (Func-Dateiname_zerlegen_Dateiende -FuncVar $Dokumentart)
                                                                                                                    
                                                            IF ($OutputRegelZielPfad -like '*\*')
                                                                {
                                                                    Func-Write-LogDatei -LogEintrag ""
                                                                    Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                    Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                    Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad\$Dokumentart"
                                                                    Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad\$Dokumentart"
                                                                    
                                                                    Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelWert\$Dokumentart"
                                                                    $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                }

                                                            ELSE
                                                                {
                                                                    Func-Write-LogDatei -LogEintrag ""
                                                                    Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                    Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$Dokumentart"
                                                                    Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$Dokumentart"
                                                                    
                                                                    Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$Dokumentart"
                                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$Dokumentart")
                                                                }
                                                    }
                                        }
                            }

                        # Prüfe ob es sich um Sortiermethode6 handelt, jede Sortiermethode arbeitet anders und muss anders konfiguriert werden!
                        ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Sortiermethode6')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, werden in diesen verschoben verschoben."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "a"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen,"
                                            Func-Write-LogDatei "werden aber bei der nächsten Regel wieder versucht zu verarbeiten."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "b"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung3")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "c"
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                                                                
                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Sortiermethode6" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                    FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")

                                                        IF ($OutputRegelWert[1] -ne $NULL)
                                                            {
                                                                Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelWert[0]
                                                                Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelDateiZeichenLaenge.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelDateiZeichenLaenge.TrimEnd()
                                                                
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[1]
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                            }
                                                        ELSE
                                                            {
                                                                Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelWert
                                                                Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelDateiZeichenLaenge.TrimStart()
                                                                Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelDateiZeichenLaenge.TrimEnd()
                                                            }

                                                    Set-Variable -Name OutputRegelName                  -Value ("Dateilaenge betraegt "+$OutputRegelDateiZeichenLaenge+" Zeichen")

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Aufgrund Ihrer Konfiguration, wird dieser Regeldurchlauf wie folgt bennant: $OutputRegelName"
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$OutputPfadArbeitsOrdner\*" -SuchDateiEndung $DateiEndung)
                                                    FOREACH ($Fund in $Funde)
                                                        {
                                                            $FundZeichenLaenge = ($Fund.Name | measure-object -character | select -expandproperty characters)
                                                            IF ($FundZeichenLaenge -eq $OutputRegelDateiZeichenLaenge)
                                                                {
                                                                    IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                        {
                                                                            Func-PDFAKonvertierung -Datei "$Fund"
                                                                        }

                                                                    IF ($OutputRegelZielPfad -like '*\*')
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag ""
                                                                            Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                            Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad"
                                                                    
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelZielPfad"
                                                                            $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                        }

                                                                    ELSE
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag ""
                                                                            Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                    
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                            $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$OutputRegelName")
                                                                        }
                                                                }
                                                             ELSE
                                                                {
                                                                    Func-Write-LogDatei -LogEintrag "$Fund.Name + fällt nicht in das definierte Raster und wird in diesem Durchlauf nicht beachtet/verschoben verschoben!"

                                                                }
                                                        }
                                                }

                                            IF ($FehlerOrdnerSchalter -eq "a")
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im zweiten Schritt werden alle übrigen Dateien verschoben verschoben.
                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Nun werden noch die nicht klassifizierten Dateien verschoben verschoben."
                                                    
                                                    $OutputPfadArbeitsOrdner = $OutputPfadArbeitsOrdner.TrimStart()
                                                    $OutputPfadArbeitsOrdner = $OutputPfadArbeitsOrdner.TrimEnd()
                                                    
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }
                                                        ELSE
                                                            {
                                                                Write-host "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                        }
                                                            }
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "b")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben, jedoch bei der nächsten Regel nochmal mitverarbeitet."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu inkonsistenz in Ihre Ordnerstruktur führen."
                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner")
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "c")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu Dateileichen in Ihre Ordnerstruktur führen."
                                                }
                                        }

                                Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                                $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()
                            }

                        # Prüfe ob es sich um Sortiermethode7 handelt, jede Sortiermethode arbeitet anders und muss anders konfiguriert werden!
                        ELSEIF ($(get-variable -Name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Sortiermethode7')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, werden in diesen verschoben verschoben."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "a"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen,"
                                            Func-Write-LogDatei "werden aber bei der nächsten Regel wieder versucht zu verarbeiten."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "b"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung3")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "c"
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                                                                
                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Sortiermethode7" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                    FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")

                                                    Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelWert[0]
                                                    Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelDateiString.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiZeichenLaenge    -Value $OutputRegelDateiString.TrimEnd()

                                                    Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelWert[1]
                                                    Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiString           -Value $OutputRegelDateiString.TrimEnd()

                                                        IF ($OutputRegelWert[2] -ne $NULL)
                                                            {
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[2]
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                            }

                                                    Set-Variable -Name OutputRegelName                  -Value ("Dateilaenge betraegt "+$OutputRegelDateiZeichenLaenge+" Zeichen, mit gesuchter Zeichenkette "+$OutputRegelDateiString)

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Aufgrund Ihrer Konfiguration, wird dieser Regeldurchlauf wie folgt bennant: $OutputRegelName"

                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$OutputPfadArbeitsOrdner\*$OutputRegelDateiString*" -SuchDateiEndung $DateiEndung)
                                                    FOREACH ($Fund in $Funde)
                                                        {
                                                            $FundZeichenLaenge = ($Fund.Name | measure-object -character | select -expandproperty characters)
                                                            Func-Write-LogDatei -LogEintrag ""
                                                            Func-Write-LogDatei -LogEintrag "Zeichen: $OutputRegelDateiString im Dateinamen gefunden!"
                                                            IF ($FundZeichenLaenge -eq $OutputRegelDateiZeichenLaenge)
                                                                {
                                                                        IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                            {
                                                                                Func-PDFAKonvertierung -Datei "$Fund"
                                                                            }

                                                                        IF ($OutputRegelZielPfad  -like '*\*')
                                                                            {
                                                                                Func-Write-LogDatei -LogEintrag ""
                                                                                Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                                Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                                Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad"
                                                                                Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad"
                                                                    
                                                                                Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelZielPfad"
                                                                                $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                            }

                                                                        ELSE
                                                                            {
                                                                                Func-Write-LogDatei -LogEintrag ""
                                                                                Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                                Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                                Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                    
                                                                                Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                                $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$OutputRegelName")
                                                                            }
                                                                }

                                                             ELSE
                                                                {
                                                                    Func-Write-LogDatei -LogEintrag "$Fund.Name + fällt nicht in das definierte Raster und wird in diesem Durchlauf nicht beachtet/verschoben verschoben!"

                                                                }
                                                        }
                                                }

                                            IF ($FehlerOrdnerSchalter -eq "a")
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im zweiten Schritt werden alle übrigen Dateien verschoben verschoben.
 
                                                    Set-Variable -Name OutputPfadArbeitsOrdner     -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner     -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Nun werden noch die nicht klassifizierten Dateien verschoben verschoben."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Write-host "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                        }
                                                            }
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "b")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben, jedoch bei der nächsten Regel nochmal mitverarbeitet."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu inkonsistenz in Ihre Ordnerstruktur führen."
                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner")
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "c")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu Dateileichen in Ihre Ordnerstruktur führen."
                                                }
                                        }

                                Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                                $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()
                
                            }

                        ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Umbenennmethode1')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }

                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Umbenennmethode1" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                     FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im ersten Schritt werden nur Dateien verschoben verschoben, die der OutputRegel1 entsprechen.
                                                    
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")
                                                    
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelWert[0]
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimEnd()

                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelWert[1]
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimEnd()

                                                    Set-Variable -Name OutputRegelName                  -Value ("Der String "+$OutputRegelDateiStringOriginal+" wird ersetzt mit "+$OutputRegelDateiStringErsetzen)

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Aufgrund Ihrer Konfiguration, wird dieser Regeldurchlauf wie folgt benannt: $OutputRegelName"
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob umzubenennende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Es werden nur Dateien berücksichtigt, bei denen - $DateiStringOriginal - irgendwo im Dateinamen vorkommt."
                                                    
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung” -Include *$OutputRegelDateiStringOriginal*
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu umzubenennenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "In Datei: $Fund wurde dieser String $OutputRegelDateiStringOriginal gefunden, dieser wird ersetzt mit $OutputRegelDateiStringErsetzen."
                                                                            $Fund | Rename-Item -Newname { $_.Name -replace "$OutputRegelDateiStringOriginal","$OutputRegelDateiStringErsetzen" }
                                                                        }
                                                            }
                                                }
                                        }
                             }

                      ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Umbenennmethode2')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, werden in diesen verschoben verschoben."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "a"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen,"
                                            Func-Write-LogDatei "werden aber bei der nächsten Regel wieder versucht zu verarbeiten."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "b"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung3")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "c"
                                        }
                                                                                
                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Umbenennmethode2" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                     FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im ersten Schritt werden nur Dateien verschoben verschoben, die der OutputRegel1 entsprechen.

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")
                                                    
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelWert[0]
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimEnd()

                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelWert[1]
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimEnd()

                                                        IF ($OutputRegelWert[2] -ne $NULL)
                                                            {
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[2]
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                            }

                                                    Set-Variable -Name OutputRegelName                  -Value ("Der String "+$OutputRegelDateiStringOriginal+" wird ersetzt mit "+$OutputRegelDateiStringErsetzen)

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Aufgrund Ihrer Konfiguration, wird dieser Regeldurchlauf wie folgt benannt: $OutputRegelName"
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob umzubenennende Dateien vorhanden sind. Diese werden im Anschluss noch verschoben."
                                                    Func-Write-LogDatei -LogEintrag "Es werden nur Dateien berücksichtigt, bei denen - $OutputRegelDateiStringOriginal - irgendwo im Dateinamen vorkommt."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung” -Include *$OutputRegelDateiStringOriginal*
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine umzubenennenden bzw. zu verschiebenden Dateien vorhanden."
                                                            }
                                                        ELSE
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben und umbenannt."
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "In Datei: $Fund wurde dieser String $OutputRegelDateiStringOriginal gefunden, dieser wird ersetzt mit $OutputRegelDateiStringErsetzen."
                                                                            $Fund | Rename-Item -Newname {$(Split-Path $Fund -Leaf) -replace "$OutputRegelDateiStringOriginal","$OutputRegelDateiStringErsetzen"}
                                                                            $Fund = ($Fund -replace "$OutputRegelDateiStringOriginal","$OutputRegelDateiStringErsetzen")
                                                                                IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                                    {
                                                                                        Func-PDFAKonvertierung -Datei "$Fund"
                                                                                    }

                                                                                IF ($OutputRegelWert  -like '*\*')
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                                        Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputRegelZielPfad"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputRegelZielPfad"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                                    }

                                                                                ELSE
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$OutputRegelName")
                                                                                    }
                                                                        }
                                                            }
                                                }

                                            IF ($FehlerOrdnerSchalter -eq "a")
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im zweiten Schritt werden alle übrigen Dateien verschoben verschoben.

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Nun werden noch die nicht klassifizierten Dateien verschoben verschoben."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }
                                                        ELSE
                                                            {
                                                                Write-host "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                        }
                                                            }
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "b")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben, jedoch bei der nächsten Regel nochmal mitverarbeitet."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu inkonsistenz in Ihre Ordnerstruktur führen."
                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner")
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "c")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben verschoben verschoben verschoben."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu Dateileichen in Ihre Ordnerstruktur führen."
                                                }
                                        }

                                Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                                $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()
                            }


                        ELSEIF ($(get-variable -Name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Umbenennmethode3')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Der Parameter ist für diesen Durchlauf jedoch ungültig und wird ignoriert."
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }

                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Umbenennmethode3" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                     FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im ersten Schritt werden nur Dateien verschoben verschoben, die der OutputRegel1 entsprechen.

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")

                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelWert[0]
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimEnd()

                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelWert[1]
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimEnd()

                                                    Set-Variable -Name OutputRegelName                  -Value ("Der komplette Dateiname wurde ersetzt mit "+$OutputRegelDateiStringErsetzen+" plus Zeitstempel")

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Aufgrund Ihrer Konfiguration, wird dieser Regeldurchlauf wie folgt benannt: $OutputRegelName"
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob umzubenennenden Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Es werden nur Dateien berücksichtigt, bei denen - $OutputRegelDateiStringOriginal - irgendwo im Dateinamen vorkommt."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung” -Include *$OutputRegelDateiStringOriginal*
                                                        IF ($Funde -eq $NULL)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine umzubenennenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            $Tag          = (Get-Date).Day
                                                                            $Monat        = (Get-Date).Month
                                                                            $Jahr         = (Get-Date).Year

                                                                            $Stunde       = (Get-Date).Hour
                                                                            $Minute       = (Get-Date).Minute
                                                                            $Sekunde      = (Get-Date).Second
                                                                            $Millisekunde = (Get-Date).Millisecond

                                                                            $ZeitStempel2 = "$Tag$Monat$Jahr$DateiTrennzeichen$Stunde$Minute$Sekunde$Millisekunde"

                                                                            Func-Write-LogDatei -LogEintrag "In Datei: $Fund wurde dieser String $OutputRegelDateiStringOriginal gefunden, dieser wird ersetzt mit $OutputRegelDateiStringErsetzen."
                                                                            $Fund | Rename-Item -Newname "$OutputRegelDateiStringErsetzen$DateiTrennzeichen$ZeitStempel2.$Dateiendung"
                                                                        }
                                                            }
                                                }
                                        }
                             }

                      ELSEIF ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly)[0] -like 'Umbenennmethode4')
                            {
                                $OutputRegelWerte = ($(get-variable -name ("OutputRegel"+$Zähler) -ValueOnly))

                                    IF ($OutputRegelWerte -contains "FehlerBehandlung1")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf eingeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, werden in diesen verschoben verschoben."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "a"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung2")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen,"
                                            Func-Write-LogDatei "werden aber bei der nächsten Regel wieder versucht zu verarbeiten."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "b"
                                        }

                                    ELSEIF ($OutputRegelWerte -contains "FehlerBehandlung3")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "Die Fehlerbehandlung ist für diesen Durchlauf ausgeschaltet worden (Verwendung Ordner: $FehlerOrdner)."
                                            Func-Write-LogDatei "Dateien die in diesem Durchlauf nicht verarbeitet werden können, bleiben einfach stehen."
                                            Set-Variable -Name FehlerOrdnerSchalter -Value "c"
                                        }

                                    IF ($OutputRegelWerte -contains "PDFCreatorKonvertierung")
                                        {
                                            Func-Write-LogDatei ""
                                            Func-Write-LogDatei "PDF/A Konvertierung ist für diesen Durchlauf eingeschaltet."
                                            Func-Write-LogDatei "Dateien die in den $FehlerOrdner-Ordner laufen, werden ignoriert!"
                                            Set-Variable -Name PDFCreatorKonvertierung -Value $True -Scope local
                                        }
                                                                                
                                [Array]$OutputRegelWerte = $OutputRegelWerte | where {$_ -ne "Umbenennmethode4" -and $_ -ne "FehlerBehandlung1" -and $_ -ne "FehlerBehandlung2" -and $_ -ne "FehlerBehandlung3" -and $_ -ne "PDFCreatorKonvertierung"}

                                     FOREACH ($OutputPfadArbeitsOrdner in $OutputPfadArbeitsOrdnernAktuell)
                                        {
                                            FOREACH ($OutputRegelWert in $OutputRegelWerte)
                                                {
                                                    # Prüfe anhand des Output Verzeichnisses, ob zu verschiebende Dateien vorhanden sind.
                                                    # Im ersten Schritt werden nur Dateien verschoben verschoben, die der OutputRegel1 entsprechen.

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Set-Variable -Name OutputRegelWert                  -Value ($OutputRegelWert -split "\|")

                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelWert[0]
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringOriginal   -Value $OutputRegelDateiStringOriginal.TrimEnd()

                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelWert[1]
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimStart()
                                                    Set-Variable -Name OutputRegelDateiStringErsetzen   -Value $OutputRegelDateiStringErsetzen.TrimEnd()

                                                    IF ($OutputRegelWert[2] -ne $NULL)
                                                            {
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelWert[2]
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimStart() 
                                                                Set-Variable -Name OutputRegelZielPfad              -Value $OutputRegelZielPfad.TrimEnd()
                                                            }

                                                    Set-Variable -Name OutputRegelName                  -Value ("Der komplette Dateiname wurde ersetzt mit "+$OutputRegelDateiStringErsetzen+" plus Zeitstempel")

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Es werden nur Dateien berücksichtigt, bei denen - $OutputRegelDateiStringOriginal - irgendwo im Dateinamen vorkommt."
                                                    Func-Write-LogDatei -LogEintrag "Aufgrund Ihrer Konfiguration, wird dieser Regeldurchlauf wie folgt benannt: $OutputRegelName"
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung” -Include *$OutputRegelDateiStringOriginal*
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu umzubenennenden bzw. zu verschiebenden Dateien vorhanden."
                                                            }

                                                        ELSE
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Dateien gefunden, Dateien werden umbenannt und verschoben."
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            
                                                                            $Tag          = (Get-Date).Day
                                                                            $Monat        = (Get-Date).Month
                                                                            $Jahr         = (Get-Date).Year

                                                                            $Stunde       = (Get-Date).Hour
                                                                            $Minute       = (Get-Date).Minute
                                                                            $Sekunde      = (Get-Date).Second
                                                                            $Millisekunde = (Get-Date).Millisecond

                                                                            $ZeitStempel2 = "$Tag$Monat$Jahr$DateiTrennzeichen$Stunde$Minute$Sekunde$Millisekunde"
                                                                            
                                                                                 IF ($PDFCreatorKonvertierung_Hauptschalter -like "ein" -and $PDFCreatorKonvertierung -eq "True")
                                                                                    {
                                                                                        Func-PDFAKonvertierung -Datei "$Fund"
                                                                                    }

                                                                            Func-Write-LogDatei -LogEintrag "In Datei: $Fund wurde der String $OutputRegelDateiStringOriginal gefunden, dieser wird ersetzt mit $OutputRegelDateiStringErsetzen."
                                                                            $Fund | Rename-Item -Newname "$OutputRegelDateiStringErsetzen$DateiTrennzeichen$ZeitStempel2.$Dateiendung"

                                                                                IF ($OutputRegelZielPfad  -like '*\*')
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wurde in der Konfigurationsdatei angegeben:"
                                                                                        Func-Write-LogDatei -LogEintrag "$OutputRegelZielPfad"

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $OutputRegelDateiStringErsetzen$DateiTrennzeichen$ZeitStempel2.$Dateiendung nach $OutputRegelZielPfad"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputRegelZielPfad"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$OutputPfadArbeitsOrdner\$OutputRegelDateiStringErsetzen$DateiTrennzeichen$ZeitStempel2.$Dateiendung" -ZielPfad "$OutputRegelZielPfad"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Clear | Out-Null                                                                                
                                                                                    }

                                                                                ELSE
                                                                                    {
                                                                                        Func-Write-LogDatei -LogEintrag ""
                                                                                        Func-Write-LogDatei -LogEintrag "Zielpfad wird automatisch erstellt."

                                                                                        Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $OutputRegelDateiStringErsetzen$DateiTrennzeichen$ZeitStempel2.$Dateiendung nach $OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                                        Func-Pfadüberprüfung -Pfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                    
                                                                                        Func-Dateien-Versionieren -Datei "$OutputPfadArbeitsOrdner\$OutputRegelDateiStringErsetzen$DateiTrennzeichen$ZeitStempel2.$Dateiendung" -ZielPfad "$OutputPfadArbeitsOrdner\$OutputRegelName"
                                                                                        $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner\$OutputRegelName")
                                                                                    }
                                                                        }
                                                            }
                                                }

                                            IF ($FehlerOrdnerSchalter -eq "a")
                                                {
                                                    # Im zweiten Schritt werden alle übrigen Dateien verschoben verschoben.

                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimStart()
                                                    Set-Variable -Name OutputPfadArbeitsOrdner          -Value $OutputPfadArbeitsOrdner.TrimEnd()

                                                    Func-Write-LogDatei -LogEintrag ""
                                                    Func-Write-LogDatei -LogEintrag "Prüfe ob zu verschiebende Dateien vorhanden sind."
                                                    Func-Write-LogDatei -LogEintrag "Nun werden noch die nicht klassifizierten Dateien verschoben verschoben."
                                                    Func-Write-LogDatei -LogEintrag "Aktueller Ordner: $OutputPfadArbeitsOrdner"
                                                    $Funde = get-childitem “$OutputPfadArbeitsOrdner\*.$DateiEndung”
                                                        IF ($Funde -eq $null)
                                                            {
                                                                Func-Write-LogDatei -LogEintrag "Keine zu verschiebenden Dateien vorhanden."
                                                            }
                                                        ELSE
                                                            {
                                                                Write-host "Dateien gefunden, folgende Dateien werden verschoben verschoben:"
                                                                    FOREACH ($Fund in $Funde)
                                                                        {
                                                                            Func-Write-LogDatei -LogEintrag "Verschiebe Datei: $Fund nach $OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Pfadüberprüfung -Pfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                            Func-Dateien-Versionieren -Datei "$Fund"  -ZielPfad "$OutputPfad\Datei\$FehlerOrdner"
                                                                        }
                                                            }
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "b")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben, jedoch bei der nächsten Regel nochmal mitverarbeitet."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu inkonsistenz in Ihre Ordnerstruktur führen."
                                                    $OutputPfadArbeitsOrdnernZunächst.Add("$OutputPfadArbeitsOrdner")
                                                }

                                            ELSEIF ($FehlerOrdnerSchalter -eq "c")
                                                {
                                                    Func-Write-LogDatei "Nicht klassifizierte Dateien werden nicht verschoben."
                                                    Func-Write-LogDatei "ACHTUNG: Diese Einstellung kann zu Dateileichen in Ihre Ordnerstruktur führen."
                                                }
                                        }

                                Set-Variable -Name PDFCreatorKonvertierung -Value $NULL -Scope local

                                $TempOutputPfadArbeitsOrdnernAktuell = ($OutputPfadArbeitsOrdnernAktuell  | select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZuletzt  = @($TempOutputPfadArbeitsOrdnernAktuell)
                    
                                $TempOutputPfadArbeitsOrdnernZunächst = ($OutputPfadArbeitsOrdnernZunächst| select -uniq)
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernAktuell  = @($OutputPfadArbeitsOrdnernZunächst)
                    
                                [System.Collections.ArrayList]$OutputPfadArbeitsOrdnernZunächst = @()
                            }

                        ELSE
                            {
                                Func-Write-LogDatei -LogEintrag "Keine gültige Sortier- oder Umbenennmethode gefunden!"
                                Func-Write-LogDatei -LogEintrag "Bitte prüfen Sie Ihre Konfigurationsdatei auf Vollständigkeit."
                            }
                }
    }
ELSE
    {
        Func-Write-LogDatei -LogEintrag "Es wurden keine Outputregeln definiert, somit findet keine weitere Verarbeitung statt."
    }

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

# Temp Dateien nach Verarbeitung löschen 
Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-LogDatei -LogEintrag "Prüfe ob temporäre Dateien vorhanden sind und lösche diese."
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
    FOREACH ($QSProfilEintrag in $QSProfilListe)
        {
            $QSProfil = Func-Dateiname_aus_Pfad -FuncVar $QSProfilEintrag
            Func-Write-LogDatei -LogEintrag "Es wird geprüft ob in folgendem Pfad, temporäre Dateien liegen:"
            Func-Write-LogDatei -LogEintrag " $TempPfad\Datei\$QSProfil"
            #$Funde = get-childitem -Path "$TempPfad\Datei\$QSProfil"
            $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$TempPfad\Datei\$QSProfil\*" -SuchDateiEndung *)
            IF ($Funde -ne $null)
                {
                    Func-Write-LogDatei -LogEintrag "Folgende Dateien wurden gefunden:"
                    FOREACH ($Fund in $Funde)
                        {
                            Func-Write-LogDatei -LogEintrag $Fund
                            Remove-Item -Path $Fund -Force -Verbose
                        }
                    Func-Write-LogDatei -LogEintrag "Dateien werden nun gelöscht."
                    #Remove-item -Path "$TempPfad\$QSProfil" -Filter *.* -Force -verbose
                }
            ELSE
                {
                    Func-Write-LogDatei -LogEintrag "In diesem Ordner liegen derzeit keine temporären Dateien."
                }

        }

# Lösche alte Archiv-Dateien.
<# Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "Prüfe ob zu löschende Archiv-Dateien vorhanden sind."
    IF ($ArchivEntfernen -gt 0)
        {
            Func-Write-LogDatei -LogEintrag "Aktuell sollen Log Dateien gelöscht werden, die vor $LogEntfernen Tag(en) erstellt wurden."
            $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$LogPfad\*" -SuchDateiEndung $DateiEndung | where {$_.lastwritetime -lt $((Get-Date).AddDays(-$ArchivEntfernen)) -and -not $_.psiscontainer})
                IF ($Funde -eq $null)
                    {
                        Func-Write-LogDatei -LogEintrag "Keine zu löschenden Log Dateien vorhanden."
                    }
                ELSE
                    {
                        Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Log Dateien werden aufgund ihres alters gelöscht:"
                        FOREACH ($Fund in $Funde)
                            {
                                Func-Write-LogDatei -LogEintrag "Logdatei $Fund wird entfernt."
                                Remove-Item -Path $Fund -Force -Verbose
                            }
                    }
        }
    ELSE
        {
            Func-Write-LogDatei -LogEintrag "Sie haben in der Konfigurationsdatei angegeben, das Log Dateien nicht automatisch gelöscht werden sollen!"
        }#>

# Löschen alter Log-Dateien.
Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
Func-Write-LogDatei -LogEintrag "Prüfe ob zu löschende Log-Dateien vorhanden sind."
Func-Write-LogDatei -LogEintrag "-------------------------------------------------------------------------------------------"
    IF ($LogEntfernen -gt 0)
        {
            Func-Write-LogDatei -LogEintrag "Aktuell sollen Log-Dateien gelöscht werden, die vor $LogEntfernen Tag(en) erstellt wurden."
            $Funde = (Func-Dateien-zusammensuchen -SuchPfad "$LogPfad\*" -SuchDateiEndung log | where {$_.Name -like "*$SkriptName*" -and $_.lastwritetime -lt $((Get-Date).AddDays(-$LogEntfernen)) -and -not $_.psiscontainer})
                IF ($Funde -eq $null)
                    {
                        Func-Write-LogDatei -LogEintrag "Keine zu löschenden Log-Dateien vorhanden."
                    }
                ELSE
                    {
                        Func-Write-LogDatei -LogEintrag "Dateien gefunden, folgende Log-Dateien werden aufgund ihres alters gelöscht:"
                        FOREACH ($Fund in $Funde)
                            {
                                Func-Write-LogDatei -LogEintrag "Log-Datei: $Fund wird entfernt."
                                Remove-Item -Path $Fund -Force -Verbose
                            }
                    }
        }
    ELSE
        {
            Func-Write-LogDatei -LogEintrag "Sie haben in der Konfigurationsdatei angegeben, das Log Dateien nicht automatisch gelöscht werden sollen!"
        }

Func-Write-LogDatei -LogEintrag ""
Func-Write-LogDatei -LogEintrag "*******************************************************************************************"
Func-Write-LogDatei -LogEintrag "Programmende von $Skriptname auf $env:computername unter dem Konto: $env:USERDOMAIN\$env:USERNAME."
Func-Write-LogDatei -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 ZeitStempel1             -Force
Remove-Variable -name Log*                    -Force
Remove-Variable -name DateiTrennzeichen       -Force
Remove-Variable -Name Fund*		              -Force
Remove-Variable -Name *Pfad*	              -Force
Remove-Variable -Name *Datei*	              -Force
Remove-Variable -Name Zähler		          -Force

Remove-Variable -Name QSEXE*                  -Force
Remove-Variable -Name QSProfil*               -Force

Remove-Variable -Name PDFCreator*             -Force

Remove-Variable -Name FehlerOrdner            -Force

Remove-Variable -Name OutputRegel*            -Force
Remove-Variable -Name *OutputPfad*            -Force

$error.clear()