2142 lines
99 KiB
PowerShell
2142 lines
99 KiB
PowerShell
Function Main
|
|
{
|
|
#Generieren des StartPfades, damit dieser im GUI direkt angezeigt wird
|
|
$StartPfad = StartPfadHolen
|
|
GUI $StartPfad
|
|
}
|
|
|
|
Function GUI ($StartPfad)
|
|
{
|
|
[void] [System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
|
|
[void] [System.Reflection.Assembly]::LoadWithPartialName("System.Drawing")
|
|
|
|
#Eigenschaften Fenster
|
|
$Fenster = New-Object System.Windows.Forms.Form
|
|
$Fenster.Size = New-Object System.Drawing.Size(940,660) #Breite, Hoehe
|
|
$Fenster.StartPosition = "CenterScreen"
|
|
$Fenster.KeyPreview = $true # was macht das?
|
|
$Fenster.MaximumSize = $Fenster.Size # legt fest, dass Groesse des Fensters nicht veraendert werden kann
|
|
$Fenster.MinimumSize = $Fenster.Size
|
|
$Fenster.Text = "Dateikonvertierer I/O"
|
|
|
|
#Eigenschaften Tabs
|
|
$TabBasis = New-Object System.Windows.Forms.TabControl
|
|
$TabBasis.Location = New-Object System.Drawing.Size(10,10)
|
|
$TabBasis.Size = New-Object System.Drawing.Size(900,600)
|
|
$TabBasis.DataBindings.DefaultDataSourceUpdateMode = 0 # Was macht das?
|
|
$Fenster.Controls.Add($TabBasis)
|
|
|
|
# Tab: TXT-Pfad auswaehlen
|
|
$TabSeiteTXTAuswaehlen = New-Object System.Windows.Forms.TabPage
|
|
$TabSeiteTXTAuswaehlen.TabIndex = 0
|
|
$TabSeiteTXTAuswaehlen.UseVisualStyleBackColor = $true
|
|
$TabSeiteTXTAuswaehlen.Text = "txt-Datei Auswaehlen"
|
|
$TabSeiteTXTAuswaehlen.DataBindings.DefaultDataSourceUpdateMode = 0
|
|
$TabBasis.Controls.Add($TabSeiteTXTAuswaehlen)
|
|
|
|
# TXTPfadFeld
|
|
$TXTPfadFeld = New-Object System.Windows.Forms.TextBox
|
|
$TXTPfadFeld.Location = New-Object System.Drawing.Size(10,10)
|
|
$TXTPfadFeld.Size = New-Object System.Drawing.Size(860,20)
|
|
$TXTPfadFeld.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionPfadFeld "txt" $Taste
|
|
})
|
|
$TabSeiteTXTAuswaehlen.Controls.Add($TXTPfadFeld)
|
|
|
|
# TXTListeOrdnernamen
|
|
$TXTListeOrdnernamen = New-Object System.Windows.Forms.ListBox
|
|
$TXTListeOrdnernamen.Location = New-Object System.Drawing.Size(10,40)
|
|
$TXTListeOrdnernamen.Size = New-Object System.Drawing.Size(860,20)
|
|
$TXTListeOrdnernamen.Height = 450
|
|
$TXTListeOrdnernamen.Font = New-Object System.Drawing.Font("Arial",12,[System.Drawing.FontStyle]::Regular)
|
|
$TXTListeOrdnernamen.Add_DoubleClick({
|
|
# Variablen bestimmen zur uebergabe
|
|
$Auswahl = $TXTListeOrdnernamen.SelectedItem
|
|
$Pfad = $TXTPfadFeld.Text
|
|
# Pfad aktualisieren
|
|
VerzeichnisAuswaehlen "txt" $Pfad $Auswahl
|
|
})
|
|
$TXTListeOrdnernamen.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionListeOrdnernamen "txt" $Taste
|
|
})
|
|
$TabSeiteTXTAuswaehlen.Controls.Add($TXTListeOrdnernamen)
|
|
|
|
# ZurueckButton
|
|
$TXTZurueckButton = New-Object System.Windows.Forms.Button
|
|
$TXTZurueckButton.Location = New-Object System.Drawing.Size(10,500)
|
|
$TXTZurueckButton.Size = New-Object System.Drawing.Size(100,30)
|
|
$TXTZurueckButton.Text = "Zurueck"
|
|
$TXTZurueckButton.Add_Click({
|
|
$Pfad = $TXTPfadFeld.Text
|
|
#Pfad aktualisieren
|
|
VerzeichnisZurueck "txt" $Pfad
|
|
})
|
|
$TXTZurueckButton.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionButtons "txt" $Taste
|
|
})
|
|
$TabSeiteTXTAuswaehlen.Controls.Add($TXTZurueckButton)
|
|
|
|
# AuswaehlenButton
|
|
$TXTAuswaehlenButton = New-Object System.Windows.Forms.Button
|
|
$TXTAuswaehlenButton.Location = New-Object System.Drawing.Size(750,500)
|
|
$TXTAuswaehlenButton.Size = New-Object System.Drawing.Size(100,30)
|
|
$TXTAuswaehlenButton.Text = "Auswaehlen"
|
|
$TXTAuswaehlenButton.Add_Click({
|
|
# Variablen bestimmen zur uebergabe
|
|
$Auswahl = $TXTListeOrdnernamen.SelectedItem
|
|
$Pfad= $TXTPfadFeld.Text
|
|
# Pfad aktualisieren
|
|
VerzeichnisAuswaehlen "txt" $Pfad $Auswahl
|
|
})
|
|
$TXTAuswaehlenButton.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionButtons "txt" $Taste
|
|
})
|
|
$TabSeiteTXTAuswaehlen.Controls.Add($TXTAuswaehlenButton)
|
|
|
|
#Mit dieser Variable sollen ungewollt zurueckgegebene Werte der Funktion abgefangen werden, um Probleme im spaeteren Programmverlauf zu verhindern
|
|
$A = AnzeigeAktualisieren "txt" $StartPfad # Ohne dem Aufruf kann kein Startverzeichnis uebergeben werden. Wird der Aufruf keiner Variable zugewiesen verursacht dies Fehler bei der Rueckgabe.
|
|
|
|
# Tab: Zielverzeichnis auswaehlen
|
|
$TabSeiteZielVerzeichnisAuswaehlen = New-Object System.Windows.Forms.TabPage
|
|
$TabSeiteZielVerzeichnisAuswaehlen.TabIndex = 1
|
|
$TabSeiteZielVerzeichnisAuswaehlen.UseVisualStyleBackColor = $true
|
|
$TabSeiteZielVerzeichnisAuswaehlen.Text = "Zielverzeichnis Auswaehlen"
|
|
$TabSeiteZielVerzeichnisAuswaehlen.DataBindings.DefaultDataSourceUpdateMode = 0
|
|
$TabBasis.Controls.Add($TabSeiteZielVerzeichnisAuswaehlen)
|
|
|
|
# PfadFeld
|
|
$VERPfadFeld = New-Object System.Windows.Forms.TextBox
|
|
$VERPfadFeld.Location = New-Object System.Drawing.Size(10,10)
|
|
$VERPfadFeld.Size = New-Object System.Drawing.Size(860,20)
|
|
$VERPfadFeld.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionPfadFeld "ver" $Taste
|
|
})
|
|
$TabSeiteZielVerzeichnisAuswaehlen.Controls.Add($VERPfadFeld)
|
|
|
|
# ListeOrdnernamen
|
|
$VERListeOrdnernamen = New-Object System.Windows.Forms.ListBox
|
|
$VERListeOrdnernamen.Location = New-Object System.Drawing.Size(10,40)
|
|
$VERListeOrdnernamen.Size = New-Object System.Drawing.Size(860,20)
|
|
$VERListeOrdnernamen.Height = 450
|
|
$VERListeOrdnernamen.Font = New-Object System.Drawing.Font("Arial",12,[System.Drawing.FontStyle]::Regular)
|
|
$VERListeOrdnernamen.Add_DoubleClick({
|
|
# Variablen bestimmen zur uebergabe
|
|
$Auswahl = $VERListeOrdnernamen.SelectedItem
|
|
$Pfad = $VERPfadFeld.Text
|
|
# Pfad aktualisieren
|
|
VerzeichnisAuswaehlen "ver" $Pfad $Auswahl
|
|
})
|
|
$VERListeOrdnernamen.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionListeOrdnernamen "ver" $Taste
|
|
})
|
|
$TabSeiteZielVerzeichnisAuswaehlen.Controls.Add($VERListeOrdnernamen)
|
|
|
|
# ZurueckButton
|
|
$VERZurueckButton = New-Object System.Windows.Forms.Button
|
|
$VERZurueckButton.Location = New-Object System.Drawing.Size(10,500)
|
|
$VERZurueckButton.Size = New-Object System.Drawing.Size(100,30)
|
|
$VERZurueckButton.Text = "Zurueck"
|
|
$VERZurueckButton.Add_Click({
|
|
$Pfad = $VERPfadFeld.Text
|
|
#Pfad aktualisieren
|
|
VerzeichnisZurueck "ver" $Pfad
|
|
})
|
|
$VERZurueckButton.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionButtons "ver" $Taste
|
|
})
|
|
$TabSeiteZielVerzeichnisAuswaehlen.Controls.Add($VERZurueckButton)
|
|
|
|
# AuswaehlenButton
|
|
$VERAuswaehlenButton = New-Object System.Windows.Forms.Button
|
|
$VERAuswaehlenButton.Location = New-Object System.Drawing.Size(630,500)
|
|
$VERAuswaehlenButton.Size = New-Object System.Drawing.Size(100,30)
|
|
$VERAuswaehlenButton.Text = "Auswaehlen"
|
|
$VERAuswaehlenButton.Add_Click({
|
|
# Variablen bestimmen zur uebergabe
|
|
$Auswahl = $VERListeOrdnernamen.SelectedItem
|
|
$Pfad = $VERPfadFeld.Text
|
|
if ($($VERListeOrdnernamen.Items[0] -eq ""))
|
|
{
|
|
VERAuswahlBestaetigt $Pfad $Auswahl
|
|
}
|
|
else
|
|
{
|
|
# Pfad aktualisieren
|
|
VerzeichnisAuswaehlen "ver" $Pfad $Auswahl
|
|
}
|
|
})
|
|
$VERAuswaehlenButton.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionButtons "ver" $Taste
|
|
})
|
|
$TabSeiteZielVerzeichnisAuswaehlen.Controls.Add($VERAuswaehlenButton)
|
|
|
|
# BestaetigenButton
|
|
$VERBestaetigenButton = New-Object System.Windows.Forms.Button
|
|
$VERBestaetigenButton.Location = New-Object System.Drawing.Size(750,500)
|
|
$VERBestaetigenButton.Size = New-Object System.Drawing.Size(100,30)
|
|
$VERBestaetigenButton.Text = "Bestaetigen"
|
|
$VERBestaetigenButton.Add_Click({
|
|
$Auswahl = $VERListeOrdnernamen.SelectedItem
|
|
$Pfad = $VERPfadFeld.Text
|
|
VERAuswahlBestaetigt $Pfad $Auswahl
|
|
})
|
|
$VERBestaetigenButton.Add_KeyDown({
|
|
# Reaktion bei gedrueckter Taste
|
|
$Taste = $_.KeyCode
|
|
TastenReaktionButtons "ver" $Taste
|
|
})
|
|
$TabSeiteZielVerzeichnisAuswaehlen.Controls.Add($VERBestaetigenButton)
|
|
|
|
# Tab: Ausgabe Fortschritt
|
|
$TabSeiteFortschrittsanzeige = New-Object System.Windows.Forms.TabPage
|
|
$TabSeiteFortschrittsanzeige.TabIndex = 2
|
|
$TabSeiteFortschrittsanzeige.UseVisualStyleBackColor = $true
|
|
$TabSeiteFortschrittsanzeige.Text = "Bearbeitungsfortschritt"
|
|
$TabSeiteFortschrittsanzeige.DataBindings.DefaultDataSourceUpdateMode = 0
|
|
$TabBasis.Controls.Add($TabSeiteFortschrittsanzeige)
|
|
|
|
#Textfeld fuer Konstante "Aktuelle Aufgabe"
|
|
$FATextfeld1 = New-Object System.Windows.Forms.Label
|
|
$FATextfeld1.Location = New-Object System.Drawing.Size(10,10)
|
|
$FATextfeld1.Size = New-Object System.Drawing.Size(130,20)
|
|
$FATextfeld1.Text = "Aktuelle Aufgabe"
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeld1)
|
|
|
|
#Textfeld fuer Konstante "Erledigte Aufgaben"
|
|
$FATextfeld2 = New-Object System.Windows.Forms.Label
|
|
$FATextfeld2.Location = New-Object System.Drawing.Size(10,55)
|
|
$FATextfeld2.Size = New-Object System.Drawing.Size(430,20)
|
|
$FATextfeld2.Text = "Erledigte Aufgaben"
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeld2)
|
|
|
|
#TextfeldAktuelleAufgabe
|
|
$FATextfeldAktuelleAufgabe = New-Object System.Windows.Forms.Label
|
|
$FATextfeldAktuelleAufgabe.Location = New-Object System.Drawing.Size(150,10)
|
|
$FATextfeldAktuelleAufgabe.Size = New-Object System.Drawing.Size(710,60)
|
|
$FATextfeldAktuelleAufgabe.Font = New-Object System.Drawing.Font("Arial",13,[System.Drawing.FontStyle]::Regular)
|
|
$FATextfeldAktuelleAufgabe.Text = "txt-Datei auswaehlen"
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeldAktuelleAufgabe)
|
|
|
|
#ListeErledigteAufgaben
|
|
$FAListeErledigteAufgaben = New-Object System.Windows.Forms.ListBox
|
|
$FAListeErledigteAufgaben.Location = New-Object System.Drawing.Size(10,85)
|
|
$FAListeErledigteAufgaben.Size = New-Object System.Drawing.Size(860,20)
|
|
$FAListeErledigteAufgaben.Height = 200
|
|
$FAListeErledigteAufgaben.Font = New-Object System.Drawing.Font("Arial",12,[System.Drawing.FontStyle]::Regular)
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FAListeErledigteAufgaben)
|
|
|
|
#Textfeld fuer Konstante "Fortschritt Excel-Dateien beschreiben"
|
|
$FATextfeld3 = New-Object System.Windows.Forms.Label
|
|
$FATextfeld3.Location = New-Object System.Drawing.Size(10,300)
|
|
$FATextfeld3.Size = New-Object System.Drawing.Size(430,20)
|
|
$FATextfeld3.Text = "Fortschritt Excel-Dateien beschreiben"
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeld3)
|
|
|
|
#Fortschrittsbar fuer das Schreiben von Werten in die Excel-Tabelle
|
|
$FAFortschrittsbar = New-Object System.Windows.Forms.ProgressBar
|
|
$FAFortschrittsbar.Location = New-Object System.Drawing.Size(10,320)
|
|
$FAFortschrittsbar.Size = New-Object System.Drawing.Size(860,30)
|
|
$FAFortschrittsbar.Value = 0
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FAFortschrittsbar)
|
|
|
|
#Textfeld zum globalen zwischenspeichern des aktuellen Werts fuer obige Fortschrittsbar, um exaktere Werte nutzen zu koennen
|
|
$FATextfeldRealwertFortschrittsbar = New-Object System.Windows.Forms.Label
|
|
|
|
#Textfeld fuer Konstante "Bearbeitete Eintraege:"
|
|
$FATextfeld4 = New-Object System.Windows.Forms.Label
|
|
$FATextfeld4.Location = New-Object System.Drawing.Size(10,370)
|
|
$FATextfeld4.Size = New-Object System.Drawing.Size(140,20)
|
|
$FATextfeld4.Text = "Bearbeitete Eintraege:"
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeld4)
|
|
|
|
#Textfeld fuer Konstante "Gesamteintraege:"
|
|
$FATextfeld5 = New-Object System.Windows.Forms.Label
|
|
$FATextfeld5.Location = New-Object System.Drawing.Size(10,400)
|
|
$FATextfeld5.Size = New-Object System.Drawing.Size(100,20)
|
|
$FATextfeld5.Text = "Gesamteintraege:"
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeld5)
|
|
|
|
#TextfeldBearbeitetEintraege fuer die Ausgabe eines Zahlenwerts beim schreiben von Werten in die Excel-Tabelle
|
|
$FATextfeldBearbeiteteEintraege = New-Object System.Windows.Forms.Label
|
|
$FATextfeldBearbeiteteEintraege.Location = New-Object System.Drawing.Size(170,370)
|
|
$FATextfeldBearbeiteteEintraege.Size = New-Object System.Drawing.Size(430,20)
|
|
$FATextfeldBearbeiteteEintraege.Text = "0"
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeldBearbeiteteEintraege)
|
|
|
|
#TextfeldGesamtEintraege fuer die Ausgabe der insgesamt zu schreibenden Eintraege in die Excel-Tabelle
|
|
$FATextfeldGesamtEintraege = New-Object System.Windows.Forms.Label
|
|
$FATextfeldGesamtEintraege.Location = New-Object System.Drawing.Size(170,400)
|
|
$FATextfeldGesamtEintraege.Size = New-Object System.Drawing.Size(430,20)
|
|
$TabSeiteFortschrittsanzeige.Controls.Add($FATextfeldGesamtEintraege)
|
|
|
|
# Tab: Ausgabe doppelte Ein- und Ausgaenge sowie nicht zurordnebare Betriebsmittel
|
|
$TabSeiteDuplikate = New-Object System.Windows.Forms.TabPage
|
|
$TabSeiteDuplikate.TabIndex = 3
|
|
$TabSeiteDuplikate.UseVisualStyleBackColor = $true
|
|
$TabSeiteDuplikate.Text = "Doppelte Ein- und Ausgaenge"
|
|
$TabSeiteDuplikate.DataBindings.DefaultDataSourceUpdateMode = 0
|
|
$TabBasis.Controls.Add($TabSeiteDuplikate)
|
|
|
|
#Textfeld fuer Konstante "Bei den Eingaengen gibt es folgende Duplikate: "
|
|
$DPTextfeld1 = New-Object System.Windows.Forms.Label
|
|
$DPTextfeld1.Location = New-Object System.Drawing.Size(10,10)
|
|
$DPTextfeld1.Size = New-Object System.Drawing.Size(275,40)
|
|
$DPTextfeld1.Text = "Bei den Eingaengen gibt es folgende Duplikate: "
|
|
$TabSeiteDuplikate.Controls.Add($DPTextfeld1)
|
|
|
|
#ListeEingaenge zur Ausgabe der doppelt genutzten Eingaenge
|
|
$DPListeEingaenge = New-Object System.Windows.Forms.DataGridView
|
|
$DPListeEingaenge.Location = New-Object System.Drawing.Size(10,60)
|
|
$DPListeEingaenge.Size = New-Object System.Drawing.Size(275,20)
|
|
$DPListeEingaenge.Height = 430
|
|
$DPListeEingaenge.ColumnCount = 2
|
|
$DPListeEingaenge.ColumnHeadersVisible = $true
|
|
$DPListeEingaenge.Columns[0].Name = "Zeile"
|
|
$DPListeEingaenge.Columns[1].Name = "Kennzeichnung"
|
|
$TabSeiteDuplikate.Controls.Add($DPListeEingaenge)
|
|
|
|
#Textfeld fuer Konstante "Bei den Ausgaengen gibt es folgende Duplikate: "
|
|
$DPTextfeld2 = New-Object System.Windows.Forms.Label
|
|
$DPTextfeld2.Location = New-Object System.Drawing.Size(295,10)
|
|
$DPTextfeld2.Size = New-Object System.Drawing.Size(275,40)
|
|
$DPTextfeld2.Text = "Bei den Ausgaengen gibt es folgende Duplikate: "
|
|
$TabSeiteDuplikate.Controls.Add($DPTextfeld2)
|
|
|
|
#ListeAusgaenge zur Ausgabe der doppelt genutzten Ausgaenge
|
|
$DPListeAusgaenge = New-Object System.Windows.Forms.DataGridView
|
|
$DPListeAusgaenge.Location = New-Object System.Drawing.Size(295,60)
|
|
$DPListeAusgaenge.Size = New-Object System.Drawing.Size(275,20)
|
|
$DPListeAusgaenge.Height = 430
|
|
$DPListeAusgaenge.ColumnCount = 2
|
|
$DPListeAusgaenge.ColumnHeadersVisible = $true
|
|
$DPListeAusgaenge.Columns[0].Name = "Zeile"
|
|
$DPListeAusgaenge.Columns[1].Name = "Kennzeichnung"
|
|
$TabSeiteDuplikate.Controls.Add($DPListeAusgaenge)
|
|
|
|
#Textfeld fuer Konstante "Folgende Eintraege konnten keinem Betriebsmittel zugewiesen werden: "
|
|
$DPTextfeld3 = New-Object System.Windows.Forms.Label
|
|
$DPTextfeld3.Location = New-Object System.Drawing.Size(580,10)
|
|
$DPTextfeld3.Size = New-Object System.Drawing.Size(275,40)
|
|
$DPTextfeld3.Text = "Folgende Eintraege konnten keinem Betriebsmittel zugewiesen werden:"
|
|
$TabSeiteDuplikate.Controls.Add($DPTextfeld3)
|
|
|
|
#ListeFehler zur Ausgabe von Eintraegen, die weder einem Ein-, noch einem Ausgang zugeordnet werden konnten
|
|
$DPListeFehler = New-Object System.Windows.Forms.DataGridView
|
|
$DPListeFehler.Location = New-Object System.Drawing.Size(580,60)
|
|
$DPListeFehler.Size = New-Object System.Drawing.Size(275,20)
|
|
$DPListeFehler.Height = 430
|
|
$DPListeFehler.ColumnCount = 2
|
|
$DPListeFehler.ColumnHeadersVisible = $true
|
|
$DPListeFehler.Columns[0].Name = "Zeile"
|
|
$DPListeFehler.Columns[1].Name = "Kennzeichnung"
|
|
$TabSeiteDuplikate.Controls.Add($DPListeFehler)
|
|
|
|
#BestaetigenButton zum beenden des Programms
|
|
$DPBestaetigenButton = New-Object System.Windows.Forms.Button
|
|
$DPBestaetigenButton.Location = New-Object System.Drawing.Size(10,500)
|
|
$DPBestaetigenButton.Size = New-Object System.Drawing.Size(860,30)
|
|
$DPBestaetigenButton.Text = "Programm beenden"
|
|
$DPBestaetigenButton.Add_Click({
|
|
$Fenster.Dispose()
|
|
return
|
|
})
|
|
$TabSeiteDuplikate.Controls.Add($DPBestaetigenButton)
|
|
|
|
# Tab: Einstellungen
|
|
$TabSeiteEigenschaften = New-Object System.Windows.Forms.TabPage
|
|
$TabSeiteEigenschaften.TabIndex = 0
|
|
$TabSeiteEigenschaften.UseVisualStyleBackColor = $true
|
|
$TabSeiteEigenschaften.Text = "Einstellungen"
|
|
$TabSeiteEigenschaften.DataBindings.DefaultDataSourceUpdateMode = 0
|
|
$TabBasis.Controls.Add($TabSeiteEigenschaften)
|
|
|
|
#Zum festlegen eines gleichen Abstands zum linken Rand
|
|
$BasisBreite = 10
|
|
|
|
#Textfeld fuer Konstante "Startverzeichnis Auswahl .txt-Datei: "
|
|
$ESTextfeld1 = New-Object System.Windows.Forms.Label
|
|
$ESTextfeld1.Location = New-Object System.Drawing.Size($BasisBreite,10)
|
|
$ESTextfeld1.Size = New-Object System.Drawing.Size(200,20)
|
|
$ESTextfeld1.Text = "Startverzeichnis Auswahl .txt-Datei:"
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeld1)
|
|
|
|
#Textfeld zur Ausgabe des aktuell gespeicherten StartPfades
|
|
$ESTextfeldStartPfad = New-Object System.Windows.Forms.Label
|
|
$ESTextfeldStartPfad.Location = New-Object System.Drawing.Size(($BasisBreite+200),10)
|
|
$ESTextfeldStartPfad.Size = New-Object System.Drawing.Size(510,20)
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeldStartPfad)
|
|
|
|
#StartPfadAenderButton
|
|
$ESStartPfadAendernButton = New-Object System.Windows.Forms.Button
|
|
$ESStartPfadAendernButton.Location = New-Object System.Drawing.Size(730,10)
|
|
$ESStartPfadAendernButton.Size = New-Object System.Drawing.Size(150,30)
|
|
$ESStartPfadAendernButton.Text = "Aendern"
|
|
$ESStartPfadAendernButton.Add_Click({
|
|
VerzeichnisAendern "StartPfad"
|
|
})
|
|
$TabSeiteEigenschaften.Controls.Add($ESStartPfadAendernButton)
|
|
|
|
#Textfeld fuer Konstante "Startverzeichnis bei Auswahl des Zielverzeichnisses der Datei(en): "
|
|
$ESTextfeld2 = New-Object System.Windows.Forms.Label
|
|
$ESTextfeld2.Location = New-Object System.Drawing.Size($BasisBreite,45)
|
|
$ESTextfeld2.Size = New-Object System.Drawing.Size(450,20)
|
|
$ESTextfeld2.Text = "Startverzeichnis bei Auswahl des Zielverzeichnisses der Datei(en):"
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeld2)
|
|
|
|
#RadioButtonWieTXT
|
|
$ESRadioButtonWieTXT = New-Object System.Windows.Forms.RadioButton
|
|
$ESRadioButtonWieTXT.Location = New-Object System.Drawing.Size(10,10)
|
|
$ESRadioButtonWieTXT.Size = New-Object System.Drawing.Size(163,18)
|
|
$ESRadioButtonWieTXT.Name = "ESRadioButtonWieTXT"
|
|
$ESRadioButtonWieTXT.Text = "Gleich Startpfad .txt-Datei"
|
|
|
|
#RadioButtonWieZieldatei
|
|
$ESRadioButtonWieZieldatei = New-Object System.Windows.Forms.RadioButton
|
|
$ESRadioButtonWieZieldatei.Location = New-Object System.Drawing.Size(173,10)
|
|
$ESRadioButtonWieZieldatei.Size = New-Object System.Drawing.Size(179,18)
|
|
$ESRadioButtonWieZieldatei.Name = "ESRadioButtonWieZieldatei"
|
|
$ESRadioButtonWieZieldatei.Text = "Gleich gewaehlter .txt-Datei"
|
|
|
|
#RadioButtonEigenerPfad
|
|
$ESRadioButtonEigenerPfad = New-Object System.Windows.Forms.RadioButton
|
|
$ESRadioButtonEigenerPfad.Location = New-Object System.Drawing.Size(352,10)
|
|
$ESRadioButtonEigenerPfad.Size = New-Object System.Drawing.Size(94,18)
|
|
$ESRadioButtonEigenerPfad.Name = "ESRadioButtonEigenerPfad"
|
|
$ESRadioButtonEigenerPfad.Text = "Anderer Pfad"
|
|
|
|
#GroupBoxRadioButtons zum gruppieren der obigen RadioButtons
|
|
$ESGroupBoxRadioButtons = New-Object System.Windows.Forms.GroupBox
|
|
$ESGroupBoxRadioButtons.Location = New-Object System.Drawing.Size(($BasisBreite),60)
|
|
$ESGroupBoxRadioButtons.Size = New-Object System.Drawing.Size(449,30)
|
|
$ESGroupBoxRadioButtons.Controls.Add($ESRadioButtonWieTXT)
|
|
$ESGroupBoxRadioButtons.Controls.Add($ESRadioButtonWieZieldatei)
|
|
$ESGroupBoxRadioButtons.Controls.Add($ESRadioButtonEigenerPfad)
|
|
$TabSeiteEigenschaften.Controls.Add($ESGroupBoxRadioButtons)
|
|
|
|
#SpeichernButton
|
|
$ESSpeichernButton = New-Object System.Windows.Forms.Button
|
|
$ESSpeichernButton.Location = New-Object System.Drawing.Size(730,60)
|
|
$ESSpeichernButton.Size = New-Object System.Drawing.Size(150,30)
|
|
$ESSpeichernButton.Text = "Speichern"
|
|
$ESSpeichernButton.Add_Click({
|
|
EinstellungenRadioButtonSpeichern
|
|
})
|
|
$TabSeiteEigenschaften.Controls.Add($ESSpeichernButton)
|
|
|
|
#Textfeld fuer Konstante "Startverzeichnis Auswahl Zielverzeichnis: "
|
|
$ESTextfeld3 = New-Object System.Windows.Forms.Label
|
|
$ESTextfeld3.Location = New-Object System.Drawing.Size($BasisBreite,95)
|
|
$ESTextfeld3.Size = New-Object System.Drawing.Size(250,20)
|
|
$ESTextfeld3.Text = "Startverzeichnis Auswahl Zielverzeichnis:"
|
|
|
|
#TextfeldZielPfad
|
|
$ESTextfeldZielPfad = New-Object System.Windows.Forms.Label
|
|
$ESTextfeldZielPfad.Location = New-Object System.Drawing.Size(($BasisBreite+250),95)
|
|
$ESTextfeldZielPfad.Size = New-Object System.Drawing.Size(460,20)
|
|
|
|
#ZielPfadAendernButton
|
|
$ESZielPfadAendernButton = New-Object System.Windows.Forms.Button
|
|
$ESZielPfadAendernButton.Location = New-Object System.Drawing.Size(730,95)
|
|
$ESZielPfadAendernButton.Size = New-Object System.Drawing.Size(150,30)
|
|
$ESZielPfadAendernButton.Text = "Aendern"
|
|
$ESZielPfadAendernButton.Add_Click({
|
|
VerzeichnisAendern "ZielPfad"
|
|
})
|
|
|
|
|
|
#------------------- Tabelle mit ZielDateien
|
|
|
|
#Textfeld fuer Konstante "Zieldateien:"
|
|
$ESTextfeld4 = New-Object System.Windows.Forms.Label
|
|
$ESTextfeld4.Location = New-Object System.Drawing.Size($BasisBreite,140)
|
|
$ESTextfeld4.Size = New-Object System.Drawing.Size(200,20)
|
|
$ESTextfeld4.Text = "Zieldateien:"
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeld4)
|
|
|
|
#AenderungeSpeichernButton zum speichern der Werte aus der Tabelle mit den ZielDateien
|
|
$ESAenderungenSpeichernButton = New-Object System.Windows.Forms.Button
|
|
$ESAenderungenSpeichernButton.Location = New-Object System.Drawing.Size(730,$170)
|
|
$ESAenderungenSpeichernButton.Size = New-Object System.Drawing.Size(150,30)
|
|
$ESAenderungenSpeichernButton.Text = "Aenderungen Speichern"
|
|
$ESAenderungenSpeichernButton.Add_Click({
|
|
EinstellungenZielDateienSpeichern
|
|
})
|
|
$TabSeiteEigenschaften.Controls.Add($ESAenderungenSpeichernButton)
|
|
|
|
#ListeEinstellungen mit den ZielDateien und zugehoerigen Einstellungen
|
|
$ESListeEinstellungen = New-Object System.Windows.Forms.DataGridView
|
|
$ESListeEinstellungen.Location = New-Object System.Drawing.Size(10,$170)
|
|
$ESListeEinstellungen.Size = New-Object System.Drawing.Size(650,380)
|
|
$ESListeEinstellungen.ColumnCount = 4
|
|
$ESListeEinstellungen.ColumnHeadersVisible = $true
|
|
$ESListeEinstellungen.AllowUserToAddRows = $true
|
|
$ESListeEinstellungen.AllowUserToDeleteRows = $true
|
|
$ESListeEinstellungen.AutoGenerateColumns = $false
|
|
$ESListeEinstellungen.AutoSizeColumnsMode = "Fill"
|
|
$ESListeEinstellungen.Columns[0].Name = "Prefix Eingang"
|
|
$ESListeEinstellungen.Columns[1].Name = "Prefix Ausgang"
|
|
$ESListeEinstellungen.Columns[2].Name = "Dateiname"
|
|
$ESListeEinstellungen.Columns[3].Name = "Konvertierungsart"
|
|
$TabSeiteEigenschaften.Controls.Add($ESListeEinstellungen)
|
|
|
|
#Tab "Einstellungen" mit Werten beim Start befuellen
|
|
AnzeigeEinstellungenInitialisieren
|
|
|
|
$Fenster.Add_Shown({$Fenster.Activate()})
|
|
[void]$Fenster.ShowDialog()
|
|
|
|
return
|
|
}
|
|
|
|
#------------------- Funktion nur fuer das txt-GUI --------------------------
|
|
|
|
#Funktion, die beim druecken der Enter-Taste ausgeloest wird, wenn man im Dateiauswahl-Bereich ist
|
|
Function TXTReaktionReturn ($Pfad)
|
|
{
|
|
#Ueberpruefen, ob der uebergebene Pfad vorhanden ist
|
|
if (PfadExistiert $Pfad)
|
|
{
|
|
#Ende des Pfads trennen
|
|
$PfadEnde = $(Split-Path $Pfad -Leaf)
|
|
#Bei Auswahl einer Datei mit der Endung ".txt"
|
|
if ($($PfadEnde -match ".txt"))
|
|
{
|
|
#In den Tab zur Auswahl des Zielverzeichnisses wechseln
|
|
ZuVERSpringen
|
|
#Loest unbekannte Probleme in der GUI
|
|
$TXTPfadFeld.Text = $Pfad
|
|
return
|
|
}
|
|
#Bei Auswahl eines Ordners
|
|
else
|
|
{
|
|
AnzeigeAktualisieren "txt" $Pfad
|
|
}
|
|
}
|
|
#Der Pfad ist ungueltig/ existiert nicht
|
|
else
|
|
{
|
|
#Springe in die Verzeichnisauswahl
|
|
AnzeigeAktualisieren "txt" ""
|
|
}
|
|
return
|
|
}
|
|
|
|
#------------------- Funktion nur fuer das VerzeichnisWaehlen-GUI --------------------------
|
|
|
|
#Funktion, die beim bestaetigen des aktuellen Verzeichnisses genutzt wird. Sie ueberprueft zunaechst, ob das Verzeichnis vorhanden ist und wechselt dann ggf. in den Tab Fortschrittsanzeige
|
|
Function VERAuswahlBestaetigt($Pfad, $Auswahl)
|
|
{
|
|
#Zusammenfuegen von $Pfad und $Auswahl
|
|
$Pfad = Join-Path -Path $Pfad -ChildPath $Auswahl -Resolve
|
|
|
|
#Ueberpruefen, ob der Pfad vorhanden ist
|
|
if (PfadExistiert $Pfad)
|
|
{
|
|
#Wechseln in den Tab der Fortschrittsanzeige
|
|
ZuFASpringen
|
|
#Loest unbekannte Probleme in der GUI
|
|
$VERPfadfeld.Text = $Pfad
|
|
return
|
|
}
|
|
}
|
|
|
|
#Funktion, die vorauswahl fuer die Funktion AnzeigeAktualisieren trifft, weil je nach gewaehlter Nutzer-Einstellung anders reagiert werden muss
|
|
Function VERVorauswahlAnzeigeAktualisieren () {
|
|
# Todo: Soll evtl. in AnzeigeAktualisieren migriert werden. Problem: Innerhalb der Verzeichniswahl koennte man dann evtl. nicht mehr navigieren.
|
|
#Generieren des Werts des RadioButtons
|
|
$RadioButton = RadioButtonHolen
|
|
switch ($RadioButton) {
|
|
EigenerPfad {
|
|
$ZielPfad = ZielPfadHolen
|
|
AnzeigeAktualisieren "ver" $ZielPfad
|
|
}
|
|
WieTXT {
|
|
$StartPfad = StartPfadHolen
|
|
AnzeigeAktualisieren "ver" $StartPfad
|
|
}
|
|
WieZielDatei {
|
|
AnzeigeAktualisieren "ver" $TXTPfadFeld.Text
|
|
}
|
|
#Falls der Wert ungueltig ist, wird in das gleiche Verzeichnis gesprungen, dass auch bei der .txt-Datei ausgewaehlt wurde
|
|
Default {
|
|
AnzeigeAktualisieren "ver" $TXTPfadFeld.Text
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#------------------- Funktionen zum wechseln der Tabs --------------------------
|
|
|
|
#Funktion, die in den Tab zur Verzeichnisauswahl des Zielverzeichnisses wechselt und dabei benoetigte Schritte durchfuehrt
|
|
Function ZuVERSpringen
|
|
{
|
|
VERVorauswahlAnzeigeAktualisieren
|
|
AufgabenAktualisieren "Zielverzeichnis auswaehlen"
|
|
$TabBasis.SelectedIndex = 1
|
|
}
|
|
|
|
#Funktion, die in den Tab zur Fortschrittsanzeige wechselt und dabei benoetigte Schritte durchfuehrt
|
|
Function ZuFASpringen
|
|
{
|
|
$TabBasis.SelectedIndex = 2
|
|
|
|
#Ermitteln von Variablen
|
|
$ZielDateien = ZielDateienHolen
|
|
$PfadUrsprungsdatei = $TXTPfadFeld.Text
|
|
$PfadZielDateien = $VERPfadFeld.Text
|
|
|
|
#Fuer jede in der Einstellungsdatei hinterlegte Zieldatei die Konvertierung durchfuehren
|
|
foreach ($ZielDatei in $ZielDateien) {
|
|
#Erstellen des Zielpfads
|
|
$ZielPfad = ExcelDateiNameErstellen $($ZielDatei.DateiName) $PfadUrsprungsdatei $PfadZielDateien
|
|
|
|
AufgabenAktualisieren $("Excel-Datei $($ZielDatei.DateiName) erstellen")
|
|
|
|
#Unterscheiden des Wandlungstyps und aufruf der entsprechenden Funktion; kein oder falscher Wandlungstyp gilt als "Simpel"
|
|
if ($($ZielDatei.WandlungsTyp) -eq "TIA") {
|
|
$Gleiche = ExcelDateiBeschreibenTIA $PfadUrsprungsdatei $($ZielDatei.PrefixEingang) $($ZielDatei.PrefixAusgang) $ZielPfad
|
|
}
|
|
elseif ($($ZielDatei.WandlungsTyp) -eq "Simpel") {
|
|
$Gleiche = ExcelDateiBeschreibenSimpel $PfadUrsprungsdatei $($ZielDatei.PrefixEingang) $($ZielDatei.PrefixAusgang) $ZielPfad
|
|
}
|
|
elseif ($($ZielDatei.WandlungsTyp) -eq "WSCAD") {
|
|
$Gleiche = ExcelDateiBeschreibenWSCAD $PfadUrsprungsdatei $($ZielDatei.PrefixEingang) $($ZielDatei.PrefixAusgang) $ZielPfad
|
|
}
|
|
else {
|
|
$Gleiche = ExcelDateiBeschreibenSimpel $PfadUrsprungsdatei $($ZielDatei.PrefixEingang) $($ZielDatei.PrefixAusgang) $ZielPfad
|
|
}
|
|
}
|
|
|
|
#Aufteilen der Rueckgabe in gleiche Eingaenge, gleiche Ausgaenge und Betriebsmittel, die weder Ein- noch Ausgaengen zugeordnet werden koennen, also Fehler sind
|
|
$GleicheEingaenge = $Gleiche[0]
|
|
$GleicheAusgaenge = $Gleiche[1]
|
|
$Fehler = $Gleiche[2]
|
|
|
|
AufgabenAktualisieren "Ausgabe Duplikate und Fehler"
|
|
#Wechseln in die Ansicht zur Ausgabe von Duplikaten und Fehlern
|
|
ZuDPSpringen $GleicheEingaenge $GleicheAusgaenge $Fehler
|
|
}
|
|
|
|
#Funktion, die in den Tab zur Ansicht der Ausgabe von Duplikaten und Fehlern wechselt und dabei benoetigte Schritte durchfuehrt
|
|
Function ZuDPSpringen ($GleicheEingaenge, $GleicheAusgaenge, $Fehler)
|
|
{
|
|
#Liste der gleichen Eingaenge befuellen
|
|
foreach ($GleichenEingang in $GleicheEingaenge) {
|
|
$DPListeEingaenge.Rows.Add($($GleichenEingang.Zeile),($GleichenEingang.Name))
|
|
}
|
|
|
|
#Liste der gleichen Ausgaenge befuellen
|
|
foreach ($GleichenAusgang in $GleicheAusgaenge) {
|
|
$DPListeAusgaenge.Rows.Add($($GleichenAusgang.Zeile),($GleichenAusgang.Name))
|
|
}
|
|
|
|
#Liste der nicht zuweisbaren Zeilen befuellen
|
|
foreach ($Fehlen in $Fehler) {
|
|
$DPListeFehler.Rows.Add($($Fehlen.Zeile),($Fehlen.Name))
|
|
}
|
|
|
|
#Tab oeffnen
|
|
$TabBasis.SelectedIndex = 3
|
|
|
|
# Werte zuruecksetzen, um weitere durchlauefe zu ermoeglichen
|
|
# Todo: Fehler und Duplikate zuruecksetzen!!! Ueberpruefen, ob weitere Werte zurueckgesetzt werden muessen
|
|
VERVorauswahlAnzeigeAktualisieren
|
|
AnzeigeAktualisieren "txt" $($ESTextfeldStartPfad.Text)
|
|
$FAFortschrittsbar.Value = 0
|
|
$FATextfeldBearbeiteteEintraege.Text = "0"
|
|
}
|
|
|
|
#------------------- Funktionen fuer alle GUIs --------------------------
|
|
|
|
|
|
#Funktion, um die Ansicht der Datei- und Ordnerauswahl zu aktualisieren
|
|
#Bei falschem/ nicht existierendem/ leeren Pfad wird in die Ansicht zur Laufwerkswahl gewechselt
|
|
Function AnzeigeAktualisieren ($AuswahlTyp, $Pfad)
|
|
{
|
|
# Ueberpruefen, ob es das Verzeichnis gibt
|
|
if (PfadExistiert $Pfad)
|
|
{
|
|
#Ermitteln der Auswahloptionen (Ordner und ggf. .txt-Dateien)
|
|
$Optionen = Optionen $AuswahlTyp $Pfad
|
|
}
|
|
else {
|
|
#Ermitteln der Auswahloptionen (Laufwerke)
|
|
$Optionen = LaufwerkeFinden
|
|
$Pfad = ""
|
|
}
|
|
|
|
#Nur fuer die Ansicht bei Auswahl einer .txt-Datei: Aktualisieren der GUI
|
|
if ($($AuswahlTyp -eq "txt")) {
|
|
$TXTPfadFeld.Text = $Pfad
|
|
$TXTListeOrdnernamen.Items.Clear()
|
|
foreach ($Option in $Optionen)
|
|
{
|
|
if ($Option.Length -gt 0)
|
|
{
|
|
$TXTListeOrdnernamen.Items.Add($Option)
|
|
}
|
|
}
|
|
}
|
|
#Nur fuer die Ansicht bei Auswahl eines Verzeichnisses: Aktualisieren der GUI
|
|
elseif ($($AuswahlTyp -eq "ver")) {
|
|
$VERPfadFeld.Text = $Pfad
|
|
$VERListeOrdnernamen.Items.Clear()
|
|
foreach ($Option in $Optionen)
|
|
{
|
|
if ($Option.Length -gt 0)
|
|
{
|
|
$VERListeOrdnernamen.Items.Add($Option)
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
#Funktion, die bei Auswahl eines Verzeichnisses oder einer .txt-Datei aufgerufen wird, um Fehler zu erkennen
|
|
Function VerzeichnisAuswaehlen ($AuswahlTyp, $Pfad, $Auswahl)
|
|
{
|
|
#Falls das bisherige Verzeichnis existiert, fuege es mit der getroffenen Auswahl zusammen
|
|
if (PfadExistiert $Pfad)
|
|
{
|
|
$Pfad = Join-Path -Path $Pfad -ChildPath $Auswahl -Resolve
|
|
}
|
|
#Falls der Pfad die Laenge 0 hat, wurde ein Laufwerk gewaehlt
|
|
elseif ($Pfad.Length -eq 0) {
|
|
$Pfad = $Auswahl
|
|
}
|
|
#Fehlerfall/ ungueltiger Pfad: zurueck zu Laufwerken navigieren
|
|
else {
|
|
$Pfad = ""
|
|
}
|
|
|
|
#Erkennen, ob .txt-Datei gewaehlt wurde -> ggf. Auswahl abgeschlossen
|
|
#Falls es der Aufruf vom Reiter der Auswahl der txt-Dateiauswahl war und der gewaehlte Eintrag die Endung ".txt" hat, ist die Auswahl abgeschlossen
|
|
if ($($($Auswahl -match ".txt") -and $($AuswahlTyp -eq "txt")))
|
|
{
|
|
#Fuer den Gesamtfortschritt Anzahl Dateien auslesen und mit der Anzahl der zu erstellenden Dateien (=Zeilen in der urspruenglichen Datei) multiplizieren
|
|
#Dies ist nur die Mindestanzahl der Eintraege, die sich erhoet, falls nicht alle Anschluesse der SPS genutzt werden (i.d.R. der Fall). Dies erfolgt in der Funktion "AnschluesseErgaenzen"
|
|
$Datei = Get-Content $Pfad
|
|
$ZielDateien = ZielDateienHolen
|
|
$FATextfeldGesamtEintraege.Text = $($ZielDateien.count) * $($Datei.Length)
|
|
|
|
#In die Ansicht der Verzeichniswahl wechseln
|
|
ZuVERSpringen
|
|
#Loest unbekannte Probleme in der GUI
|
|
$TXTPfadFeld.Text = $Pfad
|
|
return
|
|
}
|
|
#Aktualisieren der entsprechenden Ansicht mit dem neuen Pfad
|
|
AnzeigeAktualisieren $AuswahlTyp $Pfad
|
|
return
|
|
}
|
|
|
|
#Funktion, die den Tastendruck der Loeschen-Taste managt
|
|
Function VerzeichnisZurueck ($AuswahlTyp, $Pfad)
|
|
{
|
|
#Falls die Laenge des bisherigen Pfades min. 3 Zeichen lang ist, muessen anschließend Ordner angezeigt werden, ansonsten Laufwerke
|
|
if ($Pfad.Length -gt 3)
|
|
{
|
|
$Pfad = Split-Path $Pfad
|
|
}
|
|
else
|
|
{
|
|
$Pfad = ""
|
|
}
|
|
#Aktualisieren der entsprechenden Ansicht mit dem neuen Pfad
|
|
AnzeigeAktualisieren $AuswahlTyp $Pfad
|
|
return
|
|
}
|
|
|
|
#Funktion, die auf Tastendruck im PfadFeld reagiert
|
|
Function TastenReaktionPfadFeld($AuswahlTyp, $Taste)
|
|
{
|
|
#Unterscheiden, ob der Tastendruck in der Ansicht der Verzeichnisauswahl oder der .txt-Dateiauswahl erfolgt ist
|
|
if ($AuswahlTyp -eq "txt") {
|
|
#Unterscheiden, welche Taste gedrueckt wurde
|
|
switch ($Taste){
|
|
"Return" {
|
|
$Pfad = $TXTPfadFeld.Text
|
|
TXTReaktionReturn $Pfad
|
|
}
|
|
Default {
|
|
}
|
|
}
|
|
}
|
|
elseif ($AuswahlTyp -eq "ver") {
|
|
#Unterscheiden, welche Taste gedrueckt wurde
|
|
switch ($Taste) {
|
|
"Return" {
|
|
$Pfad = $VERPfadFeld.Text
|
|
AnzeigeAktualisieren "ver" $Pfad
|
|
}
|
|
Default {
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
#Funktion, die auf Tastendruck in der Liste der Ordnernamen reagiert
|
|
Function TastenReaktionListeOrdnernamen($AuswahlTyp, $Taste)
|
|
{
|
|
#Unterscheiden, ob der Tastendruck in der Ansicht der Verzeichnisauswahl oder der .txt-Dateiauswahl erfolgt ist
|
|
if ($AuswahlTyp -eq "txt"){
|
|
#Unterscheiden, welche Taste gedrueckt wurde
|
|
switch ($Taste){
|
|
"Return" {
|
|
$Auswahl = $TXTListeOrdnernamen.SelectedItem
|
|
$Pfad = $TXTPfadFeld.Text
|
|
VerzeichnisAuswaehlen $AuswahlTyp $Pfad $Auswahl
|
|
}
|
|
"Back" {
|
|
$Pfad = $TXTPfadFeld.Text
|
|
# Pfad aktualisieren
|
|
VerzeichnisZurueck $AuswahlTyp $Pfad
|
|
}
|
|
Default {
|
|
}
|
|
}
|
|
}
|
|
elseif ($AuswahlTyp -eq "ver") {
|
|
#Unterscheiden, welche Taste gedrueckt wurde
|
|
switch ($Taste) {
|
|
"Return" {
|
|
$Auswahl = $VERListeOrdnernamen.SelectedItem
|
|
$Pfad = $VERPfadFeld.Text
|
|
VerzeichnisAuswaehlen $AuswahlTyp $Pfad $Auswahl
|
|
}
|
|
"Back" {
|
|
$Pfad = $VERPfadFeld.Text
|
|
VerzeichnisZurueck $AuswahlTyp $Pfad
|
|
}
|
|
#ShiftKey bedeutet, dass das aktuelle verzeichnis bestaetigt werden soll
|
|
"ShiftKey" {
|
|
$Pfad = $VERPfadFeld.Text
|
|
$Auswahl = $VERListeOrdnernamen.SelectedItem
|
|
ReaktionShiftKey $Pfad $Auswahl
|
|
}
|
|
Default {
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
#Funktion, die auf Tastendruck auf den Buttons/Knoepfen reagiert
|
|
Function TastenReaktionButtons($AuswahlTyp, $Taste)
|
|
{
|
|
#Unterscheiden, ob der Tastendruck in der Ansicht der Verzeichnisauswahl oder der .txt-Dateiauswahl erfolgt ist
|
|
if ($AuswahlTyp -eq "txt") {
|
|
#Unterscheiden, welche Taste gedrueckt wurde
|
|
switch ($Taste){
|
|
"Back" {
|
|
$Pfad = $TXTPfadFeld.Text
|
|
# Pfad aktualisieren
|
|
VerzeichnisZurueck $AuswahlTyp $Pfad
|
|
}
|
|
Default {
|
|
}
|
|
}
|
|
}
|
|
elseif ($AuswahlTyp -eq "ver") {
|
|
#Unterscheiden, welche Taste gedrueckt wurde
|
|
switch ($Taste) {
|
|
"Back" {
|
|
$Pfad = $VERPfadFeld.Text
|
|
VerzeichnisZurueck $AuswahlTyp $Pfad
|
|
}
|
|
#ShiftKey bedeutet, dass das aktuelle verzeichnis bestaetigt werden soll
|
|
"ShiftKey" {
|
|
$Pfad = $VERPfadFeld.Text
|
|
$Auswahl = $VERListeOrdnernamen.SelectedItem
|
|
ReaktionShiftKey $Pfad $Auswahl
|
|
}
|
|
Default {
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
#Funktion, die in Abhaenigigkeit des Pfades und des Auswahltyps (.txt-Datei oder Verzeichnis) die Auswahloptionen (also Unterordner oder Unterordner und .txt-Dateien) zurueckgibt
|
|
Function Optionen($AuswahlTyp, $Pfad)
|
|
{
|
|
#Zuweisen der Unterordner
|
|
#Typzuweisung noetig, da aus unbekanntem Grund sonst Unterordner, die mit "_" beginnen, nicht gefunden werden koennen
|
|
[System.Object[]]$UnterOrdner = UnterOrdnerFinden $Pfad
|
|
|
|
#Bei Auswahltp "txt" zusaetzlich auch diese zuweisen und alles zurueckgeben
|
|
if ($AuswahlTyp -eq "txt") {
|
|
$TxtDateien = TxtDateienFinden $Pfad
|
|
#Gibt auch Index und Typ (System.IO.DirectoryInfo bzw. System.String) zurueck, verursacht aber keine Probleme
|
|
$Optionen = $UnterOrdner + $TxtDateien
|
|
}
|
|
#Bei Auswahltyp "ver" sind die Optionen nur die Unterordner
|
|
elseif ($AuswahlTyp -eq "ver") {
|
|
#Gibt auch Index und Typ (System.IO.DirectoryInfo bzw. System.String) zurueck, verursacht aber keine Probleme
|
|
$Optionen = $UnterOrdner
|
|
}
|
|
return $Optionen
|
|
}
|
|
|
|
#Funktion, die ueberprueft, ob ein gegebener Pfad vorhanden ist. Pfad mit der Endung "*.txt" werden auch als vorhanden gewertet
|
|
Function PfadExistiert ($Pfad)
|
|
{
|
|
#Um Abzufangen, dass Test-Path mit leerem Wert durchlaufen wird. Leere Verzeichnisse gelten als ungueltig.
|
|
if ($Pfad.Length -eq 0) {
|
|
return $false
|
|
}
|
|
if ($(Test-Path $Pfad -PathType Container) -or $(Test-Path $Pfad -Include "*.txt"))
|
|
{
|
|
return $true
|
|
}
|
|
else
|
|
{
|
|
return $false
|
|
}
|
|
}
|
|
|
|
#Funktion, die eine Liste der Laufwerke zurueckgibt
|
|
Function LaufwerkeFinden()
|
|
{
|
|
#Festlegen der Laufwerksbuchstaben. Mit der Where-Object Bedingung werden virtuell von Powershell erzeugte Laufwerke entfernt
|
|
$Laufwerke = $(Get-PSDrive | Where-Object {$_.Free}).Name
|
|
|
|
#Hinzufuegen von ":\" an die Laufwerksbuchstaben, damit diese passend fuer den Pfad sind
|
|
$i = 0
|
|
foreach($Laufwerk in $Laufwerke)
|
|
{
|
|
$Laufwerke[$i] = $Laufwerk + ":\"
|
|
$i++
|
|
}
|
|
return $Laufwerke
|
|
}
|
|
|
|
#Funktion, die in Abhaengigkeit des Pfades eine Liste der Unterordner dieses Pfades zurueckgibt
|
|
Function UnterOrdnerFinden($Pfad)
|
|
{
|
|
#Festlegen der Unterordner
|
|
$UnterOrdner = $(Get-ChildItem $Pfad -Directory)
|
|
|
|
#Falls es Unterordner gibt, wird der restliche Pfad entfernt
|
|
if ($($UnterOrdner.Length -gt 0))
|
|
{
|
|
$Ordner = $(Split-Path $UnterOrdner -Leaf)
|
|
}
|
|
else {
|
|
$Ordner = ""
|
|
}
|
|
|
|
return $Ordner
|
|
}
|
|
|
|
#Funktion, die bei einer gegebenen Datei ueberprueft, ob diese Kompatibel ist fuer die Konvertierung
|
|
function KompatibilitaetsCheck ($SpeicherOrt){
|
|
$Inhalte = Get-Content $SpeicherOrt
|
|
#Dateien mit der Laenge 0 (also keinem Inhalt) gelten als nicht kompatibel
|
|
if ($Inhalte.Length -eq 0) {
|
|
return $false
|
|
}
|
|
else {
|
|
#Gehe durch alle Zeilen der Datei. Falls eine Zeile nicht korrekt ist, wird $false zurueckgegeben
|
|
foreach ($Zeile in $Inhalte) {
|
|
if (-not ($Zeile -match "'\w+','.+'") -and $Zeile.Length -gt 0) {
|
|
return $false
|
|
}
|
|
}
|
|
}
|
|
#Wenn keine Zeile falsch war, gilt die Datei als kompatibel
|
|
return $true
|
|
}
|
|
|
|
#Funktion, die in Abhaengigkeit eines Pfades eine Liste der .txt-Dateien zurueckgibt. Es werden nur fuer die Konvertierung kompatible Dateien zurueckgegeben
|
|
Function TxtDateienFinden($Pfad)
|
|
{
|
|
#Definieren aller im Verzeichnis vorhandenen .txt-Dateien
|
|
$TxtDateien = $(Get-Childitem $Pfad\*.txt)
|
|
$KompatibleTxtDateien = @()
|
|
|
|
#Falls .txt-Dateien gefunden wurden, pruefe diese auf kompatibilitaet
|
|
if ($TxtDateien.Length -gt 0)
|
|
{
|
|
#Jede Datei, die kompatibel ist, wird dem Arry $KompatibleTxtDateien hinzugefuegt
|
|
foreach ($TxtDatei in $TxtDateien) {
|
|
if (KompatibilitaetsCheck $TxtDatei) {
|
|
$KompatibleTxtDateien += $TxtDatei
|
|
}
|
|
}
|
|
#Falls kompatible .txt-Dateien gefunden wurden, gebe deren Namen zurueck
|
|
if ($KompatibleTxtDateien.Length -gt 0) {
|
|
return $(Split-Path $KompatibleTxtDateien -Leaf)
|
|
}
|
|
else {
|
|
return
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return
|
|
}
|
|
}
|
|
|
|
#Funktion, die den Tastedruck der Shift-Taste verarbeitet
|
|
Function ReaktionShiftKey ($Pfad, $Auswahl)
|
|
{
|
|
#Falls das Verzeichnis existiert, ist die Auswahl des Zielverzeichnisses abgeschlossen
|
|
if (PfadExistiert $Pfad)
|
|
{
|
|
VERAuswahlBestaetigt $Pfad $Auswahl
|
|
}
|
|
#Falls das Verzeichnis nicht existiert, zeige die Laufwerke an
|
|
else
|
|
{
|
|
AnzeigeAktualisieren "ver" ""
|
|
}
|
|
return
|
|
}
|
|
|
|
|
|
#Funktion, die sowohl die aktuell uebergebene Aufgabe ausgibt, als auch die Liste der vorher durchgefuehrten Aufgaben aktualisiert
|
|
Function AufgabenAktualisieren ($Aufgabe)
|
|
{
|
|
#Die zuletzt ausgefuehrte Aufgabe zu den erledigten Aufgaben hinzufuegen
|
|
$FAListeErledigteAufgaben.Items.Add($FATextfeldAktuelleAufgabe.Text)
|
|
#Die uebergebene Aufgabe als aktuell durchgefuehrte Aufgabe ausgeben
|
|
$FATextfeldAktuelleAufgabe.Text = $Aufgabe
|
|
}
|
|
|
|
#Funktion, die den Fortschrittsbalken des Dateibeschreibens bei jedem Aufruf um einen Anteil der Gesamteintraege weiter bewegt
|
|
Function DateiBeschreibenAktualisieren
|
|
{
|
|
#Stelle fest, um welchen Wert die Anzeige pro Aufruf der Funktion erhoeht werden muss. Der Wert ist entspricht 100 Prozent fortschritt
|
|
$AnteilJeAufruf = 100 / $($FATextfeldGesamtEintraege.Text)
|
|
#Erhoehen des gespeicherten Werts der Fortschrittsbar um den vorher ermittelten Anteil Aufruf
|
|
#Der Wert wird versteckt in einem Textfeld in der GUI gespeichert, weil der Wert von $FAFortschrittsbar.Value zu ungenau ist
|
|
[System.double] $FATextfeldRealwertFortschrittsbar.Text += $AnteilJeAufruf
|
|
|
|
#Da $FAFortschrittsbar.Value sich wie ein int verhaelt, ist der letzte Wert i. d. R. hoeher als 100 -> Fehler, der hiermit abgefangen wird, indem dann der Wert 100 zugewiesen wird
|
|
if ($([System.Double]$FATextfeldRealwertFortschrittsbar.Text) -ge 100)
|
|
{
|
|
$FAFortschrittsbar.Value = 100
|
|
}
|
|
#Weise ansonsten den tatsaechlichen Wert der Fortschrittsbar zu
|
|
else
|
|
{
|
|
$FAFortschrittsbar.Value = $FATextfeldRealwertFortschrittsbar.Text
|
|
}
|
|
|
|
#Ermitteln der bisher bearbeiteten Eintraege und erhoehen des Werts
|
|
[System.Int64] $BearbeiteteEintraege = $FATextfeldBearbeiteteEintraege.Text
|
|
$BearbeiteteEintraege++
|
|
#Aktualisieren der Ausgabe der bearbeiteten Eintraege
|
|
$FATextfeldBearbeiteteEintraege.Text = $BearbeiteteEintraege
|
|
}
|
|
|
|
#--------------------------------------- Start Funktionen fuer Einstellungen -------------------------------
|
|
|
|
#Funktion, die den Benutzernamen des aktuell angemeldeten Benutzers ausgibt
|
|
Function BenutzerNameHolen () {
|
|
return $env:USERNAME
|
|
}
|
|
|
|
#Funktion, die den Pfad mit Namen der Einstellungsdatei zurueckgibt. Die Einstellungsdatei liegt im gleichen Verzeichnis, in dem das Skript abgespeichert ist
|
|
Function PfadEinstellungsDateiHolen () {
|
|
# Koennte man eigentlich in einer Zeile machen, aber PS macht da Probleme
|
|
$AktuellesVerzeichnis = Get-Location
|
|
#Fuer persoenliche Einstellungsdateien werden diese in Abhaengigkeit des Benutzernamens erstellt
|
|
$Benutzer = BenutzerNameHolen
|
|
$PfadEinstellungsDatei = $("$AktuellesVerzeichnis\" + "EinstellungenSkriptKonvertierung_" + $Benutzer + ".txt")
|
|
return $PfadEinstellungsDatei
|
|
}
|
|
|
|
#Funktion, die die Inhalte (also den Text) der Einstellungsdatei zurueckgibt
|
|
Function InhalteEinstellungsDateiHolen () {
|
|
#Festlegen des Pfades
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
|
|
#Ueberpruefen, ob es den Pfad gibt. Falls er nicht vorhanden ist, erstellen der Einstellungsdatei
|
|
if (-not (Test-Path $PfadEinstellungsDatei)) {
|
|
#Die Funktion muss zugewiesen werden, weil sonst (zufaellige) Rueckgaben Probleme verursachen
|
|
$A = EinstellungsDateiErstellen
|
|
}
|
|
else {
|
|
$EinstellungsInhalte = Get-Content $PfadEinstellungsDatei
|
|
return $EinstellungsInhalte
|
|
}
|
|
}
|
|
|
|
#Funktion, die den StartPfad fuer die Auswahl der .txt-Datei aus der Einstellungsdatei ausliest und zurueckgibt
|
|
Function StartPfadHolen () {
|
|
#Inhalte der Einstellungsdatei speichern
|
|
$EinstellungsZeilen = InhalteEinstellungsDateiHolen
|
|
|
|
#Durch jede Zeile der Einstellungsdatei iterieren. Sobald in einer Zeile die Einstellung fuer StartPfad gefunden wird, wird der Wert dieser Zeile zurueckgegeben
|
|
#Sollte es mehrere Zeilen geben, in denen der StartPfad angegeben ist, wird also nur der als erstes Gefundene (also i. d. R. der Oberste) beruecksichtigt
|
|
#Falls der gefundene StartPfad nicht existiert, wird stattdessen das Verzeichnis des Skripts zurueckgegeben
|
|
foreach ($EinstellungsZeile in $EinstellungsZeilen) {
|
|
$EinstellungsBestandteile = $EinstellungsZeile.Split("|")
|
|
if ($EinstellungsBestandteile[0] -eq "StartPfad") {
|
|
$StartPfad = $EinstellungsBestandteile[1]
|
|
#Pruefen, ob es den Pfad gibt. Falls er nicht existiert, wird das aktuelle Verzeichnis als StartPfad festgelegt
|
|
if (PfadExistiert $StartPfad) {
|
|
return $StartPfad
|
|
}
|
|
else {
|
|
#Todo: Muesste eigentlich auch in der Einstellungsdatei neu gespeichert werden. Neue Funktion erstellen, die dies auch fuer VerzeichnisAendern macht?
|
|
return Get-Location
|
|
}
|
|
}
|
|
}
|
|
|
|
#Falls kein StartPfad gefunden wurde, soll der Pfad der Einstellungsdatei als Pfad angegeben werden. Dieser wird auch in der Einstellungsdatei gespeichert.
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
$StartPfad = Split-Path $PfadEinstellungsDatei
|
|
Add-Content $PfadEinstellungsDatei $("StartPfad|" + $StartPfad)
|
|
return $StartPfad
|
|
}
|
|
|
|
#Funktion, die den StartPfad fuer die Auswahl des Zielverzeichnisses aus der Einstellungsdatei ausliest und zurueckgibt
|
|
Function ZielPfadHolen () {
|
|
#Inhalte der Einstellungsdatei speichern
|
|
$EinstellungsZeilen = InhalteEinstellungsDateiHolen
|
|
|
|
#Durch jede Zeile der Einstellungsdatei iterieren. Sobald in einer Zeile die Einstellung fuer ZielPfad gefunden wird, wird der Wert dieser Zeile zurueckgegeben
|
|
#Sollte es mehrere Zeilen geben, in denen der ZielPfad angegeben ist, wird also nur der als erstes Gefundene (also i. d. R. der Oberste) beruecksichtigt
|
|
#Falls der gefundene ZielPfad nicht existiert, wird stattdessen das Verzeichnis des Skripts zurueckgegeben
|
|
foreach ($EinstellungsZeile in $EinstellungsZeilen) {
|
|
$EinstellungsBestandteile = $EinstellungsZeile.Split("|")
|
|
if ($EinstellungsBestandteile[0] -eq "ZielPfad") {
|
|
$ZielPfad = $EinstellungsBestandteile[1]
|
|
return $ZielPfad
|
|
}
|
|
}
|
|
|
|
#Falls kein ZielPfad gefunden wurde, soll der Pfad des StartVerzeichnisses als Pfad angegeben werden. Dieser wird auch in der Einstellungsdatei gespeichert.
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
$ZielPfad = StartPfadHolen
|
|
Add-Content $PfadEinstellungsDatei $("ZielPfad|" + $ZielPfad)
|
|
return $ZielPfad
|
|
}
|
|
|
|
#Funktion, die den Wert der RadioButtons aus der Einstellungsdatei ausliest und zurueckgibt.
|
|
#In den RadioButtons ist festgelegt, ob das initial geoeffnete Verzeichnis bei der Auswahl des Zielverzeichnisses
|
|
# a) gleich dem Verzeichnis ist, in dem die .txt-Datei gespeichert ist
|
|
# b) gleich dem Verzeichnis ist, das initial bei Auswahl der .txt-Datei angzeigt wird
|
|
# c) ein unabhaenig davon festgelegtes Verzeichnis ist
|
|
# Unabhaengig von der Auswahl der RadioButtons kann natuerlich frei durch die Verzeichnisse navigiert werden
|
|
Function RadioButtonHolen () {
|
|
#Inhalte der Einstellungsdatei speichern
|
|
$EinstellungsZeilen = InhalteEinstellungsDateiHolen
|
|
|
|
#Durch jede Zeile der Einstellungsdatei iterieren. Sobald in einer Zeile die Einstellung fuer RadioButton gefunden wird, wird der Wert dieser Zeile zurueckgegeben
|
|
#Sollte es mehrere Zeilen geben, in denen der RadioButton angegeben ist, wird also nur der als erstes Gefundene (also i. d. R. der Oberste) beruecksichtigt
|
|
#Falls der gefundene RadioButton nicht existiert, wird stattdessen das Verzeichnis des Skripts zurueckgegeben
|
|
foreach ($EinstellungsZeile in $EinstellungsZeilen) {
|
|
$EinstellungsBestandteile = $EinstellungsZeile.Split("|")
|
|
if ($EinstellungsBestandteile[0] -eq "VerzeichnisWahl") {
|
|
$RadioButton = $EinstellungsBestandteile[1]
|
|
return $RadioButton
|
|
}
|
|
}
|
|
|
|
#Falls kein VerzeichnisWahl gefunden wurde, soll die Einstellung auf "Gleich" gesetzt werden, also gleich dem Verzeichnis, in dem die .txt-Datei ausgewaehlt wurde.
|
|
#Dieser Wert wird auch in der Einstellungsdatei gespeichert.
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
Add-Content $PfadEinstellungsDatei $("VerzeichnisWahl|Gleich")
|
|
return "Gleich"
|
|
}
|
|
|
|
#Funktion, die eine ueberpruefte Version der zu erstellenden ZielDateien zurueckgibt.
|
|
Function ZielDateienHolen () {
|
|
#Inhalte der Einstellungsdatei speichern
|
|
$EinstellungsInhalte = InhalteEinstellungsDateiHolen
|
|
|
|
#Durch jede Zeile der Einstellungsdatei iterieren. In jeder Zeile, in der Werte fuer die ZielDateien gefunden werden, werden diese in $ZielDateien zwischengespeichert
|
|
foreach ($EinstellungsZeile in $EinstellungsInhalte) {
|
|
$EinstellungsInhalt = $EinstellungsZeile.Split("|")
|
|
if ($EinstellungsInhalt[0] -eq "Datei") {
|
|
$ZielDateien += @([PSCustomObject]@{
|
|
PrefixEingang = $EinstellungsInhalt[1]
|
|
PrefixAusgang = $EinstellungsInhalt[2]
|
|
DateiName = $EinstellungsInhalt[3]
|
|
WandlungsTyp = $EinstellungsInhalt[4]
|
|
})
|
|
}
|
|
}
|
|
#Ueberpruefen der $ZielDateien in der Funktion ZielDateienCheck
|
|
#Todo: Was passiert, wenn $ZielDateien leer ist? Wird dies als "Ich wollte nur nach Duplikaten und falschen BMKs suchen" gewertet?
|
|
$ZielDateienSicher = ZielDateienCheck $ZielDateien
|
|
return $ZielDateienSicher
|
|
}
|
|
|
|
#Funktion, die ein Array mit Einstellungswerten der zu erstellenden Dateien erhaelt und bei diesen einige Fehler findet und so gut es geht korrigiert
|
|
Function ZielDateienCheck ($ZielDateien) {
|
|
#Iterieren durch die Eintraege von $ZielDateien
|
|
#Reihenfolge der Korrektur ist wichtig! WandlungsTyp muss zuerst korrigiert werden, da Prefixe und DateiName dort einen Wert brauchen
|
|
#Wenn ein falscher Wert gefunden wird, wird die entsprechende Spalte in der GUI Rot markiert
|
|
$i = 0
|
|
foreach ($ZielDatei in $ZielDateien) {
|
|
#Fehler: Keiner oder falscher Wandlungstyp angegeben
|
|
if (($ZielDatei.WandlungsTyp -ne "TIA") -and ($ZielDatei.WandlungsTyp -ne "WSCAD") -and ($ZielDatei.WandlungsTyp -ne "Simpel")) {
|
|
$ZielDatei.WandlungsTyp = "Simpel"
|
|
$ESListeEinstellungen.Rows[$i].Cells[3].Value = $ZielDatei.WandlungsTyp
|
|
$ESListeEinstellungen.Rows[$i].Cells[3].Style.BackColor = 'Red'
|
|
}
|
|
#Fehler: Zu langer Prefix fuer Eingaenge angegeben
|
|
if ($ZielDatei.PrefixEingang.Length -gt 3) {
|
|
$ZielDatei.PrefixEingang = $ZielDatei.PrefixEingang.Substring(0,3)
|
|
$ESListeEinstellungen.Rows[$i].Cells[0].Value = $ZielDatei.PrefixEingang
|
|
$ESListeEinstellungen.Rows[$i].Cells[0].Style.BackColor = 'Red'
|
|
}
|
|
#Fehler: Kein Prefix fuer Eingaenge angegeben
|
|
if ($ZielDatei.PrefixEingang.Length -eq 0) {
|
|
switch ($($ZielDatei.WandlungsTyp)) {
|
|
Simpel {
|
|
$ZielDatei.PrefixEingang = "E"
|
|
}
|
|
TIA {
|
|
$ZielDatei.PrefixEingang = "%E"
|
|
}
|
|
WSCAD {
|
|
$ZielDatei.PrefixEingang = "E"
|
|
}
|
|
Default {
|
|
$ZielDatei.PrefixEingang = "E"
|
|
}
|
|
}
|
|
$ESListeEinstellungen.Rows[$i].Cells[0].Value = $ZielDatei.PrefixEingang
|
|
$ESListeEinstellungen.Rows[$i].Cells[0].Style.BackColor = 'Red'
|
|
}
|
|
#Fehler: Zu langer Prefix fuer Ausgaenge angegeben
|
|
if ($ZielDatei.PrefixAusgang.Length -gt 3) {
|
|
$ZielDatei.PrefixAusgang = $ZielDatei.PrefixAusgang.Substring(0,3)
|
|
$ESListeEinstellungen.Rows[$i].Cells[1].Value = $ZielDatei.PrefixAusgang
|
|
$ESListeEinstellungen.Rows[$i].Cells[1].Style.BackColor = 'Red'
|
|
}
|
|
#Fehler: Kein Prefix fuer Ausgaenge angegeben
|
|
if ($ZielDatei.PrefixAusgang.Length -eq 0) {
|
|
switch ($($ZielDatei.WandlungsTyp)) {
|
|
Simpel {
|
|
$ZielDatei.PrefixAusgang = "A"
|
|
}
|
|
TIA {
|
|
$ZielDatei.PrefixAusgang = "%A"
|
|
}
|
|
WSCAD {
|
|
$ZielDatei.PrefixAusgang = "A"
|
|
}
|
|
Default {
|
|
$ZielDatei.PrefixAusgang = "A"
|
|
}
|
|
}
|
|
$ESListeEinstellungen.Rows[$i].Cells[1].Value = $ZielDatei.PrefixAusgang
|
|
$ESListeEinstellungen.Rows[$i].Cells[1].Style.BackColor = 'Red'
|
|
}
|
|
#Fehler: Zu langer Dateiname angegeben
|
|
if ($ZielDatei.DateiName.Length -gt 150) {
|
|
$ZielDatei.DateiName = $ZielDatei.DateiName.Substring(0,150)
|
|
$ESListeEinstellungen.Rows[$i].Cells[2].Value = $ZielDatei.DateiName
|
|
$ESListeEinstellungen.Rows[$i].Cells[2].Style.BackColor = 'Red'
|
|
}
|
|
#Fehler: Kein Dateiname angegeben
|
|
if ($ZielDatei.DateiName.Length -eq 0) {
|
|
$ZielDatei.DateiName = $($ZielDatei.WandlungsTyp + "_[Ursprungsdatei]")
|
|
$ESListeEinstellungen.Rows[$i].Cells[2].Value = $ZielDatei.DateiName
|
|
$ESListeEinstellungen.Rows[$i].Cells[2].Style.BackColor = 'Red'
|
|
}
|
|
#Werte speichern fuer Rueckgabe
|
|
$GepruefteZielDateien += @([PSCustomObject]@{
|
|
PrefixEingang = $ZielDatei.PrefixEingang
|
|
PrefixAusgang = $ZielDatei.PrefixAusgang
|
|
DateiName = $ZielDatei.DateiName
|
|
WandlungsTyp = $ZielDatei.WandlungsTyp
|
|
})
|
|
$i++
|
|
}
|
|
|
|
return $GepruefteZielDateien
|
|
}
|
|
|
|
#Funktion, die eine Datei mit den Einstellungen und Standardwerten erstellt
|
|
Function EinstellungsDateiErstellen () {
|
|
#Verzeichnis, in dem die Einstellungsdatei gespeicher werden soll, festlegen
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
# Todo: Moegliches Problem mit der Funktion "StartVerzeichnisAktualisieren". Ueberpruefen!
|
|
|
|
New-Item $PfadEinstellungsDatei -ItemType File
|
|
|
|
#Festlegen von Variablen, die in die Einstellungsdatei geschrieben werden
|
|
$StartPfad = Get-Location
|
|
$ZielDateien = @([PSCustomObject]@{
|
|
PrefixEingang = "E"
|
|
PrefixAusgang = "A"
|
|
DateiName = "WSCAD_[Ursprungsdatei]"
|
|
WandlungsTyp = "WSCAD"
|
|
})
|
|
$ZielDateien += @([PSCustomObject]@{
|
|
PrefixEingang = "%E"
|
|
PrefixAusgang = "%A"
|
|
DateiName = "TIA_[Ursprungsdatei]"
|
|
WandlungsTyp = "TIA"
|
|
})
|
|
$ZielDateien += @([PSCustomObject]@{
|
|
PrefixEingang = "E"
|
|
PrefixAusgang = "A"
|
|
DateiName = "EA_[Ursprungsdatei]"
|
|
WandlungsTyp = "Simpel"
|
|
})
|
|
|
|
#Aus Gruenden der besseren Uebersichtlichkeit im Code wird das Schreiben mit Add-Content durchgefuehrt
|
|
|
|
#Schreiben in die Einstellungsdatei: Hinweise fuer den Benutzer
|
|
Add-Content $PfadEinstellungsDatei "Hinweise zur Einstellungsdatei: "
|
|
Add-Content $PfadEinstellungsDatei "1) Jeder Eintrag wird durch senkrechte Striche (|) geteilt. Der erste Bereich gibt die Art des Eintrags an."
|
|
Add-Content $PfadEinstellungsDatei " Moegliche Werte sind 'StartPfad' und 'Datei'. Es sollte nur ein StartPfad angegeben sein. Sind mehrere Angegeben,"
|
|
Add-Content $PfadEinstellungsDatei " wird der erste verwendet. Es koennen beliebig viele Dateien angegeben werden."
|
|
Add-Content $PfadEinstellungsDatei "2) Die rechte Spalte bei Dateien gibt das Konvertierungsformat fuer diese Datei an. Moeglich sind 'TIA', 'WSCAD'"
|
|
Add-Content $PfadEinstellungsDatei " und 'Simpel'. Ist ein falscher oder kein Wert angegeben, wird automatisch in 'Simpel' konvertiert."
|
|
Add-Content $PfadEinstellungsDatei "3) Die zweite Spalte von rechts bei Dateien gibt den Zieldateinamen an. Ist darin [Ursprungsdatei] enthalten,"
|
|
Add-Content $PfadEinstellungsDatei " wird dieser Teil durch den Namen der txt-Datei ersetzt, von der die Daten konvertiert werden."
|
|
Add-Content $PfadEinstellungsDatei "Nutzung des Konvertierers auf eigene Gefahr und ohne Haftungsuebernahme bei Schaeden!"
|
|
|
|
#Schreiben in die Einstellungsdatei: StartPfad, VerzeichnisWahl, ZielPfad und Datei(en)
|
|
Add-Content $PfadEinstellungsDatei $("StartPfad|" + $StartPfad)
|
|
Add-Content $PfadEinstellungsDatei $("VerzeichnisWahl|WieZielDatei")
|
|
Add-Content $PfadEinstellungsDatei $("ZielPfad|" + $StartPfad)
|
|
foreach ($ZielDatei in $ZielDateien) {
|
|
Add-Content $PfadEinstellungsDatei $("Datei|" + $ZielDatei.PrefixEingang + "|" + $ZielDatei.PrefixAusgang + "|" + $ZielDatei.DateiName + "|" + $ZielDatei.WandlungsTyp)
|
|
}
|
|
|
|
return $ZielDateien
|
|
}
|
|
|
|
#Funktion, die die Werte in die GUI fuer den Einstellungen-Reiter initialisiert
|
|
Function AnzeigeEinstellungenInitialisieren ()
|
|
{
|
|
#Inhalte der Einstellungsdatei speichern
|
|
$EinstellungsInhalte = InhalteEinstellungsDateiHolen
|
|
|
|
#Auslesen und anzeigen der Werte fuer die ZielDateien
|
|
foreach ($EinstellungsZeile in $EinstellungsInhalte) {
|
|
$EinstellungsBestandteile = $EinstellungsZeile.Split("|")
|
|
if ($EinstellungsBestandteile[0] -eq "Datei") {
|
|
$ESListeEinstellungen.Rows.Add($($EinstellungsBestandteile[1]),$($EinstellungsBestandteile[2]),$($EinstellungsBestandteile[3]),$($EinstellungsBestandteile[4]))
|
|
}
|
|
}
|
|
|
|
#Auslesen und anzeigen des Werts fuer den StartPfad
|
|
$StartPfad = StartPfadHolen
|
|
$ESTextfeldStartPfad.Text = $StartPfad
|
|
|
|
#Auslesen und anzeigen des Werts fuer die RadioButtons
|
|
#In den RadioButtons ist festgelegt, ob das initial geoeffnete Verzeichnis bei der Auswahl des Zielverzeichnisses
|
|
# a) gleich dem Verzeichnis ist, in dem die .txt-Datei gespeichert ist
|
|
# b) gleich dem Verzeichnis ist, das initial bei Auswahl der .txt-Datei angzeigt wird
|
|
# c) ein unabhaenig davon festgelegtes Verzeichnis ist
|
|
# Unabhaengig von der Auswahl der RadioButtons kann natuerlich frei durch die Verzeichnisse navigiert werden
|
|
$RadioButton = RadioButtonHolen
|
|
switch ($RadioButton) {
|
|
EigenerPfad {
|
|
$ESRadioButtonEigenerPfad.Checked = $true
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeld3)
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeldZielPfad)
|
|
$TabSeiteEigenschaften.Controls.Add($ESZielPfadAendernButton)
|
|
$ZielPfad = ZielPfadHolen
|
|
$ESTextfeldZielPfad.Text = $ZielPfad
|
|
}
|
|
WieTXT {
|
|
$ESRadioButtonWieTXT.Checked = $true
|
|
}
|
|
WieZielDatei {
|
|
$ESRadioButtonWieZieldatei.Checked = $true
|
|
}
|
|
Default {
|
|
$ESRadioButtonWieZieldatei.Checked = $true
|
|
}
|
|
}
|
|
}
|
|
|
|
#Funktion, die einen Explorer oeffnet, bei der ein Verzeichnis ausgewaehlt wird, dieses in der Einstellungsdatei speichert und in der GUI im Tab der Einstellungen
|
|
#das neue Verzeichnis ausgibt. Zuvor wird das alte Verzeichnis geloescht.
|
|
#Welches Verzeichnis (i. d. R. StartPfad oder ZielPfad) geaendert wird, muss der Funktion uebergeben werden
|
|
Function VerzeichnisAendern ($SuchBereich)
|
|
{
|
|
#Inhalte der Einstellungsdatei einlesen und die Inhalte der Datei loeschen
|
|
$DateiInhalt = InhalteEinstellungsDateiHolen
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
Clear-Content $PfadEinstellungsDatei
|
|
|
|
#Wieder-Beschreiben der Datei und austauschen der in $SuchBereich uebergebenen Einstellung sowie oeffnen des Explorers, zur Auswahl des neuen Verzeichnisses
|
|
foreach ($DateiZeile in $DateiInhalt) {
|
|
$DateiBestandTeile = $DateiZeile.Split("|")
|
|
if ($DateiBestandTeile[0] -eq $SuchBereich) {
|
|
$Explorer = New-Object System.Windows.Forms.FolderBrowserDialog
|
|
$Explorer.SelectedPath = $DateiBestandTeile[1]
|
|
$Explorer.ShowDialog()
|
|
$Pfad = $Explorer.SelectedPath
|
|
$DateiZeile = $($DateiBestandTeile[0] + "|" + $Pfad)
|
|
}
|
|
Add-Content $PfadEinstellungsDatei $DateiZeile
|
|
}
|
|
|
|
#Anzeige der GUI im Tab Verzeichnisauswahl des Verzeichnisses, in dem die Dateien gespeichert werden, aktualisieren. Dies muss aktualisiert werden, da evtl. aufgrund
|
|
#der Einstellung der Radio-Buttons auch bei Aenderung des Verzeichnisses zur Wahl der .txt-Datei diese Ansicht aktualisiert werden muss
|
|
VERVorauswahlAnzeigeAktualisieren
|
|
|
|
#Je nach gewaehltem $SuchBereich muessen verschiedene teile des GUI aktualisiert werden
|
|
switch ($SuchBereich) {
|
|
StartPfad {
|
|
AnzeigeAktualisieren "txt" $Pfad
|
|
$ESTextfeldStartPfad.Text = $Pfad
|
|
}
|
|
ZielPfad {
|
|
$ESTextfeldZielPfad.Text = $Pfad
|
|
}
|
|
Default {}
|
|
}
|
|
}
|
|
|
|
#Funktion, die die aktuell gewaehlte Einstellung des RadioButtons in der Einstellungsdatei speichert
|
|
Function EinstellungenRadioButtonSpeichern () {
|
|
#Feststellen, welcher RadioButton aktiviert ist und die entsprechenden Teile der GUI aktualisieren
|
|
if ($ESRadioButtonEigenerPfad.Checked -eq $true) {
|
|
$Auswahl = "EigenerPfad"
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeld3)
|
|
$TabSeiteEigenschaften.Controls.Add($ESTextfeldZielPfad)
|
|
$TabSeiteEigenschaften.Controls.Add($ESZielPfadAendernButton)
|
|
$ZielPfad = ZielPfadHolen
|
|
$ESTextfeldZielPfad.Text = $ZielPfad
|
|
}
|
|
elseif ($ESRadioButtonWieTXT.Checked -eq $true) {
|
|
$Auswahl = "WieTXT"
|
|
$TabSeiteEigenschaften.Controls.Remove($ESTextfeld3)
|
|
$TabSeiteEigenschaften.Controls.Remove($ESTextfeldZielPfad)
|
|
$TabSeiteEigenschaften.Controls.Remove($ESZielPfadAendernButton)
|
|
}
|
|
else {
|
|
$Auswahl = "WieZielDatei"
|
|
$TabSeiteEigenschaften.Controls.Remove($ESTextfeld3)
|
|
$TabSeiteEigenschaften.Controls.Remove($ESTextfeldZielPfad)
|
|
$TabSeiteEigenschaften.Controls.Remove($ESZielPfadAendernButton)
|
|
}
|
|
#Inhalte und Pfad der Einstelungsdatei speichern
|
|
$DateiInhalt = InhalteEinstellungsDateiHolen
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
|
|
#Anzeige fuer Verzeichnisauswahl aktualisieren, Inhalte der Einstellungsdatei loeschen
|
|
VERVorauswahlAnzeigeAktualisieren
|
|
Clear-Content $PfadEinstellungsDatei
|
|
|
|
#Durch die Einstellungsinhalte iterieren, dabei nach Zeile fuer VerzeichnisAuswahl suchen, alle Inhalte und aktualisierten Wert fuer VerzeichnisWahl in die Datei schreiben
|
|
foreach ($DateiZeile in $DateiInhalt) {
|
|
$DateiBestandTeile = $DateiZeile.Split("|")
|
|
#Zeile fuer VerzeichnisWahl finden und Einstellung durch neue Auswahl ersetzen
|
|
if ($DateiBestandTeile[0] -eq "VerzeichnisWahl") {
|
|
$DateiZeile = $($DateiBestandTeile[0] + "|" + $Auswahl)
|
|
}
|
|
Add-Content $PfadEinstellungsDatei $DateiZeile
|
|
}
|
|
}
|
|
|
|
#Funktion, die die Tabelle der ZielDateien ausliest und deren Werte abspeichert
|
|
Function EinstellungenZielDateienSpeichern ()
|
|
{
|
|
#Auslesen der Tabelle mit den ZielDateien und daraus das Array $ZielDateien erstellen
|
|
for ($i = 0; $i -lt ($ESListeEinstellungen.RowCount-1); $i++) {
|
|
#Falls in keinem Feld ein Wert steht, wird die Zeile uebersprungen (=> eintrag geloescht)
|
|
if ($($($($ESListeEinstellungen.Rows[$i].Cells[0].Value).Length -ne 0) -or
|
|
$($($ESListeEinstellungen.Rows[$i].Cells[1].Value).Length -ne 0) -or
|
|
$($($ESListeEinstellungen.Rows[$i].Cells[2].Value).Length -ne 0) -or
|
|
$($($ESListeEinstellungen.Rows[$i].Cells[3].Value).Length -ne 0)
|
|
)) {
|
|
#Eintrag fuer $ZielDateien hinzufuegen
|
|
$ZielDateien += @([PSCustomObject]@{
|
|
PrefixEingang = $ESListeEinstellungen.Rows[$i].Cells[0].Value
|
|
PrefixAusgang = $ESListeEinstellungen.Rows[$i].Cells[1].Value
|
|
DateiName = $ESListeEinstellungen.Rows[$i].Cells[2].Value
|
|
WandlungsTyp = $ESListeEinstellungen.Rows[$i].Cells[3].Value
|
|
})
|
|
}
|
|
}
|
|
#Ueberpruefen der $ZielDateien
|
|
$ZielDateien = ZielDateienCheck $ZielDateien
|
|
|
|
#Holen der Einstellungsdatei
|
|
$PfadEinstellungsDatei = PfadEinstellungsDateiHolen
|
|
$AlteEinstellungsDatei = Get-Content $PfadEinstellungsDatei
|
|
$NeueEinstellungsDatei = @()
|
|
|
|
#Alte Ziel-Dateien loeschen
|
|
foreach ($Zeile in $AlteEinstellungsDatei) {
|
|
$Einstellung = $Zeile.Split("|")
|
|
if ($Einstellung[0] -ne "Datei") {
|
|
$NeueEinstellungsDatei += $Zeile
|
|
}
|
|
}
|
|
|
|
#Neue Ziel-Dateien hinzufuegen
|
|
foreach ($ZielDatei in $ZielDateien) {
|
|
$ZielDateiensatz = $("Datei|" + $ZielDatei.PrefixEingang + "|" + $ZielDatei.PrefixAusgang + "|" + $ZielDatei.DateiName + "|" + $ZielDatei.WandlungsTyp)
|
|
$NeueEinstellungsDatei += $ZielDateiensatz
|
|
}
|
|
|
|
#Inhalte der Einstellungsdatei loeschen und neu befuellen
|
|
Clear-Content $PfadEinstellungsDatei
|
|
foreach ($Zeile in $NeueEinstellungsdatei) {
|
|
Add-Content $PfadEinstellungsDatei $Zeile
|
|
}
|
|
|
|
# UngespeichterteAenderungen reseten! (?)
|
|
}
|
|
|
|
|
|
#--------------------------------------- Ende Funktionen fuer GUI -------------------------------
|
|
|
|
#Funktion, die aus in den Einstellungen festgelegtem Namen, ggf. dem urspruenglichen Dateinamen und dem Speicherort fuer die Datei den neuen Dateinamen erstellt
|
|
Function ExcelDateiNameErstellen ($EingestellterName, $PfadUrsprungsdatei, $PfadZielDatei)
|
|
{
|
|
#Feststellen des Namens der urspruenglichen Datei aus dem Gesamtpfad
|
|
$NameUrsprungsdatei = Split-Path $PfadUrsprungsdatei -Leaf
|
|
#Entfernen der Endung (".txt" --> 4 Zeichen)
|
|
$NameUrsprungsdateiLaenge = $NameUrsprungsdatei.Length
|
|
$NameUrsprungsdateiKurz = $NameUrsprungsdatei.Substring(0, $($NameUrsprungsdateiLaenge - 4))
|
|
|
|
#Zusammensetzen des neuen Namens aus dem uebergegenem Zielpfad, dem Zeichen "\", dem eingestellten Namen, wobei der Bereich "[Ursprungsdatei]" durch den Dateinamen
|
|
#der Datei ersetzt wird, die konvertiert wurde, und der Endung ".xlsx"
|
|
$GesamtPfadZielDatei = $PfadZielDatei + "\" + $EingestellterName.Replace("[Ursprungsdatei]",$NameUrsprungsdateiKurz) + ".xlsx"
|
|
|
|
return $GesamtPfadZielDatei
|
|
}
|
|
|
|
#Funktion, die aus einem gegebenem Pfad, Prefixen fuer Ein- und Ausgang und dem Pfad der Zieldatei dort eine Datei erstellt nach dem Format "Simpel"
|
|
#Bei Simpel gibt es keine spezielle Verarbeitung, die geaenderten Betriebsmittel und Kommentare werden einfach in die Excel-Datei eingetragen
|
|
Function ExcelDateiBeschreibenSimpel ($PfadUrsprungsdatei, $PrefixEingang, $PrefixAusgang, $ZielDatei)
|
|
{
|
|
#Deklarieren der Variablen/Arrays
|
|
$Eingaenge = @()
|
|
$ZuEingang = @("FDI", "B", "S", "E", "I", "DI", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BJ", "BK", "BL", "BM", "BN", "BP", "BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ", "FA", "FB", "FC", "FD", "FE", "FF", "FG", "FH", "FJ", "FK", "FL", "FM", "FN", "FP", "FQ", "FR", "FS", "FT", "FU", "FV", "FW", "FX", "FY", "FZ", "SA", "SB", "SC", "SD", "SE", "SF", "SG", "SH", "SJ", "SK", "SL", "SM", "SN", "SP", "SQ", "SR", "SS", "ST", "SU", "SV", "SW", "SX", "SY", "SZ")
|
|
$Ausgaenge = @()
|
|
$ZuAusgang = @("K", "O", "Q", "M", "A", "P", "DQ", "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CJ", "CK", "CL", "CM", "CN", "CP", "CQ", "CR", "CS", "CT", "CU", "CV", "CW", "CX", "CY", "CZ", "EA", "EB", "EC", "ED", "EE", "EF", "EG", "EH", "EJ", "EK", "EL", "EM", "EN", "EP", "EQ", "ER", "ES", "ET", "EU", "EV", "EW", "EX", "EY", "EZ", "GA", "GB", "GC", "GD", "GE", "GF", "GG", "GH", "GJ", "GK", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GV", "GW", "GX", "GY", "GZ", "HA", "HB", "HC", "HD", "HE", "HF", "HG", "HH", "HJ", "HK", "HL", "HM", "HN", "HP", "HQ", "HR", "HS", "HT", "HU", "HV", "HW", "HX", "HY", "HZ", "KA", "KB", "KC", "KD", "KE", "KF", "KG", "KH", "KJ", "KK", "KL", "KM", "KN", "KP", "KQ", "KR", "KS", "KT", "KU", "KV", "KW", "KX", "KY", "KZ", "MA", "MB", "MC", "MD", "ME", "MF", "MG", "MH", "MJ", "MK", "ML", "MM", "MN", "MP", "MQ", "MR", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "PA", "PB", "PC", "PD", "PE", "PF", "PG", "PH", "PJ", "PK", "PL", "PM", "PN", "PP", "PQ", "PR", "PS", "PT", "PU", "PV", "PW", "PX", "PY", "PZ", "QA", "QB", "QC", "QD", "QE", "QF", "QG", "QH", "QJ", "QK", "QL", "QM", "QN", "QP", "QQ", "QR", "QS", "QT", "QU", "QV", "QW", "QX", "QY", "QZ", "RA", "RB", "RC", "RD", "RE", "RF", "RG", "RH", "RJ", "RK", "RL", "RM", "RN", "RP", "RQ", "RR", "RS", "RT", "RU", "RV", "RW", "RX", "RY", "RZ", "TA", "TB", "TC", "TD", "TE", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TP", "TQ", "TR", "TS", "TT", "TU", "TV", "TW", "TX", "TY", "TZ")
|
|
$Fehler = @()
|
|
$Ursprungdatei = Get-Content $PfadUrsprungsdatei
|
|
|
|
AufgabenAktualisieren "Daten fuer Simpel konvertieren"
|
|
#Interieren durch die Eintraege
|
|
#$i steht fuer die Zeilennummer
|
|
$i = 0
|
|
foreach ($Eintrag in $Ursprungdatei)
|
|
{
|
|
#Teilen der Eintraege in $BMKZahl und $Kommentar
|
|
$Eintragszeile = $Eintrag.Split("'")
|
|
$BMKZahl = $Eintragszeile[1]
|
|
$BMKZahl = $BMKZahl.TrimStart("'")
|
|
$Kommentar = $Eintragszeile[3]
|
|
$Kommentar = $Kommentar.TrimEnd("'")
|
|
|
|
#Unterscheiden, ob es sich um einen Ein-, Ausgang oder Fehler handelt
|
|
if ($($($BMKZahl -replace "[\d]") -in $ZuEingang))
|
|
{
|
|
#Anpassen der $BMKZahl: Entfernen der Buchstaben, einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts und hinzufuegen des Prefix fuer Eingaenge
|
|
$BMKZahl = $BMKZahl -replace("[a-zA-Z]","")
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
$BMKZahl = $PrefixEingang + $BMKZahl
|
|
#Eintraegen in das Array fuer Eingaenge
|
|
$Eingaenge += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
Kommentar = $Kommentar
|
|
Zeile = $i
|
|
})
|
|
}
|
|
elseif ($($($BMKZahl -replace "[\d]") -in $ZuAusgang))
|
|
{
|
|
#Anpassen der $BMKZahl: Entfernen der Buchstaben, einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts und hinzufuegen des Prefix fuer Ausgaenge
|
|
$BMKZahl = $BMKZahl -replace("[a-zA-Z]","")
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
$BMKZahl = $PrefixAusgang + $BMKZahl
|
|
#Eintragen in das Array fuer Ausgaenge
|
|
$Ausgaenge += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
Kommentar = $Kommentar
|
|
Zeile = $i
|
|
})
|
|
}
|
|
else
|
|
{
|
|
#Anpassen der $BMKZahl: Einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts
|
|
$BMKZahlLaenge = $($BMKZahl.length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
#Eintragen in das Array fuer Fehler
|
|
$Fehler += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
Kommentar = $Kommentar
|
|
Zeile = $i
|
|
})
|
|
}
|
|
#Erhoehen des Zeilencounters
|
|
$i++
|
|
}
|
|
|
|
AufgabenAktualisieren "Daten fuer Simpel in Excel-Datei schreiben"
|
|
#Excel oeffnen und Datei erstellen
|
|
$Datei = New-Object -ComObject Excel.Application
|
|
$Mappe = $Datei.Workbooks.Add()
|
|
$Mappe.SaveAs($ZielDatei)
|
|
$Blatt = $Mappe.WorkSheets.item(1)
|
|
$Datei.Visible = $false
|
|
|
|
#Header erstellen
|
|
#(kein Header vorhanden)
|
|
|
|
#Schleife fuer Fehler
|
|
#$i ist der Zeilencounter. Die oberste Zeile in Excel ist Zeile 1
|
|
$i = 1
|
|
$Fehler = $Fehler | Sort-Object "Name"
|
|
foreach ($EinzelFehler in $Fehler) {
|
|
$Blatt.Cells.Item($i,1) = $EinzelFehler.Name
|
|
$Blatt.Cells.Item($i,2) = $EinzelFehler.Kommentar
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
}
|
|
|
|
#Schleife fuer Eingaenge
|
|
$Eingaenge = $Eingaenge | Sort-Object "Name"
|
|
foreach ($Eingang in $Eingaenge) {
|
|
$Blatt.Cells.Item($i,1) = $Eingang.Name
|
|
$Blatt.Cells.Item($i,2) = $Eingang.Kommentar
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
}
|
|
|
|
#Schleife fuer Ausgaenge
|
|
$Ausgaenge = $Ausgaenge | Sort-Object "Name"
|
|
foreach ($Ausgang in $Ausgaenge) {
|
|
$Blatt.Cells.Item($i,1) = $Ausgang.Name
|
|
$Blatt.Cells.Item($i,2) = $Ausgang.Kommentar
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
}
|
|
|
|
#Speichern der Datei und schließen von Excel
|
|
$Mappe.Save()
|
|
$Datei.Quit()
|
|
|
|
#Ermitteln von Duplikaten
|
|
$GleicheEingaenge = GleicheFinden $Eingaenge
|
|
$GleicheAusgaenge = GleicheFinden $Ausgaenge
|
|
|
|
#Dieses beschreiben ist noetig, da sonst in der Rueckgabe Fehler entstehen koennen, wenn entweder $GleicheEingaenge oder $GleicheAusgaenge leer sind (aber nicht beide)
|
|
if ( $($Fehler.Length -eq 0))
|
|
{
|
|
$Fehler += @([PSCustomObject]@{
|
|
Name = "Keine"
|
|
Zeile = "Alle"
|
|
})
|
|
}
|
|
|
|
return $GleicheEingaenge, $GleicheAusgaenge, $Fehler
|
|
}
|
|
|
|
#Funktion, die aus einem gegebenem Pfad, Prefixen fuer Ein- und Ausgang und dem Pfad der Zieldatei dort eine Datei erstellt nach dem Format "TIA"
|
|
#Bei TIA ist ein spezielle Header notwendig. Außerdem wird ein zweites Tabellenblatt erstellt, bei dem in etwas angepasster Form und mit speziellem Zaehler die Ein- und Ausgaenge
|
|
#aufgelistet sind.
|
|
#Das Format fuer TIA wurde nach Vorgaben von Christian Forkl (SPS-Programmierer) erstellt
|
|
Function ExcelDateiBeschreibenTIA ($PfadUrsprungsdatei, $PrefixEingang, $PrefixAusgang, $ZielDatei)
|
|
{
|
|
$Eingaenge = @()
|
|
$ZuEingang = @("FDI", "B", "S", "E", "I", "DI", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BJ", "BK", "BL", "BM", "BN", "BP", "BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ", "FA", "FB", "FC", "FD", "FE", "FF", "FG", "FH", "FJ", "FK", "FL", "FM", "FN", "FP", "FQ", "FR", "FS", "FT", "FU", "FV", "FW", "FX", "FY", "FZ", "SA", "SB", "SC", "SD", "SE", "SF", "SG", "SH", "SJ", "SK", "SL", "SM", "SN", "SP", "SQ", "SR", "SS", "ST", "SU", "SV", "SW", "SX", "SY", "SZ")
|
|
$Ausgaenge = @()
|
|
$ZuAusgang = @("K", "O", "Q", "M", "A", "P", "DQ", "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CJ", "CK", "CL", "CM", "CN", "CP", "CQ", "CR", "CS", "CT", "CU", "CV", "CW", "CX", "CY", "CZ", "EA", "EB", "EC", "ED", "EE", "EF", "EG", "EH", "EJ", "EK", "EL", "EM", "EN", "EP", "EQ", "ER", "ES", "ET", "EU", "EV", "EW", "EX", "EY", "EZ", "GA", "GB", "GC", "GD", "GE", "GF", "GG", "GH", "GJ", "GK", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GV", "GW", "GX", "GY", "GZ", "HA", "HB", "HC", "HD", "HE", "HF", "HG", "HH", "HJ", "HK", "HL", "HM", "HN", "HP", "HQ", "HR", "HS", "HT", "HU", "HV", "HW", "HX", "HY", "HZ", "KA", "KB", "KC", "KD", "KE", "KF", "KG", "KH", "KJ", "KK", "KL", "KM", "KN", "KP", "KQ", "KR", "KS", "KT", "KU", "KV", "KW", "KX", "KY", "KZ", "MA", "MB", "MC", "MD", "ME", "MF", "MG", "MH", "MJ", "MK", "ML", "MM", "MN", "MP", "MQ", "MR", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "PA", "PB", "PC", "PD", "PE", "PF", "PG", "PH", "PJ", "PK", "PL", "PM", "PN", "PP", "PQ", "PR", "PS", "PT", "PU", "PV", "PW", "PX", "PY", "PZ", "QA", "QB", "QC", "QD", "QE", "QF", "QG", "QH", "QJ", "QK", "QL", "QM", "QN", "QP", "QQ", "QR", "QS", "QT", "QU", "QV", "QW", "QX", "QY", "QZ", "RA", "RB", "RC", "RD", "RE", "RF", "RG", "RH", "RJ", "RK", "RL", "RM", "RN", "RP", "RQ", "RR", "RS", "RT", "RU", "RV", "RW", "RX", "RY", "RZ", "TA", "TB", "TC", "TD", "TE", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TP", "TQ", "TR", "TS", "TT", "TU", "TV", "TW", "TX", "TY", "TZ")
|
|
$Fehler = @()
|
|
|
|
$Ursprungdatei = Get-Content $PfadUrsprungsdatei
|
|
|
|
AufgabenAktualisieren "Daten fuer TIA konvertieren"
|
|
#Interieren durch die Eintraege
|
|
#$i steht fuer die Zeilennummer
|
|
$i = 0
|
|
foreach ($Eintrag in $Ursprungdatei)
|
|
{
|
|
#Teilen der Eintraege in $BMKZahl, $BMKZahlOriginal und $Kommentar
|
|
$Eintragszeile = $Eintrag.Split("'")
|
|
$BMKZahl = $Eintragszeile[1]
|
|
$BMKZahl = $BMKZahl.TrimStart("'")
|
|
$BMKZahlOriginal = $BMKZahl
|
|
$Kommentar = $Eintragszeile[3]
|
|
$Kommentar = $Kommentar.TrimEnd("'")
|
|
#Unterscheiden, ob es sich um einen Ein-, Ausgang oder Fehler handelt
|
|
if ($($($BMKZahl -replace "[\d]") -in $ZuEingang))
|
|
{
|
|
#Anpassen der $BMKZahl: Entfernen der Buchstaben, einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts und hinzufuegen des Prefix fuer Eingaenge und Konstanten
|
|
$BMKZahl = $BMKZahl -replace("[a-zA-Z]","")
|
|
$BMKNurZahl = $BMKZahl
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
$BMKZahl = $PrefixEingang + $BMKZahl
|
|
$BMKZahlConstant = "cIn" + $BMKZahlOriginal
|
|
#Eintraegen in das Array fuer Eingaenge
|
|
$Eingaenge += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
NameOriginal = $BMKZahlOriginal
|
|
NameConstant = $BMKZahlConstant
|
|
Kommentar = $Kommentar
|
|
Zahl = $BMKNurZahl
|
|
Zeile = $i
|
|
})
|
|
}
|
|
elseif ($($($BMKZahl -replace "[\d]") -in $ZuAusgang))
|
|
{
|
|
#Anpassen der $BMKZahl: Entfernen der Buchstaben, einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts und hinzufuegen des Prefix fuer Ausgaenge
|
|
$BMKZahl = $BMKZahl -replace("[a-zA-Z]","")
|
|
$BMKNurZahl = $BMKZahl
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
$BMKZahl = $PrefixAusgang + $BMKZahl
|
|
$BMKZahlConstant = "cOut" + $BMKZahlOriginal
|
|
#Eintragen in das Array fuer Ausgaenge
|
|
$Ausgaenge += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
NameOriginal = $BMKZahlOriginal
|
|
NameConstant = $BMKZahlConstant
|
|
Kommentar = $Kommentar
|
|
Zahl = $BMKNurZahl
|
|
Zeile = $i
|
|
})
|
|
}
|
|
else
|
|
{
|
|
#Anpassen der $BMKZahl: Einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts
|
|
$BMKNurZahl = $i
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
$BMKZahlConstant = "cErr" + $BMKZahlOriginal
|
|
#Eintragen in das Array fuer Fehler
|
|
$Fehler += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
NameOriginal = $BMKZahlOriginal
|
|
NameConstant = $BMKZahlConstant
|
|
Zahl = $BMKNurZahl
|
|
Zeile = $i
|
|
})
|
|
}
|
|
#Erhoehen des Zeilencounters
|
|
$i++
|
|
}
|
|
|
|
AufgabenAktualisieren "Daten fuer TIA in Excel-Datei schreiben"
|
|
#Excel oeffnen und Datei erstellen, Arbeitmappen erstellen und umbennenen
|
|
$Datei = New-Object -ComObject Excel.Application
|
|
$Mappe = $Datei.Workbooks.Add()
|
|
$Mappe.SaveAs($ZielDatei)
|
|
$BlattConstants = $Mappe.WorkSheets.item(1)
|
|
$BlattConstants.Name = "Constants"
|
|
$BlattPLCTags = $Mappe.WorkSheets.Add()
|
|
$BlattPLCTags.Name = "PLC Tags"
|
|
$Datei.Visible = $false
|
|
|
|
#Header fuer Blatt "Constants" erstellen
|
|
$BlattConstants.Cells.Item(1,1) = "Name"
|
|
$BlattConstants.Cells.Item(1,2) = "Path"
|
|
$BlattConstants.Cells.Item(1,3) = "Data Type"
|
|
$BlattConstants.Cells.Item(1,4) = "Value"
|
|
$BlattConstants.Cells.Item(1,5) = "Comment"
|
|
|
|
#Header fuer Blatt "PLC Tags" erstellen
|
|
$BlattPLCTags.Cells.Item(1,1) = "Name"
|
|
$BlattPLCTags.Cells.Item(1,2) = "Path"
|
|
$BlattPLCTags.Cells.Item(1,3) = "Data Type"
|
|
$BlattPLCTags.Cells.Item(1,4) = "Logical Address"
|
|
$BlattPLCTags.Cells.Item(1,5) = "Comment"
|
|
$BlattPLCTags.Cells.Item(1,6) = "Hmi Visible"
|
|
$BlattPLCTags.Cells.Item(1,7) = "Hmi Accessible"
|
|
$BlattPLCTags.Cells.Item(1,8) = "Hmi Writeable"
|
|
$BlattPLCTags.Cells.Item(1,9) = "Typeobject ID"
|
|
$BlattPLCTags.Cells.Item(1,10) = "Version ID"
|
|
|
|
#Schleife fuer Fehler
|
|
#$i ist der Zeilencounter. Die oberste Zeile in Excel ist Zeile 1. In Zeile 1 ist der Header, ab Zeile 2 die Inhalte
|
|
#$j ist fuer einen Counter der Eingaenge im Blatt "Constants"
|
|
$i = 2
|
|
$j = 0
|
|
$Fehler = $Fehler | Sort-Object "Zahl"
|
|
foreach ($EinzelFehler in $Fehler) {
|
|
#In Blatt "Constants" schreiben
|
|
$BlattConstants.Cells.Item($i,1) = $EinzelFehler.NameConstant#Name
|
|
$BlattConstants.Cells.Item($i,2) = "Import" #Path
|
|
$BlattConstants.Cells.Item($i,3) = "Int" #Data Type
|
|
$BlattConstants.Cells.Item($i,4) = $j #Value
|
|
# $BlattConstants.Cells.Item($i,5) = #Comment
|
|
|
|
#In Blatt "PLC Tags" schreiben
|
|
$BlattPLCTags.Cells.Item($i,1) = $EinzelFehler.NameOriginal#Name
|
|
$BlattPLCTags.Cells.Item($i,2) = "Import" #Path
|
|
$BlattPLCTags.Cells.Item($i,3) = "Bool" #Data Type
|
|
$BlattPLCTags.Cells.Item($i,4) = $EinzelFehler.Name #Logical Address
|
|
$BlattPLCTags.Cells.Item($i,5) = $EinzelFehler.Kommentar #Comment
|
|
$BlattPLCTags.Cells.Item($i,6) = "'True" #Hmi Visible
|
|
$BlattPLCTags.Cells.Item($i,7) = "'True" #Hmi Accessible
|
|
$BlattPLCTags.Cells.Item($i,8) = "'True" #Hmi Writeable
|
|
# $BlattPLCTags.Cells.Item($i,9) = #Typeobject ID
|
|
# $BlattPLCTags.Cells.Item($i,10) = #Version ID
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
$j++
|
|
}
|
|
|
|
#Schleife fuer Eingaenge
|
|
#Zuruecksetzen von $j, da dies jeweils bei Ein- und Ausgaenge bei 0 beginnen muss
|
|
$j = 0
|
|
$Eingaenge = $Eingaenge | Sort-Object "Zahl"
|
|
foreach ($Eingang in $Eingaenge) {
|
|
#In Blatt "Constants" schreiben
|
|
$BlattConstants.Cells.Item($i,1) = $Eingang.NameConstant #Name
|
|
$BlattConstants.Cells.Item($i,2) = "Import" #Path
|
|
$BlattConstants.Cells.Item($i,3) = "Int" #Data Type
|
|
$BlattConstants.Cells.Item($i,4) = $j #Value
|
|
# $BlattConstants.Cells.Item($i,5) = #Comment
|
|
|
|
#In Blatt "PLC Tags" schreiben
|
|
$BlattPLCTags.Cells.Item($i,1) = $Eingang.NameOriginal #Name
|
|
$BlattPLCTags.Cells.Item($i,2) = "Import" #Path
|
|
$BlattPLCTags.Cells.Item($i,3) = "Bool" #Data Type
|
|
$BlattPLCTags.Cells.Item($i,4) = $Eingang.Name #Logical Address
|
|
$BlattPLCTags.Cells.Item($i,5) = $Eingang.Kommentar #Comment
|
|
$BlattPLCTags.Cells.Item($i,6) = "'True" #Hmi Visible
|
|
$BlattPLCTags.Cells.Item($i,7) = "'True" #Hmi Accessible
|
|
$BlattPLCTags.Cells.Item($i,8) = "'True" #Hmi Writeable
|
|
# $BlattPLCTags.Cells.Item($i,9) = #Typeobject ID
|
|
# $BlattPLCTags.Cells.Item($i,10) = #Version ID
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
$j++
|
|
}
|
|
|
|
#Schleife fuer Ausgaenge
|
|
#Zuruecksetzen von $j, da dies jeweils bei Ein- und Ausgaenge bei 0 beginnen muss
|
|
$j = 0
|
|
$Ausgaenge = $Ausgaenge | Sort-Object "Zahl"
|
|
foreach ($Ausgang in $Ausgaenge) {
|
|
#In Blatt "Constants" schreiben
|
|
$BlattConstants.Cells.Item($i,1) = $Ausgang.NameConstant #Name
|
|
$BlattConstants.Cells.Item($i,2) = "Import" #Path
|
|
$BlattConstants.Cells.Item($i,3) = "Int" #Data Type
|
|
$BlattConstants.Cells.Item($i,4) = $j #Value
|
|
# $BlattConstants.Cells.Item($i,5) = #Comment
|
|
|
|
#In Blatt "PLC Tags" schreiben
|
|
$BlattPLCTags.Cells.Item($i,1) = $Ausgang.NameOriginal #Name
|
|
$BlattPLCTags.Cells.Item($i,2) = "Import" #Path
|
|
$BlattPLCTags.Cells.Item($i,3) = "Bool" #Data Type
|
|
$BlattPLCTags.Cells.Item($i,4) = $Ausgang.Name #Logical Address
|
|
$BlattPLCTags.Cells.Item($i,5) = $Ausgang.Kommentar #Comment
|
|
$BlattPLCTags.Cells.Item($i,6) = "'True" #Hmi Visible
|
|
$BlattPLCTags.Cells.Item($i,7) = "'True" #Hmi Accessible
|
|
$BlattPLCTags.Cells.Item($i,8) = "'True" #Hmi Writeable
|
|
# $BlattPLCTags.Cells.Item($i,9) = #Typeobject ID
|
|
# $BlattPLCTags.Cells.Item($i,10) = #Version ID
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
$j++
|
|
}
|
|
|
|
#Speichern der Datei und schließen von Excel
|
|
$Mappe.Save()
|
|
$Datei.Quit()
|
|
|
|
#Ermitteln von Duplikaten
|
|
$GleicheEingaenge = GleicheFinden $Eingaenge
|
|
$GleicheAusgaenge = GleicheFinden $Ausgaenge
|
|
|
|
#Dieses beschreiben ist noetig, da sonst in der Rueckgabe Fehler entstehen koennen, wenn entweder $GleicheEingaenge oder $GleicheAusgaenge leer sind (aber nicht beide)
|
|
if ( $($Fehler.Length -eq 0))
|
|
{
|
|
$Fehler += @([PSCustomObject]@{
|
|
Name = "Keine"
|
|
Zeile = "Alle"
|
|
})
|
|
}
|
|
|
|
return $GleicheEingaenge, $GleicheAusgaenge, $Fehler
|
|
}
|
|
|
|
#Funktion, die aus einem gegebenem Pfad, Prefixen fuer Ein- und Ausgang und dem Pfad der Zieldatei dort eine Datei erstellt nach dem Format "WSCAD"
|
|
#Bei WSCAD ist ein spezieller Header notwendig. Außerdem werden die Ein- und Ausgaenge ergaenzt. Falls im Bereich mit der Endung 0-7 min. ein Ein- oder Ausgang existiert,
|
|
#werden alle weiteren Ein- und Ausgaenge in diesem Bereich ergänzt
|
|
Function ExcelDateiBeschreibenWSCAD ($PfadUrsprungsdatei, $PrefixEingang, $PrefixAusgang, $ZielDatei)
|
|
{
|
|
$Eingaenge = @()
|
|
$ZuEingang = @("FDI", "B", "S", "E", "I", "DI", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BJ", "BK", "BL", "BM", "BN", "BP", "BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ", "FA", "FB", "FC", "FD", "FE", "FF", "FG", "FH", "FJ", "FK", "FL", "FM", "FN", "FP", "FQ", "FR", "FS", "FT", "FU", "FV", "FW", "FX", "FY", "FZ", "SA", "SB", "SC", "SD", "SE", "SF", "SG", "SH", "SJ", "SK", "SL", "SM", "SN", "SP", "SQ", "SR", "SS", "ST", "SU", "SV", "SW", "SX", "SY", "SZ")
|
|
$Ausgaenge = @()
|
|
$ZuAusgang = @("K", "KF", "O", "Q", "M", "A", "P", "DQ", "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CJ", "CK", "CL", "CM", "CN", "CP", "CQ", "CR", "CS", "CT", "CU", "CV", "CW", "CX", "CY", "CZ", "EA", "EB", "EC", "ED", "EE", "EF", "EG", "EH", "EJ", "EK", "EL", "EM", "EN", "EP", "EQ", "ER", "ES", "ET", "EU", "EV", "EW", "EX", "EY", "EZ", "GA", "GB", "GC", "GD", "GE", "GF", "GG", "GH", "GJ", "GK", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GV", "GW", "GX", "GY", "GZ", "HA", "HB", "HC", "HD", "HE", "HF", "HG", "HH", "HJ", "HK", "HL", "HM", "HN", "HP", "HQ", "HR", "HS", "HT", "HU", "HV", "HW", "HX", "HY", "HZ", "KA", "KB", "KC", "KD", "KE", "KG", "KH", "KJ", "KK", "KL", "KM", "KN", "KP", "KQ", "KR", "KS", "KT", "KU", "KV", "KW", "KX", "KY", "KZ", "MA", "MB", "MC", "MD", "ME", "MF", "MG", "MH", "MJ", "MK", "ML", "MM", "MN", "MP", "MQ", "MR", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "PA", "PB", "PC", "PD", "PE", "PF", "PG", "PH", "PJ", "PK", "PL", "PM", "PN", "PP", "PQ", "PR", "PS", "PT", "PU", "PV", "PW", "PX", "PY", "PZ", "QA", "QB", "QC", "QD", "QE", "QF", "QG", "QH", "QJ", "QK", "QL", "QM", "QN", "QP", "QQ", "QR", "QS", "QT", "QU", "QV", "QW", "QX", "QY", "QZ", "RA", "RB", "RC", "RD", "RE", "RF", "RG", "RH", "RJ", "RK", "RL", "RM", "RN", "RP", "RQ", "RR", "RS", "RT", "RU", "RV", "RW", "RX", "RY", "RZ", "TA", "TB", "TC", "TD", "TE", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TP", "TQ", "TR", "TS", "TT", "TU", "TV", "TW", "TX", "TY", "TZ")
|
|
$Fehler = @()
|
|
|
|
$Ursprungsdatei = Get-Content $PfadUrsprungsdatei
|
|
|
|
AufgabenAktualisieren "Daten fuer WSCAD konvertieren"
|
|
#Interieren durch die Eintraege
|
|
#$i steht fuer die Zeilennummer
|
|
$i = 0
|
|
foreach ($Eintrag in $Ursprungsdatei) {
|
|
#Teilen der Eintraege in $BMKZahl und $Kommentar
|
|
$Eintragszeile = $Eintrag.Split("'")
|
|
$BMKZahl = $Eintragszeile[1]
|
|
$BMKZahl = $BMKZahl.TrimStart("'")
|
|
$Kommentar = $Eintragszeile[3]
|
|
$Kommentar = $Kommentar.TrimEnd("'")
|
|
#Unterscheiden, ob es sich um einen Ein-, Ausgang oder Fehler handelt
|
|
if ($($($BMKZahl -replace "[\d]") -in $ZuEingang))
|
|
{
|
|
#Anpassen der $BMKZahl: Entfernen der Buchstaben, einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts und hinzufuegen des Prefix fuer Eingaenge
|
|
$BMKZahl = $BMKZahl -replace("[a-zA-Z]","")
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
|
|
#Bis zu zwei Voranstehende Nullen entfernen
|
|
if ($BMKZahl.Length -ge 4 -and $BMKZahl.Substring(0,1) -eq "0") {
|
|
$BMKZahl = $BMKZahl.Substring(1)
|
|
if ($BMKZahl.Length -ge 4 -and $BMKZahl.Substring(0,1) -eq "0") {
|
|
$BMKZahl = $BMKZahl.Substring(1)
|
|
}
|
|
}
|
|
$BMKZahl = $PrefixEingang + $BMKZahl
|
|
#Eintraegen in das Array fuer Eingaenge
|
|
$Eingaenge += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
Kommentar = $Kommentar
|
|
Zeile = $i
|
|
})
|
|
}
|
|
elseif ($($($BMKZahl -replace "[\d]") -in $ZuAusgang))
|
|
{
|
|
#Anpassen der $BMKZahl: Entfernen der Buchstaben, einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts und hinzufuegen des Prefix fuer Ausgaenge
|
|
$BMKZahl = $BMKZahl -replace("[a-zA-Z]","")
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
|
|
#Bis zu zwei Voranstehende Nullen entfernen
|
|
if ($BMKZahl.Length -ge 3 -and $BMKZahl.Substring(0,1) -eq "0") {
|
|
$BMKZahl = $BMKZahl.Substring(1)
|
|
if ($BMKZahl.Length -ge 3 -and $BMKZahl.Substring(0,1) -eq "0") {
|
|
$BMKZahl = $BMKZahl.Substring(1)
|
|
}
|
|
}
|
|
$BMKZahl = $PrefixAusgang + $BMKZahl
|
|
#Eintragen in das Array fuer Ausgaenge
|
|
$Ausgaenge += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
Kommentar = $Kommentar
|
|
Zeile = $i
|
|
})
|
|
}
|
|
else
|
|
{
|
|
#Anpassen der $BMKZahl: Einfuegen eines Punkts (".") zwischen letzter und vorletzer Stelle von Rechts
|
|
$BMKZahlLaenge = $($BMKZahl.Length - 1)
|
|
$BMKZahl = $BMKZahl.Substring(0,$BMKZahlLaenge) + "." + $BMKZahl.Substring($BMKZahlLaenge)
|
|
#Eintragen in das Array fuer Fehler
|
|
$Fehler += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
Kommentar = $Kommentar
|
|
Zeile = $i
|
|
})
|
|
}
|
|
#Erhoehen des Zeilencounters
|
|
$i++
|
|
}
|
|
|
|
#Ergaenzen der Ein- und Ausgaenge. Falls an der SPS (physikalisch) min. einer der 8 Anschluesse (0-7) genutzt wird, sind zwangsweise die anderen auch vorhanden.
|
|
#Deswegen werden diese hier ohne Kommentar hinzugefuegt.
|
|
AufgabenAktualisieren "Anschluesse fuer Eingaenge ergaenzen"
|
|
$Eingaenge = AnschluesseErgaenzen $Eingaenge
|
|
AufgabenAktualisieren "Anschluesse fuer Ausgaenge ergaenzen"
|
|
$Ausgaenge = AnschluesseErgaenzen $Ausgaenge
|
|
|
|
AufgabenAktualisieren "Daten fuer WSCAD in Excel-Datei schreiben"
|
|
#Excel oeffnen und Datei erstellen
|
|
$Datei = New-Object -ComObject Excel.Application
|
|
$Mappe = $Datei.Workbooks.Add()
|
|
$Mappe.SaveAs($ZielDatei)
|
|
$Blatt = $Mappe.WorkSheets.item(1)
|
|
$Datei.Visible = $false
|
|
|
|
#Header erstellen
|
|
$Blatt.Cells.Item(1,1) = "Anschluss"
|
|
$Blatt.Cells.Item(1,2) = "Kommentar"
|
|
$Blatt.Cells.Item(1,3) = "Symboltext"
|
|
$Blatt.Cells.Item(1,4) = "Bezug"
|
|
$Blatt.Cells.Item(1,5) = "Sondertext 1"
|
|
$Blatt.Cells.Item(1,6) = "Sondertext 2"
|
|
$Blatt.Cells.Item(1,7) = "Sondertext 3"
|
|
$Blatt.Cells.Item(1,8) = "Sondertext 4"
|
|
$Blatt.Cells.Item(1,9) = "Sondertext 5"
|
|
$Blatt.Cells.Item(1,10) = "Sondertext 6"
|
|
$Blatt.Cells.Item(1,11) = "Sondertext 7"
|
|
$Blatt.Cells.Item(1,12) = "Sondertext 8"
|
|
|
|
#Schleife fuer Fehler
|
|
#$i ist der Zeilencounter. Die oberste Zeile in Excel ist Zeile 1. Dort ist der Header. Ab Zeile 2 kommen die Inhalte.
|
|
$i = 2
|
|
$Fehler = $Fehler | Sort-Object "Name"
|
|
foreach ($EinzelFehler in $Fehler) {
|
|
#In Blatt schreiben
|
|
$Blatt.Cells.Item($i,1) = $EinzelFehler.Name #Anschluss
|
|
$Blatt.Cells.Item($i,2) = $EinzelFehler.Kommentar #Kommentar
|
|
# $Blatt.Cells.Item($i,3) = "" #Symboltext
|
|
# $Blatt.Cells.Item($i,4) = "" #Bezug
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
}
|
|
|
|
#Schleife fuer Eingaenge
|
|
$Eingaenge = $Eingaenge | Sort-Object "Name"
|
|
foreach ($Eingang in $Eingaenge) {
|
|
#In Blatt schreiben
|
|
$Blatt.Cells.Item($i,1) = $Eingang.Name #Anschluss
|
|
$Blatt.Cells.Item($i,2) = $Eingang.Kommentar #Kommentar
|
|
# $Blatt.Cells.Item($i,3) = "" #Symboltext
|
|
# $Blatt.Cells.Item($i,4) = "" #Bezug
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
}
|
|
|
|
#Schleife fuer Ausgaenge
|
|
$Ausgaenge = $Ausgaenge | Sort-Object "Name"
|
|
foreach ($Ausgang in $Ausgaenge) {
|
|
#In Blatt schreiben
|
|
$Blatt.Cells.Item($i,1) = $Ausgang.Name #Anschluss
|
|
$Blatt.Cells.Item($i,2) = $Ausgang.Kommentar #Kommentar
|
|
# $Blatt.Cells.Item($i,3) = "" #Symboltext
|
|
# $Blatt.Cells.Item($i,4) = "" #Bezug
|
|
|
|
DateiBeschreibenAktualisieren
|
|
$i++
|
|
}
|
|
|
|
#Speichern der Datei und schließen von Excel
|
|
$Mappe.Save()
|
|
$Datei.Quit()
|
|
|
|
#Ermitteln von Duplikaten
|
|
$GleicheEingaenge = GleicheFinden $Eingaenge
|
|
$GleicheAusgaenge = GleicheFinden $Ausgaenge
|
|
|
|
#Dieses beschreiben ist noetig, da sonst in der Rueckgabe Fehler entstehen koennen, wenn entweder $GleicheEingaenge oder $GleicheAusgaenge leer sind (aber nicht beide)
|
|
if ( $($Fehler.Length -eq 0))
|
|
{
|
|
$Fehler += @([PSCustomObject]@{
|
|
Name = "Keine"
|
|
Zeile = "Alle"
|
|
})
|
|
}
|
|
|
|
return $GleicheEingaenge, $GleicheAusgaenge, $Fehler
|
|
}
|
|
|
|
#Funktion, die ein Array erhaelt und ueberprueft, ob ein oder mehrere Eintraege gleich sind. Die gleiche Eintraege werden zurueckgegeben.
|
|
Function GleicheFinden ($ZuUeberpruefen)
|
|
{
|
|
$ZuUeberpruefen = $ZuUeberpruefen | Sort-Object "Name"
|
|
$Gleiche = @()
|
|
#Schleife zum iterieren durch die Eintraege
|
|
for ($i = 0; $i -lt $($ZuUeberpruefen.Count - 1); $i++)
|
|
{
|
|
#Boolean $IstGleich gibt an, ob der aktuelle und der folgende Eintrag gleich sind.
|
|
$IstGleich = $($ZuUeberpruefen[$i].Name -eq $ZuUeberpruefen[$($i+1)].Name)
|
|
if ($IstGleich)
|
|
{
|
|
#Eintrag hinzufuegen, falls es den Eintrag nicht schon gibt
|
|
if (-not $($Gleiche[-1].Zeile -eq $ZuUeberpruefen[$i].Zeile))
|
|
{
|
|
$Gleiche += $ZuUeberpruefen[$i]
|
|
}
|
|
$Gleiche += $ZuUeberpruefen[$($i+1)]
|
|
}
|
|
}
|
|
|
|
#Falls es keine Duplikate gibt, gibt es fuer keine Namen in allen Zeilen Duplikate
|
|
#Die Werte werden hinzugefuegt, um spaetere Probleme beim Eintragen der Wert in das GUI verhindert werden
|
|
if ( $($Gleiche.Length -eq 0))
|
|
{
|
|
$Gleiche += @([PSCustomObject]@{
|
|
Name = "Keine"
|
|
Zeile = "Alle"
|
|
})
|
|
}
|
|
|
|
return $Gleiche
|
|
}
|
|
|
|
#Funktion, die eine Liste von Anschluessen erhaelt und diese ergaenzt. Falls min. einer der Anschluesse von 0-7 vorhanden ist, werden alle anderen, noch nicht vorhandenen, hinzugefuegt
|
|
Function AnschluesseErgaenzen ($Anschluesse)
|
|
{
|
|
$Anschluesse = $Anschluesse | Sort-Object "Name"
|
|
|
|
#Schleife zum iterieren durch die Anschluesse
|
|
foreach ($Anschluss in $Anschluesse) {
|
|
#Ermitteln der Baugruppe des aktuellen Anschlusses. Die Baugruppe ist die zweite Stelle von Rechts.
|
|
$AnschlussBauteil = $Anschluss.Name.Substring(0,$Anschluss.Name.Length - 2)
|
|
#Festlegen der Anschluesse, die vorhanden sein sollen
|
|
$SollAnschluesse = @(0,1,2,3,4,5,6,7)
|
|
#Schleife zum ueberpruefen, ob in der Baugruppe des aktuellen Anschlusses weitere Anschluesse vorhanden sind
|
|
foreach ($SubAnschluss in $Anschluesse) {
|
|
#Ermitteln der Baugruppe des aktuellen Sub-Anschlusses
|
|
$SubAnschlussBauteil = $SubAnschluss.Name.Substring(0,$SubAnschluss.Name.Length - 2)
|
|
#Wenn das Bauteil von Anschluss und Sub-Anschluss gleich ist, muss der Anschluss in der Liste der $SollAnschluesse gestrichen werden
|
|
if ($SubAnschlussBauteil -eq $AnschlussBauteil) {
|
|
#Den zu streichenden Anschluss ermitteln
|
|
$SubAnschlussLetzteStelle = $($SubAnschluss.Name).Substring($SubAnschluss.Name.Length - 1,1)
|
|
#Den zu streichenden Anschluss aus der Liste entfernen
|
|
$SollAnschluesse = $SollAnschluesse | Where-Object {$_ -ne $SubAnschlussLetzteStelle}
|
|
}
|
|
}
|
|
#Ergaenzen der fehlenden Anschluesse
|
|
foreach ($FehlenderAnschluss in $SollAnschluesse) {
|
|
#Weil durch die zusaetzlichen Eintraege auch die Zahl der Gesamteintraege steigt, wird die Zahl der $GesamtEintraege korrigiert
|
|
[System.Double] $GesamtEintraege = $FATextfeldGesamtEintraege.Text
|
|
$GesamtEintraege++
|
|
$FATextfeldGesamtEintraege.Text = $GesamtEintraege
|
|
|
|
#Der Name des zu ergaenzenden Anschlusses ist, bis auf die letzte Stelle, gleich dem des aktuellen Anschlusses
|
|
$Name = $Anschluss.Name
|
|
#Tausche die letzte Stelle durch den Wert von $FehlenderAnschluss aus
|
|
$BMKZahl = $($($Name.Substring(0,$Name.Length - 1)) + $FehlenderAnschluss)
|
|
#Den ergaenzten Anschluss in die Liste aller Anschluesse ergaenzen
|
|
$Anschluesse += @([PSCustomObject]@{
|
|
Name = $BMKZahl
|
|
Kommentar = ""
|
|
#Zeile = "" # Wird nich gebraucht, da hier keine Duplikate auftreten koennen. Ausserdem gibt es ohnehin keine zugehoerige Zeile in der UrsprungsDatei
|
|
})
|
|
}
|
|
}
|
|
$Anschluesse = $Anschluesse | Sort-Object "Name"
|
|
return $Anschluesse
|
|
}
|
|
|
|
Main |