private void DatenAuslesen(tabMaschine Maschine, string DateiName)
{
int zaehler = 0;
string msg = "";
_Ergebnisse.Clear();
var lZeilen = StringListenLaden(DateiName);
if (lZeilen != null)
{
foreach (var zeile in lZeilen)
{
zaehler++;
var felder = zeile.Split(new char[] { ';' }, StringSplitOptions.None);
var erg = new ErgebnisAbfrage();
try
{
erg.Start = Convert.ToDateTime(felder[6]);
}
catch (Exception f)
{
FehlerAusloesen("DatumStart", zaehler, zeile, 6, felder[6], f);
}
try
{
erg.Dauer = Convert.ToDateTime(felder[7]) - (DateTime)erg.Start;
}
catch (Exception f)
{
FehlerAusloesen("DatumEnde", zaehler, zeile, 7, felder[7], f);
}
try
{
erg.Schluessel = felder[2];
}
catch (Exception f)
{
FehlerAusloesen("NummerPosition", zaehler, zeile, 2, felder[2], f);
}
_Ergebnisse.Add(erg);
}
ErgebnissInDatenbank(Maschine, _Ergebnisse);
try
{
File.Delete(DateiName);
}
catch (Exception f)
{
msg = $"Datei {DateiName} konnte nicht gelöscht werden !\nGrund: {f.Message}";
throw new Exception(msg);
}
}
}
public FormMaschinenOptionen(tabMaschine Maschine, IEnumerable <tabStandort> Standorte)
{
InitializeComponent();
this.Maschine = Maschine;
cmbStandort.ItemsSource = Standorte;
}
public override void Start(tabMaschine Maschine)
{
var pfadStart = @"\\" + Maschine.MaschineAdresse + @"\" + _StartPfad;
Helper.SetzeBackflash(ref pfadStart);
if (KontrolleDirectory(Maschine, pfadStart))
{
var datTemp = pfadStart + "JgDaten.Txt";
if (File.Exists(datTemp))
{
DatenAuslesen(Maschine, datTemp);
}
if (!File.Exists(datTemp))
{
var datOrginal = pfadStart + "StatExport.txt";
if (File.Exists(datOrginal))
{
File.Move(datOrginal, datTemp);
if (File.Exists(datTemp))
{
DatenAuslesen(Maschine, datTemp);
}
}
}
}
}
private static void BedienerVonReparaturAbmelden(tabMaschine Maschine, tabBediener Bediener)
{
if (Maschine.eAktivReparatur != null)
{
var anmeldungReparatur = Maschine.eAktivReparatur.sAnmeldungen.Where(w => w.IstAktiv).FirstOrDefault(f => f.eBediener == Bediener);
if (anmeldungReparatur != null)
{
anmeldungReparatur.AnzeigeAbmeldung = DateTime.Now;
}
}
}
internal bool KontrolleDirectory(tabMaschine Maschine, string Pfad)
{
if (!Directory.Exists(Pfad))
{
var msg = $"Directory {Pfad} nicht vorhanden !";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
Maschine.eProtokoll.FehlerPfadZurMaschine++;
return(false);
}
return(true);
}
private tabProtokoll ProtokollErstellen(tabMaschine ZuMaschine)
{
var prot = new tabProtokoll()
{
Id = ZuMaschine.Id,
AuswertungStart = DateTime.Now.Date,
AuswertungEnde = DateTime.Now.Date,
LetzteDateiDatum = DateTime.Today.AddDays(-60),
LetzteZeile = 0,
ProtokollText = "Protokoll erstellt",
};
_ListeMaschinen.Db.tabProtokollSet.Add(prot);
return(prot);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
cmbStatus.ItemsSource = Enum.GetValues(typeof(JgMaschineData.EnumStatusMaschine));
cmbProtokolle.ItemsSource = Enum.GetValues(typeof(JgMaschineData.EnumMaschinenArt));
if (Maschine == null)
{
Maschine = new tabMaschine()
{
Id = Guid.NewGuid(), fStandort = (cmbStandort.Items[0] as tabStandort).Id
}
}
;
gridMaschine.DataContext = Maschine;
}
internal void ErgebnissInDatenbank(tabMaschine Maschine, List <ErgebnisAbfrage> Ergebnisse)
{
var vorg = $"DatenAbgleich_Datum = '{DateTime.Now}', DatenAbgleich_Bearbeiter = '{Helper.Benutzer}', DatenAbgleich_Status = 1, IstAbgleichInJgData = 0 ";
var vorgMitStart = "UPDATE tabBauteilSet SET DatumStart = '{1}', DatumEnde = '{2}', "
+ vorg + "WHERE IdStahlPosition = '{0}'\n";
var vorgNurDauer = "UPDATE tabBauteilSet SET DatumEnde = DatumStart + '{1}', "
+ vorg + "WHERE IdStahlPosition = '{0}'\n";
var sb = new StringBuilder();
foreach (var erg in Ergebnisse)
{
if (erg.Start != null)
{
sb.AppendFormat(vorgMitStart, erg.Schluessel, erg.Start, erg.Start + erg.Dauer);
}
else
{
sb.AppendFormat(vorgNurDauer, erg.Schluessel, erg.Dauer.ToString());
}
}
try
{
var anzErfolg = _Db.Database.ExecuteSqlCommand(sb.ToString(), null);
var msg = $"Datensätze aktualisiert: {anzErfolg} von {Ergebnisse.Count}";
if (anzErfolg == Ergebnisse.Count)
{
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
}
else
{
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
}
}
catch (Exception f)
{
var msg = $"Fehler beim aktualisieren der Bauteile in der Datenbank!\nGrund: {f.Message}";
throw new Exception(msg);
}
}
private static void ProgrammeEintragen(ScannerOptionen Optionen, tabMaschine Maschine, ScannerText e)
{
string msg = "";
var reparatur = Maschine.eAktivReparatur;
if (e.VorgangProgramm == VorgangProgram.REPA_ENDE)
{
if (reparatur == null)
{
e.FehlerAusgabe(" ", "Kein Vorgang", "angemeldet !");
}
else
{
e.SendeText("Vorgang beendet", " ", $"> {reparatur.Vorgang.ToString().ToUpper()} <", " ", Maschine.MaschinenName);
reparatur.VorgangEnde = DateTime.Now;
Maschine.eAktivReparatur = null;
foreach (var anmledungReparatur in reparatur.sAnmeldungen.Where(w => w.IstAktiv).ToList())
{
anmledungReparatur.Abmeldung = reparatur.VorgangEnde;
}
msg = $"Reparatur {reparatur.Vorgang} an Maschine {Maschine.MaschinenName} beendet.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Information);
};
}
else // Anmeldung einer Reparatur
{
if (reparatur != null)
{
e.FehlerAusgabe(" ", $"> {reparatur.Vorgang.ToString().ToUpper()} <", "bereits angemeldet !");
}
else
{
reparatur = new tabReparatur()
{
Id = Guid.NewGuid(),
VorgangBeginn = DateTime.Now,
fMaschine = Maschine.Id,
};
switch (e.VorgangProgramm)
{
case VorgangProgram.REPASTART: reparatur.Vorgang = EnumReperaturVorgang.Reparatur; break;
case VorgangProgram.WARTSTART: reparatur.Vorgang = EnumReperaturVorgang.Wartung; break;
case VorgangProgram.COILSTART: reparatur.Vorgang = EnumReperaturVorgang.Coilwechsel; break;
}
var anzCoils = " ";
if (e.VorgangProgramm == VorgangProgram.COILSTART)
{
reparatur.CoilwechselAnzahl = Convert.ToByte(e.ScannerKoerper);
anzCoils = $"Anzahl {reparatur.CoilwechselAnzahl}";
}
e.SendeText("Beginn Vorgang", " ", $"> {reparatur.Vorgang.ToString().ToUpper()} <", anzCoils, Maschine.MaschinenName);
Maschine.eAktivReparatur = reparatur;
foreach (var anmeldungen in Maschine.AktiveAnmeldungen)
{
var anmeldungReparatur = new tabAnmeldungReparatur()
{
Id = Guid.NewGuid(),
Anmeldung = reparatur.VorgangBeginn,
fBediener = anmeldungen.fBediener,
fReparatur = reparatur.Id,
};
Optionen.DbScann.tabAnmeldungReparaturSet.Add(anmeldungReparatur);
}
msg = $"Reparatur {reparatur.Vorgang} an Maschine {Maschine.MaschinenName} gestartet.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Information);
}
}
}
private static void BedienerAnmelden(ScannerOptionen Optionen, tabMaschine Maschine, ScannerText ScText)
{
string msg = "";
var matchCode = ScText.ScannerKoerper;
var anmeldungVorhanden = Maschine.AktiveAnmeldungen.FirstOrDefault(f => f.eBediener.MatchCode == matchCode);
if ((ScText.VorgangProgramm == VorgangProgram.ANMELDUNG) && (anmeldungVorhanden != null))
{
ScText.FehlerAusgabe("Sie sind bereits an", Maschine.MaschinenName, "angemeldet !");
return;
}
var bediener = anmeldungVorhanden?.eBediener;
if (anmeldungVorhanden == null)
{
bediener = SuchBediener(Optionen, ScText);
if (bediener == null)
{
return;
}
anmeldungVorhanden = bediener.eAktivAnmeldung;
}
// Wenn Bediener an anderer Maschine angemeldet -> abmelden
if (anmeldungVorhanden != null)
{
// Kontrolle, ob an anderer Maschine eine Reparatur läuft
if (anmeldungVorhanden.eMaschine.eAktivReparatur != null)
{
var anmeldungReparatur = anmeldungVorhanden.eMaschine.eAktivReparatur.sAnmeldungen.FirstOrDefault(f => f.IstAktiv && (f.fBediener == bediener.Id));
if (anmeldungReparatur != null)
{
anmeldungReparatur.Abmeldung = DateTime.Now;
}
}
anmeldungVorhanden.Abmeldung = DateTime.Now;
anmeldungVorhanden.ManuelleAbmeldung = false;
anmeldungVorhanden.eBediener.eAktivAnmeldung = null;
}
if (ScText.VorgangProgramm == VorgangProgram.ABMELDUNG)
{
if (anmeldungVorhanden == null)
{
ScText.FehlerAusgabe("Sie sind an keiner", "Maschine", "angemeldet !");
return;
}
ScText.SendeText(" - Abmeldung -", anmeldungVorhanden.eBediener.Name, anmeldungVorhanden.eMaschine.MaschinenName);
msg = $"Bediener {anmeldungVorhanden.eBediener.Name} an Maschine {anmeldungVorhanden.eMaschine.MaschinenName} abgemeldet.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Information);
}
else // Anmeldung an Maschine
{
ScText.SendeText(" ", "- A N M E L D U N G -", " ", bediener.Name, Maschine.MaschinenName);
var anmeldungNeu = new tabAnmeldungMaschine()
{
Id = Guid.NewGuid(),
Anmeldung = DateTime.Now,
fBediener = bediener.Id,
fMaschine = Maschine.Id,
ManuelleAnmeldung = false,
ManuelleAbmeldung = false,
};
Optionen.DbScann.tabAnmeldungMaschineSet.Add(anmeldungNeu);
bediener.fAktivAnmeldung = anmeldungNeu.Id;
// Wenn eine Reparatur läuft, an dieser anmelden
if (Maschine.eAktivReparatur != null)
{
var anmeldungReparatur = new tabAnmeldungReparatur()
{
Id = Guid.NewGuid(),
Anmeldung = DateTime.Now,
fBediener = bediener.Id,
fReparatur = (Guid)Maschine.fAktivReparatur,
};
Optionen.DbScann.tabAnmeldungReparaturSet.Add(anmeldungReparatur);
}
msg = $"Bediener {bediener.Name} an Maschine {Maschine.MaschinenName} angemeldet.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
}
}
private static void Bf2dEintragen(ScannerOptionen Optionen, tabMaschine Maschine, ScannerText ScText)
{
string msg = "";
BvbsDatenaustausch btNeu = null;
try
{
btNeu = new BvbsDatenaustausch(ScText.ScannerVorgangScan + ScText.ScannerKoerper, false);
}
catch (Exception f)
{
ScText.FehlerAusgabe("BVBS Code konnte nicht", "gelesen werden !");
msg = $"Bvbs Code konnte icht gelesen Werden.\nGrund: {f.Message}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
return;
}
if (Maschine.eAktivBauteil != null)
{
var letztesBt = Maschine.eAktivBauteil;
letztesBt.DatumEnde = DateTime.Now;
if (btNeu.BvbsString == letztesBt.BvbsCode)
{
msg = $"BauteilMaschine: {Maschine.MaschinenName}\nProject: {btNeu.ProjektNummer} erledigt";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
ScText.SendeText(" ", " - Bauteil erledigt -");
Maschine.eAktivBauteil = null;
return;
}
}
if (ScText.VorgangScan == VorgangScanner.BF2D)
{
DatenAnMaschineSenden(Optionen, Maschine, btNeu.BvbsString);
}
var btInDatenBank = Optionen.DbScann.tabBauteilSet.FirstOrDefault(f => ((f.fMaschine == Maschine.Id) && (f.BvbsCode == btNeu.BvbsString)));
if (btInDatenBank != null)
{
msg = $"Bauteil an Maschine {Maschine.MaschinenName} bereits am {btInDatenBank.DatumStart.ToString("dd.MM.yy HH:mm")} gefertigt.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
ScText.FehlerAusgabe("Bauteil bereits am", btInDatenBank.DatumStart.ToString("dd.MM.yy HH:mm"), "gefertigt.");
}
else
{
ScText.SendeText(" ", "- Bauteil OK -");
var bvbs = new BvbsDatenaustausch(btNeu.BvbsString, false);
var btNeuErstellt = new tabBauteil()
{
Id = Guid.NewGuid(),
DatumStart = DateTime.Now,
eMaschine = Maschine,
BvbsCode = btNeu.BvbsString,
BvbsDaten = bvbs,
BtGewicht = StahlGewichte.GetGewichtKg((int)btNeu.Durchmesser, (int)btNeu.Laenge),
IstHandeingabe = false,
IstVorfertigung = Maschine.IstStangenschneider && ((byte)btNeu.ListeGeometrie.Count == 0),
AnzahlBediener = (byte)Maschine.AktiveAnmeldungen.Count(),
};
foreach (var bed in Maschine.AktiveAnmeldungen)
{
btNeuErstellt.sBediener.Add(bed.eBediener);
}
Maschine.eAktivBauteil = btNeuErstellt;
msg = $"BT erstellt. Maschine: {Maschine.MaschinenName}\n Project: {btNeu.ProjektNummer} Anzahl: {btNeu.Anzahl} Gewicht: {btNeuErstellt.BtGewicht}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
}
}
// Programme zum Datenverarbeitung der Sacannerdaten **************************************************************
private static void DatenAnMaschineSenden(ScannerOptionen Optionen, tabMaschine Maschine, string BfbsString)
{
if ((Maschine.MaschinenArt == EnumMaschinenArt.Handbiegung) || (string.IsNullOrWhiteSpace(Maschine.MaschineAdresse)))
{
return;
}
string msg = "";
switch (Maschine.MaschinenArt)
{
case EnumMaschinenArt.Schnell:
if (Maschine.MaschinePortnummer == null)
{
msg = $"Bei Maschine: {Maschine.MaschinenName} wurde keine Portnummer eingetragen!";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
return;
}
Task.Factory.StartNew((SendDaten) =>
{
var md = (DatenAnMaschine)SendDaten;
try
{
msg = $"Verbindung mit: {md.Maschine.MaschinenName} Port: {md.Maschine.MaschinePortnummer}.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
using (var client = new TcpClient(md.Maschine.MaschineAdresse, (int)md.Maschine.MaschinePortnummer))
{
client.NoDelay = true;
client.SendTimeout = 1000;
client.ReceiveTimeout = 1000;
var nwStr = client.GetStream();
var buffer = Encoding.ASCII.GetBytes(md.BvbsString + Convert.ToChar(13) + Convert.ToChar(10));
nwStr.Write(buffer, 0, buffer.Length);
// Auf Antwort von Maschine warten
try
{
buffer = new byte[client.ReceiveBufferSize];
int anzEmpfang = nwStr.Read(buffer, 0, (int)client.ReceiveBufferSize);
var empfangen = Encoding.ASCII.GetString(buffer, 0, anzEmpfang);
msg = $"Rückantwort von Maschine {md.Maschine.MaschinenName}: {empfangen}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
#region Antwort der Maschine auf Fehler prüfen
if ((empfangen.Length >= 3) && (empfangen[0] == Convert.ToChar(15)))
{
var dat = JgMaschineLib.Helper.StartVerzeichnis() + @"FehlerCode\JgMaschineFehlerSchnell.txt";
if (!File.Exists(dat))
{
msg = $"Fehlerdatei: {dat} für Maschine 'Schnell' existiert nicht.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
}
else
{
try
{
string nummer = empfangen.Substring(1, 2);
var zeilen = File.ReadAllLines(dat);
foreach (var zeile in zeilen)
{
if (zeile.Substring(0, 2) == nummer)
{
msg = $"Fehlermeldung von Maschine {md.Maschine.MaschinenName} ist {zeile}!";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
break;
}
}
}
catch (Exception f)
{
msg = $"Fehler beim auslesen der Fehlerdatei Firma Schnell.\nGrund: {f.Message}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Information);
}
}
}
#endregion
}
catch (Exception f)
{
throw new Exception($"Fehler bei warten auf Antwort von Maschine ! {f.Message}", f);
}
client.Close();
msg = $"Verbindung mit: {md.Maschine.MaschinenName} abgeschlossen.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
}
}
catch (Exception f)
{
msg = $"Fehler beim senden der Bvbs Daten an die Maschine: {Maschine.MaschinenName}\nDaten: {md.BvbsString}\nGrund: {f.Message}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Error);
}
}, new DatenAnMaschine()
{
Optionen = Optionen, Maschine = Maschine, BvbsString = BfbsString
});
break;
case EnumMaschinenArt.Evg:
Task.Factory.StartNew((SendDaten) =>
{
var md = (DatenAnMaschine)SendDaten;
var datAuftrag = "Auftrag1.txt";
var datProdListe = string.Format(@"\\{0}\{1}\{2}", md.Maschine.MaschineAdresse, md.Optionen.EvgPfadProduktionsListe, datAuftrag);
// Produktionsliste schreiben
try
{
File.WriteAllText(datProdListe, md.BvbsString);
}
catch (Exception f)
{
msg = $"Fehler beim schreiben der EVG Produktionsliste in die Maschine {md.Maschine.MaschinenName}!\nDatei: {datProdListe}.\nGrund: {f.Message}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
}
// Produktionsauftrag schreiben
var datProtAuftrag = string.Format(@"\\{0}\{1}", md.Maschine.MaschineAdresse, md.Optionen.EvgDateiProduktionsAuftrag);
try
{
File.WriteAllText(datProtAuftrag, datAuftrag);
}
catch (Exception f)
{
msg = $"Fehler beim schreiben des EVG Produktionsauftrages in die Maschine {md.Maschine.MaschinenName}!\nDatei: {datProtAuftrag}.\nGrund: {f.Message}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
}
}, new { Optionen, Maschine, BfbsString });
break;
case EnumMaschinenArt.Progress:
Task.Factory.StartNew((SendDaten) =>
{
var md = (DatenAnMaschine)SendDaten;
var datei = string.Format(@"\\{0}\{1}\{2}", md.Maschine.MaschineAdresse, md.Optionen.ProgressPfadProduktionsListe, "Auftrag.txt");
// Produktionsliste schreiben
try
{
File.WriteAllText(datei, md.BvbsString, Encoding.UTF8);
}
catch (Exception f)
{
msg = $"Fehler beim schreiben der Progress Produktionsliste Maschine: {Maschine.MaschinenName} \nDatei: {datei}.\nGrund: {f.Source}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
}
}, new { Optionen, Maschine, BfbsString });
break;
}
}
public override void Start(tabMaschine Maschine)
{
var merkeLetzteDatum = Maschine.eProtokoll.LetzteDateiDatum;
var merkeLetzteZeile = Maschine.eProtokoll.LetzteZeile;
var pfadStart = @"\\" + Maschine.MaschineAdresse + @"\" + _StartPfad;
Helper.SetzeBackflash(ref pfadStart);
if (KontrolleDirectory(Maschine, pfadStart))
{
var dateienAuswertung = Directory.EnumerateFiles(pfadStart, "20*_produzione.xml", SearchOption.TopDirectoryOnly).ToList();
foreach (var datei in dateienAuswertung)
{
var datumDat = Helper.DatumAusYyyyMMdd(Path.GetFileName(datei));
if (datumDat < Maschine.eProtokoll.LetzteDateiDatum)
{
continue;
}
XDocument xdoc = XDocument.Load(datei);
XElement root = xdoc.Root;
var dataName = "{" + root.GetDefaultNamespace().NamespaceName + "}" + "DATA";
XElement rootStart = root.Elements().FirstOrDefault(z => z.Name == dataName);
foreach (var elementDatum in rootStart.Elements())
{
var datum = Helper.DatumAusYyyyMMdd(elementDatum.Attribute("date").Value);
if (datum <= Maschine.eProtokoll.LetzteDateiDatum)
{
continue;
}
int zaehler = 0;
foreach (var elementBauteil in elementDatum.Elements())
{
zaehler++;
if ((datum == Maschine.eProtokoll.LetzteDateiDatum) && (zaehler < Maschine.eProtokoll.LetzteZeile))
{
continue;
}
_Ergebnisse.Add(new ErgebnisAbfrage()
{
// Schluessel = Convert.ToInt32(w.Attribute("time_work").Value),
Dauer = new TimeSpan(0, 0, Convert.ToInt32(elementBauteil.Attribute("time_work").Value))
});
}
if (datum >= merkeLetzteDatum)
{
merkeLetzteDatum = datum;
merkeLetzteZeile = zaehler;
}
}
}
Maschine.eProtokoll.LetzteDateiDatum = merkeLetzteDatum;
Maschine.eProtokoll.LetzteZeile = merkeLetzteZeile;
}
}
public override void Start(tabMaschine Maschine)
{
var pfadStart = @"\\" + Maschine.MaschineAdresse + @"\" + _StartPfad;
Helper.SetzeBackflash(ref pfadStart);
if (KontrolleDirectory(Maschine, pfadStart))
{
// alle relevante Dateien aus Verzeichnissen laden -> Stammverzeichnis ...\EVG\Eingabe\Monit\(Jahr)\(HahrMonat)\....
var heute = DateTime.Now.Date;
var durchlauf = Maschine.eProtokoll.LetzteDateiDatum;
var dateienAuswertung = new List <string>();
while (durchlauf <= heute)
{
var dirMonatJahr = string.Format(@"{0}\{1}\{1}{2}", pfadStart, durchlauf.Year, durchlauf.Month.ToString("D2"));
dateienAuswertung.AddRange(Directory.EnumerateFiles(dirMonatJahr, "F_*.mon").ToList());
durchlauf.AddMonths(1);
}
;
var merkeLetzteDatum = Maschine.eProtokoll.LetzteDateiDatum;
var merkeLetzteZeile = Maschine.eProtokoll.LetzteZeile;
var merkeZeileBauteil = 0;
foreach (var datei in dateienAuswertung)
{
var datum = Helper.DatumAusYyyyMMdd(Path.GetFileName(datei).Substring(2));
if (datum < Maschine.eProtokoll.LetzteDateiDatum)
{
continue;
}
var lZeilen = StringListenLaden(datei);
if (datum > Maschine.eProtokoll.LetzteDateiDatum)
{
Maschine.eProtokoll.LetzteDateiDatum = datum;
}
ErgebnisAbfrage ergNeu = null;
var zeileStart = 0;
if (datum == merkeLetzteDatum)
{
zeileStart = merkeLetzteZeile;
}
for (int zeile = zeileStart; zeile < lZeilen.Length; zeile++)
{
if (lZeilen[zeile][7] == 'A')
{
merkeZeileBauteil = zeile;
ergNeu = new ErgebnisAbfrage()
{
Start = GetDatum(datum, lZeilen[zeile])
};
_Ergebnisse.Add(ergNeu);
var felder = lZeilen[zeile].Split(new char[] { ';' }, StringSplitOptions.None);
try
{
ergNeu.Schluessel = felder[4];
}
catch (Exception f)
{
var msg = $"Fehler beim konvertieren der Id {felder[4]} in Zeile: {zeile}.\nGrund: {f.Message}";
throw new Exception(msg);
}
}
else if ((ergNeu != null) && (lZeilen[zeile][7] == 'D'))
{
ergNeu.Dauer = (DateTime)ergNeu.Start - GetDatum(datum, lZeilen[zeile]);
}
}
if (datum == Maschine.eProtokoll.LetzteDateiDatum)
{
Maschine.eProtokoll.LetzteZeile = merkeZeileBauteil;
}
}
ErgebnissInDatenbank(Maschine, _Ergebnisse);
}
}
public FormReparatur(tabReparatur NeuReparatur, IEnumerable <tabBediener> Bediener, tabMaschine AktuelleMaschine = null)
{
InitializeComponent();
cmbVerursacher.ItemsSource = Bediener;
cmbProtokollant.ItemsSource = Bediener;
cmbVorgangs.ItemsSource = Enum.GetValues(typeof(EnumReperaturVorgang));
cmbVorgangs.SelectedIndex = 0;
if (NeuReparatur == null)
{
NeuReparatur = new JgMaschineData.tabReparatur()
{
VorgangBeginn = DateTime.Now,
eMaschine = AktuelleMaschine
};
lbBisDatum.Visibility = Visibility.Collapsed;
dtpRepBis.Visibility = Visibility.Collapsed;
lbBisPunkt.Visibility = Visibility.Collapsed;
tbBisZeit.Visibility = Visibility.Collapsed;
}
else
{
var dzBis = (JgZeit)this.FindResource("dzReparaturBis");
dzBis.AnzeigeDatumZeit = NeuReparatur.VorgangEnde ?? DateTime.Now;
dzBis.OnNeuerWert = (datum, zeit) => Reparatur.AnzeigeVorgangEnde = datum + zeit;
}
var dzVon = (JgZeit)this.FindResource("dzReparaturVon");
dzVon.AnzeigeDatumZeit = NeuReparatur.VorgangBeginn;
dzVon.OnNeuerWert = (datum, zeit) => NeuReparatur.AnzeigeVorgangBeginn = datum + zeit;
gridReparatur.DataContext = NeuReparatur;
}
public abstract void Start(tabMaschine Maschine);
