2550 lines
390 KiB
PowerShell
2550 lines
390 KiB
PowerShell
# 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() |