internal override void SendeDatenZurMaschine(string BvBsCode)
{
Task.Factory.StartNew((SendDaten) =>
{
var md = (DatenTaskMaschine)SendDaten;
var datAuftrag = "Auftrag1.txt";
var datProdListe = string.Format(@"\\{0}\{1}\{2}", md.Maschine.MaschineIp, md.PfadProduktionsListe, datAuftrag);
try
{
File.WriteAllText(datProdListe, md.BvbsString);
}
catch (Exception f)
{
JgLog.Set(this, $"Fehler beim schreiben der EVG Produktionsliste!\nDatei: {datProdListe}.\nGrund: {f.Message}", JgLog.LogArt.Warnung);
}
// Produktionsauftrag schreiben
var datProtAuftrag = string.Format(@"\\{0}\{1}", md.Maschine.MaschineIp, md.DateiProduktionsAuftrag);
try
{
File.WriteAllText(datProtAuftrag, datAuftrag);
}
catch (Exception f)
{
JgLog.Set(this, $"Fehler beim schreiben des EVG Produktionsauftrages!\nDatei: {datProtAuftrag}.\nGrund: {f.Message}", JgLog.LogArt.Warnung);
}
}, _DatenTask);
}
private string[] MeldungBeenden(JgMaschineStamm Maschine)
{
if (Maschine.MeldMeldung == null)
{
return(null);
}
var progText = "Reparatur";
switch (Maschine.MeldMeldung.Meldung)
{
case ScannerMeldung.COILSTART:
progText = "Coilwechsel";
break;
case ScannerMeldung.WARTSTART:
progText = "Wartung";
break;
}
var meldung = Maschine.MeldMeldung.Abmeldung();
Maschine.MeldMeldung = null;
JgLog.Set(Maschine, $"Meldung {progText} beendet!", JgLog.LogArt.Info);
_JgOpt.QueueSend($"Meldung {progText} beendet", Maschine, meldung);
return(new string[] { "", progText, "beendet" });
}
public static void LoadStatusMaschineLocal(JgMaschineStamm Maschine, string PfadAusgabe)
{
if (Maschine != null)
{
var datAusgabe = GetDateiName(PfadAusgabe, Maschine.Id);
try
{
var erg = Helper.XmlDateiInObjekt <JgMaschinenStatus>(datAusgabe);
if (erg != null)
{
Maschine.AktivBauteil = erg.AktivBauteil;
Maschine.ListeBauteile = erg.ListeBauteile;
Maschine.MeldBediener = erg.MeldBediener;
Maschine.MeldListeHelfer = erg.MeldListeHelfer;
Maschine.MeldMeldung = erg.MeldMeldung;
}
}
catch (Exception ex)
{
JgLog.Set(null, $"Fehler Reader Program 'Load' Maschinenstatus für Datei {datAusgabe} ausgelöst\nGrund: {ex.Message}", JgLog.LogArt.Info);
}
}
}
public byte[] GetStatusAsXmlByte()
{
if (_Maschine != null)
{
var lhelfer = MeldListeHelfer.Select(s => s.Id).ToList();
var erg = new JgMaschinenStatusMeldungen()
{
IdBediener = MeldBediener?.Id,
IdMeldung = MeldMeldung?.Id,
IdAktivBauteil = AktivBauteil?.Id,
IdListeHelfer = new List <Guid>(lhelfer),
Information = _Maschine.Information
};
try
{
return(Helper.ObjectInXmlDatenByte <JgMaschinenStatusMeldungen>(erg));
}
catch (Exception ex)
{
JgLog.Set(null, $"Fehler Reader Load Maschinenstatus ausgelöst.\nGrund: {ex.Message}", JgLog.LogArt.Info);
}
}
return(null);
}
private void MaschineBvbsEintragen(JgScannerAusgabe ScanAusgabe, JgMaschineStamm Maschine)
{
if (Maschine.AktivBauteil != null)
{
var bauteilFertig = Maschine.AktivBauteil.IdBauteilJgData == ScanAusgabe.ScannKoerper;
BauteilBeendet(ScanAusgabe, Maschine);
if (bauteilFertig)
{
return;
}
}
BvbsDaten btNeu = null;
try
{
btNeu = new BvbsDaten(ScanAusgabe.BvbsString, true);
}
catch (Exception f)
{
JgLog.Set(Maschine, $"Bvbs Code konnte icht gelesen Werden.\nGrund: {f.Message}", JgLog.LogArt.Info);
ScanAusgabe.Set(false, true, "Fehler im BVBS", "Code");
return;
}
//todo: Aktives Bausteil von String in eindeutige Id aus JgData umwandeln
var btId = ScanAusgabe.ScannKoerper.Replace("\n", string.Empty).Replace("\r", string.Empty);
if (Maschine.ListeBauteile.Any(a => a.IdJgData == btId))
{
ScanAusgabe.Set(true, true, "Bauteil wurde", "bereits", "erstellt !");
}
else
{
Maschine.AktivBauteil = new JgBauteil
{
IdMaschine = Maschine.Id,
IdBediener = Maschine.MeldBediener.IdBediener,
AnzahlHelfer = Maschine.MeldListeHelfer.Count,
IdBauteilJgData = btId,
AnzahlTeile = btNeu.Anzahl ?? 0,
GewichtInKg = btNeu.Gewicht ?? 0,
DuchmesserInMm = btNeu.Durchmesser ?? 0,
LaengeInCm = btNeu.Laenge ?? 0,
AnzahlBiegungen = btNeu.ListeGeometrie.Count() - 1
};
JgLog.Set(Maschine, $"Bauteil {Maschine.AktivBauteil.Id} registriert.", JgLog.LogArt.Unbedeutend);
_JgOpt.QueueSend($"BT {Maschine.AktivBauteil.Id}", Maschine.AktivBauteil);
ScanAusgabe.Set(true, false, "Bauteil in", "Maschine", "registriert");
}
}
// Programme zum Datenverarbeitung der Sacannerdaten **************************************************************
private void BauteilBeendet(JgScannerAusgabe ScanAusgabe, JgMaschineStamm Maschine)
{
var meldung = new JgMeldung()
{
Id = Maschine.AktivBauteil.Id,
IdBediener = Maschine.AktivBauteil.IdBediener,
Meldung = ScannerMeldung.BAUT_ENDE,
Aenderung = DateTime.Now
};
Maschine.ListeBauteile.Add(new JgBauteilFertig(meldung.Id, Maschine.AktivBauteil.IdBauteilJgData));
Maschine.AktivBauteil = null;
JgLog.Set(Maschine, $"Bauteilt: {meldung.Id} erledigt", JgLog.LogArt.Unbedeutend);
_JgOpt.QueueSend($"Bauteil {ScanAusgabe.ScannKoerper} fertig", Maschine, meldung);
ScanAusgabe.Set(false, false, "", "Bauteil", "fertig!");
}
internal override void SendeDatenZurMaschine(string BvBsCode)
{
_DatenTask.BvbsString = BvBsCode;
Task.Factory.StartNew((SendDaten) =>
{
var md = (DatenTaskMaschine)SendDaten;
var datei = string.Format(@"\\{0}\{1}\{2}", md.Maschine.MaschineIp, md.PfadProduktionsListe, "Auftrag.txt");
try
{
File.WriteAllText(datei, BvBsCode, Encoding.UTF8);
}
catch (Exception ex)
{
JgLog.Set(this, $"Fehler beim schreiben der Progress Produktionsliste!\nDatei: {datei}.\nGrund: {ex.Message}", JgLog.LogArt.Fehler);
}
}, BvBsCode);
}
public void SaveStatusMaschineLocal()
{
if (_Maschine != null)
{
Task.Factory.StartNew((Opt) =>
{
var optUeberg = (OptUebergabe)Opt;
try
{
Helper.ObjektInXmlDatei <JgMaschinenStatus>(optUeberg.StatusMaschine, optUeberg.DateiAusgabe);
}
catch (Exception ex)
{
JgLog.Set(null, $"Fehler Writer Save Maschinenstatus ausgelöst.\nGrund: {ex.Message}", JgLog.LogArt.Info);
}
}, new OptUebergabe()
{
StatusMaschine = this, DateiAusgabe = _DateiAusgabe
});
}
}
public void DatenZurMaschine(string BvBsCode)
{
JgLog.Set(this, $"Sende Daten an {this.MaschineName}", JgLog.LogArt.Info);
SendeDatenZurMaschine(BvBsCode);
}
internal override void SendeDatenZurMaschine(string BvBsCode)
{
JgLog.Set(this, $"Daten registriert.", JgLog.LogArt.Info);
}
internal override void SendeDatenZurMaschine(string BvBsCode)
{
if (this.MaschinePort == 0)
{
JgLog.Set(this, $"Bei Maschine wurde keine Portnummer eingetragen!", JgLog.LogArt.Krittisch);
}
else
{
_DatenTask.BvbsString = BvBsCode;
Task.Factory.StartNew((SendDaten) =>
{
var md = (DatenTaskMaschine)SendDaten;
try
{
using (var client = new TcpClient(md.Maschine.MaschineIp, md.Maschine.MaschinePort))
{
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);
JgLog.Set(this, $"Rückantwort von Maschine {md.Maschine.MaschineName}: {empfangen}", JgLog.LogArt.Unbedeutend);
#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 beim warten auf Antwort von Maschine ! {f.Message}", f);
}
client.Close();
JgLog.Set(this, $"Verbindung abgeschlossen.", JgLog.LogArt.Unbedeutend);
}
}
catch (Exception f)
{
JgLog.Set(this, $"Fehler beim senden der Bvbs Daten an die Maschine.\nDaten: {md.BvbsString}\nGrund: {f.Message}", JgLog.LogArt.Warnung);
}
}, _DatenTask);
}
}
internal override void EinlesenZeitenAusMaschine()
{
var pfadStart = @"\\" + this.MaschineIp + @"\" + "Muss noch eingessellt werden";
if (!Directory.Exists(pfadStart))
{
JgLog.Set(this, "Pad zum Auslesen der Daten nicht gefunden", JgLog.LogArt.Fehler);
}
else
{
// alle relevante Dateien aus Verzeichnissen laden -> Stammverzeichnis ...\EVG\Eingabe\Monit\(Jahr)\(HahrMonat)\....
var heute = DateTime.Now.Date;
var durchlauf = this.ListeBauteile.Min(m => m.Erstellt);
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);
}
}
static void Main(string[] args)
{
Logger.SetLogWriter(new LogWriterFactory().Create());
ExceptionPolicy.SetExceptionManager(new ExceptionPolicyFactory().CreateManager(), false);
// Bsp.: ExceptionPolicy.HandleException(ex, "Policy");
Console.WriteLine("Scanner Gestartet");
JgLog.Set(null, "Programm wird gestartet!", JgLog.LogArt.Info);
var pr = Properties.Settings.Default;
var jgOpt = new JgOptionen()
{
IdStandort = pr.IdStandort,
};
// Bediener und Maschine local laden, danach mit Server abgeleichen
var init = new JgInit(jgOpt);
init.BedienerLocalLaden();
init.MaschinenLocalLaden();
try
{
using (var dienst = new ServiceRef.WcfServiceClient())
{
var tt = dienst.WcfTest("OK?");
if (tt == "OK?")
{
JgLog.Set(null, "Verbindung Server OK!", JgLog.LogArt.Info);
if (init.BedienerVonServer(dienst))
{
init.BedienerLocalSpeichern();
}
if (init.MaschinenVonServer(dienst))
{
init.MaschinenLocalSpeichern();
}
}
}
}
catch (Exception ex)
{
ExceptionPolicy.HandleException(ex, "Policy");
}
// Status Maschinen laden, wenn vorhanden
foreach (var maStatus in jgOpt.ListeMaschinen.Values)
{
JgMaschinenStatus.LoadStatusMaschineLocal(maStatus, jgOpt.PfadDaten);
}
// Optionen für jedes Craddel laden
var listeCraddleOpt = new List <JgOptionenCraddle>();
for (int i = 0; i < 5; i++)
{
var s = Properties.Settings.Default["Craddel_" + i.ToString()].ToString();
var crad = new JgOptionenCraddle(jgOpt);
Helper.PropStringInOnjekt <JgOptionenCraddle>(crad, s);
if (crad.CraddleIpAdresse != "")
{
listeCraddleOpt.Add(crad);
}
}
#if DEBUG
var lTaskMaschine = new List <JgScannerMaschinen>();
foreach (var crad in listeCraddleOpt)
{
var sm = new JgScannerMaschinen();
sm.TaskScannerMaschineStarten(crad);
lTaskMaschine.Add(sm);
}
var datenZumServer = new JgDatenZumServer(jgOpt);
datenZumServer.DatenabgleichStarten();
Console.WriteLine("Fertig");
Console.ReadKey();
#else
var ServiceToRun = new ServiceBase[] { new JgMaschineServiceScanner(scOptionen) };
ServiceBase.Run(ServiceToRun);
#endif
}
private void MaschineMeldungEintragen(JgScannerAusgabe ScanAusgabe, JgMaschineStamm Maschine)
{
// *** Unterprogramm Bendigung von Coilwechsel, Wartung und Reparatur mit "Rep_Ende"
switch (ScanAusgabe.Meldung)
{
case ScannerMeldung.COILSTART:
if (Maschine?.MeldMeldung?.Meldung == ScannerMeldung.COILSTART)
{
ScanAusgabe.Set(false, true, "Coilwechsle bereits", "begonnen");
}
else
{
MeldungBeenden(Maschine);
Maschine.MeldMeldung = new JgMeldung(Maschine.MeldBediener.IdBediener, ScannerMeldung.COILSTART);
try
{
Maschine.MeldMeldung.Anzahl = Convert.ToInt32(ScanAusgabe.ScannKoerper);
}
catch { }
JgLog.Set(Maschine, $"Start Coilwechsel. Anzahl: {Maschine.MeldMeldung.Anzahl ?? 0}", JgLog.LogArt.Info);
ScanAusgabe.Set(false, false, "", "Coilwechsel", "gestartet");
_JgOpt.QueueSend($"Start Coilwechsel", Maschine, Maschine.MeldMeldung);
}
break;
case ScannerMeldung.REPASTART:
if (Maschine?.MeldMeldung?.Meldung == ScannerMeldung.REPASTART)
{
ScanAusgabe.Set(false, true, "Reparatur bereits", "begonnen");
}
else
{
MeldungBeenden(Maschine);
Maschine.MeldMeldung = new JgMeldung(Maschine.MeldBediener.IdBediener, ScannerMeldung.REPASTART);
JgLog.Set(Maschine, "Start Reparatur.", JgLog.LogArt.Info);
ScanAusgabe.Set(false, false, "", "Reparatur", "gestartet");
_JgOpt.QueueSend($"Start Reparatur", Maschine, Maschine.MeldMeldung);
}
break;
case ScannerMeldung.WARTSTART:
if (Maschine?.MeldMeldung?.Meldung == ScannerMeldung.WARTSTART)
{
ScanAusgabe.Set(false, true, "Wartung bereits", "begonnen");
}
else
{
MeldungBeenden(Maschine);
Maschine.MeldMeldung = new JgMeldung(Maschine.MeldBediener.IdBediener, ScannerMeldung.WARTSTART);
JgLog.Set(Maschine, $"Start Wartung.", JgLog.LogArt.Info);
ScanAusgabe.Set(false, false, "", "Wartung", "gestartet");
_JgOpt.QueueSend($"Start Wartung", Maschine, Maschine.MeldMeldung);
}
break;
case ScannerMeldung.REPA_ENDE:
if (Maschine.MeldMeldung == null)
{
ScanAusgabe.Set(false, true, "", "Keine Meldung", "registriert");
}
else
{
ScanAusgabe.Set(false, false, MeldungBeenden(Maschine));
}
break;
}
}
private void MaschineAnmeldungEintragen(JgScannerAusgabe ScanAusgabe, JgMaschineStamm Maschine)
{
var bediener = _JgOpt.JgOpt.ListeBediener.FirstOrDefault(f => (f.Value.NummerAusweis == ScanAusgabe.ScannKoerper)).Value;
if (bediener == null)
{
JgLog.Set(Maschine, $"Bediener ({ScanAusgabe.ScannKoerper}) nicht in Datenbank !", JgLog.LogArt.Info);
ScanAusgabe.Set(false, true, "Bediener", ScanAusgabe.ScannKoerper, "nicht regisitriert");
}
else
{
if ((ScanAusgabe.Meldung == ScannerMeldung.ANMELDUNG) && (Maschine.MeldBediener != null))
{
if (bediener.Id == Maschine.MeldBediener.IdBediener)
{
ScanAusgabe.Set(false, true, "Bediener", bediener.BedienerName, "bereits angemeldet!");
return;
}
else if (Maschine.MeldListeHelfer.Any(f => f.IdBediener == bediener.Id))
{
ScanAusgabe.Set(false, true, "Helfer", bediener.BedienerName, "bereits angemeldet!");
return;
}
}
// In allen Maschinen nach einer Anmeldung suchen und abmelden
var abmeldungBediener = false;
var abmeldungHelfer = false;
foreach (var maAbmeldung in _JgOpt.JgOpt.ListeMaschinen.Values)
{
// Wenn Bediener auf einer Maschine angemeldet ist
if (maAbmeldung?.MeldBediener?.IdBediener == bediener.Id)
{
abmeldungBediener = true;
var msg = $"Bediener {bediener.BedienerName} abgemeldet";
var meldung = maAbmeldung.MeldBediener.Abmeldung();
maAbmeldung.MeldBediener = null;
_JgOpt.QueueSend(msg, maAbmeldung, meldung);
JgLog.Set(Maschine, msg, JgLog.LogArt.Unbedeutend);
// Bei Bedienerabmeldung auch alle Helfer abmelden
foreach (var meldHelfer in maAbmeldung.MeldListeHelfer)
{
// Wenn Helfer in Liste Bediener vorhanden
if (_JgOpt.JgOpt.ListeBediener.ContainsKey(meldHelfer.IdBediener))
{
meldHelfer.Abmeldung();
msg = $"Helfer {_JgOpt.JgOpt.ListeBediener[meldHelfer.IdBediener].BedienerName} abgemeldet!";
_JgOpt.QueueSend(msg, maAbmeldung, meldHelfer);
JgLog.Set(Maschine, msg, JgLog.LogArt.Unbedeutend);
}
}
Maschine.MeldListeHelfer.Clear();
}
else
{
// Ob in einer Helferliste eingetragen
var lHelfer = maAbmeldung.MeldListeHelfer.Where(w => w.IdBediener == bediener.Id).ToList();
foreach (var meldHelfer in lHelfer)
{
abmeldungHelfer = true;
if (_JgOpt.JgOpt.ListeBediener.ContainsKey(meldHelfer.IdBediener))
{
var meldung = meldHelfer.Abmeldung();
maAbmeldung.MeldListeHelfer.Remove(meldHelfer);
_JgOpt.QueueSend($"Helfer {_JgOpt.JgOpt.ListeBediener[meldHelfer.IdBediener]} abgemeldet", maAbmeldung, meldung);
JgLog.Set(Maschine, $"Helfer {_JgOpt.JgOpt.ListeBediener[meldHelfer.IdBediener].BedienerName} abgemeldet!", JgLog.LogArt.Unbedeutend);
}
}
}
}
if (ScanAusgabe.Meldung == ScannerMeldung.ABMELDUNG)
{
if (abmeldungBediener)
{
ScanAusgabe.Set(false, false, "", "Bediener", bediener.BedienerName, "abgemeldet!");
}
else if (abmeldungHelfer)
{
ScanAusgabe.Set(false, false, "", "Helfer", bediener.BedienerName, "abgemeldet!");
}
else
{
ScanAusgabe.Set(false, true, "Keine Anmeldung", bediener.BedienerName, "registriert!");
}
}
else // Anmeldung eintragen
{
if (Maschine.MeldBediener == null)
{
Maschine.MeldBediener = new JgMeldung(bediener.Id, ScannerMeldung.ANMELDUNG);
_JgOpt.QueueSend($"Bediener {bediener.BedienerName} angemeldet", Maschine, Maschine.MeldBediener);
ScanAusgabe.Set(false, false, "", "Bediener", bediener.BedienerName, "angemeldet!");
JgLog.Set(Maschine, $"Bediener {bediener.BedienerName} angemeldet!", JgLog.LogArt.Unbedeutend);
}
else // Wenn ein Bediener angemeldet, wird ein Helfer angemeldet
{
var meld = new JgMeldung(bediener.Id, ScannerMeldung.ANMELDUNG);
Maschine.MeldListeHelfer.Add(meld);
_JgOpt.QueueSend($"Helfer {bediener.BedienerName} angemeldet", Maschine, meld);
ScanAusgabe.Set(false, false, "", "Helfer", bediener.BedienerName, "angemeldet!");
JgLog.Set(Maschine, $"Helfer {bediener.BedienerName} angemeldet!", JgLog.LogArt.Unbedeutend);
}
}
}
}
public JgScannerAusgabe TextEmpfangen(string TextEmpfangen)
{
var scanAusgabe = new JgScannerAusgabe(TextEmpfangen);
if (scanAusgabe.ScannerKennung == null)
{
JgLog.Set(null, $"Sannernummer {TextEmpfangen} zu klein", JgLog.LogArt.Fehler);
}
else
{
var maschine = _JgOpt.JgOpt.ListeMaschinen.FirstOrDefault(f => f.Value.NummerScanner == scanAusgabe.ScannerKennung).Value;
if (maschine == null)
{
JgLog.Set(null, $"Maschine mit Scannernummer {scanAusgabe.ScannerKennung} nicht gefunden", JgLog.LogArt.Fehler);
scanAusgabe.Set(false, true, "Maschine nicht", "gefunden");
}
else if ((scanAusgabe.TextEmpfangen.Length == 16) && (scanAusgabe.TextEmpfangen[13] == 'S'))
{
JgLog.Set(maschine, $"Schalter getrückt: {scanAusgabe.ScannKoerper}", JgLog.LogArt.Info);
scanAusgabe.Set(false, false, $"Schalter {scanAusgabe.ScannKoerper}", "gedrückt");
}
else if (scanAusgabe.TextEmpfangen.Length < 17)
{
JgLog.Set(maschine, $"Scanner {scanAusgabe.TextEmpfangen}. Text zu kurz.", JgLog.LogArt.Fehler);
scanAusgabe.Set(false, true, $"Text zu kurz");
}
else
{
if (scanAusgabe.VorgangScan != ScannerVorgang.FEHLER)
{
switch (scanAusgabe.VorgangScan)
{
case ScannerVorgang.BF2D:
case ScannerVorgang.TEST: scanAusgabe.Meldung = ScannerMeldung.TES_____T; break;
case ScannerVorgang.SCHALTER: scanAusgabe.Meldung = ScannerMeldung.SCHALTE_R; break;
case ScannerVorgang.MITA:
if (TextEmpfangen[17] == '0')
{
scanAusgabe.Meldung = ScannerMeldung.ANMELDUNG;
}
else
{
scanAusgabe.Meldung = ScannerMeldung.ABMELDUNG;
}
break;
case ScannerVorgang.PROG:
var scanProgrammText = (scanAusgabe.TextEmpfangen.Length < 26) ? null : scanAusgabe.TextEmpfangen.Substring(17, 9);
Enum.TryParse <ScannerMeldung>(scanProgrammText, true, out scanAusgabe.Meldung);
break;
}
if ((scanAusgabe.VorgangScan != ScannerVorgang.MITA) && (maschine.MeldBediener == null))
{
JgLog.Set(maschine, "Kein Bediener angemeldet.", JgLog.LogArt.Info);
scanAusgabe.Set(false, true, "", "Kein Bediener", "angemeldet !");
}
else
{
try
{
scanAusgabe.ScannerMitDisplay = maschine.ScannerMitDisplay;
switch (scanAusgabe.VorgangScan)
{
case ScannerVorgang.BF3D:
case ScannerVorgang.BF2D:
scanAusgabe.BvbsString = scanAusgabe.VorgangScan.ToString() + scanAusgabe.ScannKoerper;
MaschineBvbsEintragen(scanAusgabe, maschine);
if (scanAusgabe.MeldungAnMaschine)
{
maschine.SendeDatenZurMaschine(scanAusgabe.BvbsString);
}
break;
case ScannerVorgang.MITA:
MaschineAnmeldungEintragen(scanAusgabe, maschine);
break;
case ScannerVorgang.PROG:
MaschineMeldungEintragen(scanAusgabe, maschine);
break;
}
}
catch (Exception ex)
{
ExceptionPolicy.HandleException(ex, "Policy");
throw new Exception("Felhler in ScannerAusgabe", ex);
}
}
}
}
}
return(scanAusgabe);
}
public void TaskScannerMaschineStarten(JgOptionenCraddle CraddelOptionen)
{
var ctScannerMaschine = CraddelOptionen.JgOpt.CraddelTokensSource.Token;
TaskScannerMaschine = new Task((optCraddel) =>
{
var optCrad = (JgOptionenCraddle)optCraddel;
var auswertScanner = new JgScannerAuswertung(optCrad);
var msg = "";
TcpClient client = null;
NetworkStream netStream = null;
while (true)
{
JgLog.Set(null, $"Verbindungsaufbau {optCrad.Info}", JgLog.LogArt.Info);
if (!Helper.IstPingOk(optCrad.CraddleIpAdresse, out msg))
{
JgLog.Set(null, $"Ping Fehler {optCrad.Info}\nGrund: {msg}", JgLog.LogArt.Info);
Thread.Sleep(20000);
continue;
}
try
{
client = new TcpClient(optCrad.CraddleIpAdresse, optCrad.CraddlePort);
}
catch (Exception ex)
{
JgLog.Set(null, $"Fehler Verbindungsaufbau {optCrad.Info}\nGrund: {ex.Message}", JgLog.LogArt.Info);
Thread.Sleep(30000);
continue;
}
JgLog.Set(null, $"Verbindung Ok {optCrad.Info}", JgLog.LogArt.Info);
netStream = client.GetStream();
while (true)
{
var ctsScanner = new CancellationTokenSource();
var ctPing = ctsScanner.Token;
// Wenn dieser Task eher als Scanner beendet wird, liegt ein Verbindungsfehler vor;
var taskKontrolle = Task.Factory.StartNew((CraddelIpAdresse) =>
{
var ipCraddle = (string)CraddelIpAdresse;
while (true)
{
if (ctPing.IsCancellationRequested)
{
break;
}
Thread.Sleep(30000);
if (ctPing.IsCancellationRequested)
{
break;
}
if (!Helper.IstPingOk(ipCraddle, out msg))
{
break;
}
JgLog.Set(null, $"Ping {ipCraddle} Ok.", JgLog.LogArt.Unbedeutend);
}
}, optCrad.CraddleIpAdresse, ctPing);
var ctScanner = ctsScanner.Token;
var taskScannen = Task.Factory.StartNew <string>((nStream) =>
{
var nStr = (NetworkStream)netStream;
byte[] bufferEmpfang = new byte[4096];
int anzZeichen = 0;
try
{
anzZeichen = nStr.Read(bufferEmpfang, 0, bufferEmpfang.Length);
}
catch (Exception ex)
{
if (!ctScanner.IsCancellationRequested)
{
var letzteZeichen = Encoding.ASCII.GetString(bufferEmpfang, 0, anzZeichen);
JgLog.Set(null, $"Fehler Datenempfang {optCrad.Info}!\nLetzter Text: {letzteZeichen}\nGrund: {ex.Message}", JgLog.LogArt.Warnung);
return(optCrad.TextBeiFehler);
}
}
return(Encoding.ASCII.GetString(bufferEmpfang, 0, anzZeichen));
}, netStream, ctScanner);
Task.WaitAny(new Task[] { taskKontrolle, taskScannen });
ctsScanner.Cancel();
if (taskScannen.IsCompleted)
{
var textEmpfangen = taskScannen.Result;
if (textEmpfangen == optCrad.TextBeiFehler)
{
JgLog.Set(null, $"{optCrad.Info} -> Fehlertext angesprochen.", JgLog.LogArt.Warnung);
}
else if (textEmpfangen.Length == 1)
{
JgLog.Set(null, $"{optCrad.Info} -> Ein Zeichen Empfangen: {Convert.ToByte(textEmpfangen[0])}", JgLog.LogArt.Warnung);
}
else if (textEmpfangen.Length < 1)
{
JgLog.Set(null, $"{optCrad.Info} -> Leeres Zeichen Empfangen!", JgLog.LogArt.Warnung);
}
else
{
if (textEmpfangen.Contains(optCrad.TextVerbinungOk))
{
JgLog.Set(null, $"Verbindung Craddle OK ! {textEmpfangen}", JgLog.LogArt.Info);
}
else
{
var ergScanner = auswertScanner.TextEmpfangen(taskScannen.Result);
netStream.Write(ergScanner.AusgabeAufCraddle, 0, ergScanner.AusgabeAufCraddle.Length);
}
continue;
}
}
try
{
JgLog.Set(null, $"Abbruch {optCrad.Info}!", JgLog.LogArt.Warnung);
if (client != null)
{
if (client.Connected)
{
client.Close();
}
client.Dispose();
}
client = null;
if (netStream != null)
{
netStream.Close();
netStream.Dispose();
}
netStream = null;
}
catch { };
break;
}
}
}, CraddelOptionen, ctScannerMaschine, TaskCreationOptions.LongRunning);
TaskScannerMaschine.Start();
}
public void DatenabgleichStarten()
{
var ctDatenabfrage = _JgOpt.CraddelTokensSource.Token;
var task = new Task((JgOptionenSenden) =>
{
var optSenden = (JgOptionen)JgOptionenSenden;
while (true)
{
var queue = new MessageQueue(optSenden.PathQueue, QueueAccessMode.Receive)
{
Formatter = new XmlMessageFormatter(new Type[] { typeof(ServiceRef.JgWcfMeldung), typeof(ServiceRef.JgWcfBauteil) })
};
while (true)
{
try
{
MessageQueueTransaction myTransaction = null;
try
{
using (var verb = new ServiceRef.WcfServiceClient())
{
while (true)
{
object sendObj = null;
myTransaction = new MessageQueueTransaction();
try
{
myTransaction.Begin();
var erg = queue.Receive(new TimeSpan(0, 10, 0), myTransaction);
sendObj = erg.Body;
}
catch (MessageQueueException ex)
{
myTransaction.Abort();
if (ex.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout)
{
throw new Exception($"Fehler lesen Meldung aus MessageQueue!", ex);
}
}
// Wenn nach 10 Minute keine Aktion vorhanden ist, wird die Verbindung für 10 Minuten
// geschlossen und danach wieder neu gestartet.
if (sendObj == null)
{
JgLog.Set(null, $"Verbindung wird wegen Inaktivität für 10 Minuten geschlossen !", JgLog.LogArt.Info);
//todo Verbindungsauszeit eintragen
Thread.Sleep(new TimeSpan(0, 10, 0));
}
else
{
if (sendObj is ServiceRef.JgWcfMeldung wcfMeldung)
{
var maschine = JgInit.GetMaschine(optSenden.ListeMaschinen, wcfMeldung.IdMaschine);
var maStatus = new JgMaschinenStatus(maschine, optSenden.PfadDaten);
maStatus.SaveStatusMaschineLocal();
var antwortServer = verb.SendeMeldung(wcfMeldung, maStatus.GetStatusAsXmlByte());
if (antwortServer.Substring(0, 2) == "OK")
{
myTransaction.Commit();
if (antwortServer.Length > 2)
{
JgLog.Set(null, antwortServer.Substring(2), JgLog.LogArt.Fehler);
}
else
{
JgLog.Set(null, $"Wcf Meldung {wcfMeldung.Meldung} mit Id {wcfMeldung.Id} gesendet", JgLog.LogArt.Info);
}
}
else
{
myTransaction.Abort();
JgLog.Set(null, $"Wpf 'Meldung' Fehler durch Server!\nGrund: {antwortServer}", JgLog.LogArt.Fehler);
}
}
else if (sendObj is ServiceRef.JgWcfBauteil wcfBauteil)
{
var maschine = JgInit.GetMaschine(optSenden.ListeMaschinen, wcfBauteil.IdMaschine);
var maStatus = new JgMaschinenStatus(maschine, optSenden.PfadDaten);
maStatus.SaveStatusMaschineLocal();
var antwortServer = verb.SendeBauteil(wcfBauteil, maStatus.GetStatusAsXmlByte());
if (antwortServer.Substring(0, 2) == "OK")
{
myTransaction.Commit();
if (antwortServer.Length > 2)
{
JgLog.Set(null, antwortServer.Substring(2), JgLog.LogArt.Fehler);
}
else
{
JgLog.Set(null, $"Wcf Bauteil mit Id {wcfBauteil.Id} gesendet", JgLog.LogArt.Info);
}
}
else
{
myTransaction.Abort();
JgLog.Set(null, $"Wpf 'Bauteil' Fehler durch Server!\nGrund: {antwortServer}", JgLog.LogArt.Fehler);
}
}
}
}
}
}
catch (TimeoutException ex)
{
if (myTransaction != null)
{
myTransaction.Abort();
}
throw new TimeoutException("Wpf Zeitüberschreitung", ex);
}
catch (FaultException faultEx)
{
if (myTransaction != null)
{
myTransaction.Abort();
}
switch (faultEx.Code.Name)
{
case "InternalServiceFault":
JgLog.Set(null, faultEx.Message, JgLog.LogArt.Info);
Thread.Sleep(10000);
break;
default:
var msg = (faultEx.Code.SubCode == null) ? "" : " -> Subcode: " + faultEx.Code.SubCode.Name;
msg = $"WCF Faultexeption -> {faultEx.Code.Name} Message: {faultEx.Message} {msg}";
JgLog.Set(null, msg, JgLog.LogArt.Info);
throw new Exception(msg, faultEx);
}
}
catch (CommunicationException ex)
{
if (myTransaction != null)
{
myTransaction.Abort();
}
JgLog.Set(null, $"Verbindung zum Server konnte nicht aufgebaut werden !\nGrund: {ex.Message}", JgLog.LogArt.Warnung);
Thread.Sleep(10000);
}
catch (Exception ex)
{
if (myTransaction != null)
{
myTransaction.Abort();
}
throw new Exception("WCF - Unbekannter Fehler", ex);
}
}
catch (Exception ex)
{
ExceptionPolicy.HandleException(ex, "Policy");
Thread.Sleep(10000);
break;
}
}
}
}, _JgOpt, ctDatenabfrage, TaskCreationOptions.LongRunning);
task.Start();
}