public static void DatenAusDatenbankLaden(OptionenArbeitszeit Optionen)
{
string msg;
try
{
using (var Db = new JgModelContainer())
{
if (Optionen.VerbindungsString != "")
{
Db.Database.Connection.ConnectionString = Optionen.VerbindungsString;
}
msg = $"Datenbank öffnen -> {Db.Database.Connection.ConnectionString}";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Information);
Optionen.ListeTerminals = Db.tabArbeitszeitTerminalSet.Where(w => !w.DatenAbgleich.Geloescht).Include(i => i.eStandort).ToList();
msg = $"{Optionen.ListeTerminals.Count} Terminals aus DB eingelesen";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
if (Optionen.ErsterDurchlauf)
{
Optionen.ErsterDurchlauf = false;
var anzFehlerNichtNull = Optionen.ListeTerminals.Where(w => w.AnzahlFehler > 0).ToList();
if (anzFehlerNichtNull.Count > 0)
{
foreach (var nn in anzFehlerNichtNull)
{
nn.AnzahlFehler = 0;
}
Db.SaveChanges();
}
}
Optionen.UpdateBenutzerAusfuehren = (Optionen.ListeTerminals.Any(w => w.UpdateTerminal));
if (Optionen.UpdateBenutzerAusfuehren)
{
Optionen.ListeBediener = Db.tabBedienerSet.Where(w => (w.Status != EnumStatusBediener.Stillgelegt) && (!w.DatenAbgleich.Geloescht)).ToList();
msg = $"{Optionen.ListeBediener.Count} Bediener für Update Terminal aus DB eingelesen";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
}
}
msg = $"Daten aus Datenbank erfolgreich geladen.";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Information);
}
catch (Exception f)
{
msg = $"Fehler beim Laden der Daten aus der Datenbank.";
throw new MyException(msg, f);
}
}
private void RibbonWindow_Loaded(object sender, RoutedEventArgs e)
{
_Db = new JgModelContainer();
if (Properties.Settings.Default.DatenbankVerbindungsString != "")
{
_Db.Database.Connection.ConnectionString = Properties.Settings.Default.DatenbankVerbindungsString;
}
_Auswertungen = new JgEntityList <tabAuswertung>(_Db)
{
ViewSource = (CollectionViewSource)FindResource("vsAuswertung"),
Tabellen = new DataGrid[] { dgAuswertung },
OnDatenLaden = (d, p) =>
{
return(d.tabAuswertungSet.Where(w => w.FilterAuswertung == EnumFilterAuswertung.Allgemein).ToList());
}
};
_Auswertungen.DatenLaden();
_Auswertungen.Daten = _Auswertungen.Daten.OrderBy(o => o.ReportName).ToList();
_Report = new FastReport.Report();
_Report.FileName = "Datenbank";
_ReportSettings.CustomSaveReport += (obj, repEvent) =>
{
MemoryStream memStr = new MemoryStream();
try
{
var ausw = _Auswertungen.Current;
repEvent.Report.Save(memStr);
ausw.Report = memStr.ToArray();
ausw.GeaendertDatum = DateTime.Now;
ausw.GeaendertName = Helper.Benutzer;
_Auswertungen.DsSave(ausw);
}
catch (Exception f)
{
System.Windows.MessageBox.Show("Fehler beim speichern des Reports !\r\nGrund: " + f.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
memStr.Dispose();
}
};
InitCommands();
}
private async void Window_Loaded(object sender, RoutedEventArgs e)
{
_Db = new JgModelContainer();
_Standort = await _Db.tabStandortSet.FirstOrDefaultAsync(f => f.Id == Properties.Settings.Default.IdStandort);
if (_Standort == null)
{
_Standort = await _Db.tabStandortSet.FirstOrDefaultAsync();
}
tblStandort.Text = _Standort.Bezeichnung;
InitListen();
_Report = new FastReport.Report()
{
FileName = "Datenbank"
};
_ReportSettings.CustomSaveReport += (obj, repEvent) =>
{
MemoryStream memStr = new MemoryStream();
try
{
repEvent.Report.Save(memStr);
_Db.tabAuswertungSet.Attach(_AktAuswertung);
_AktAuswertung.Report = memStr.ToArray();
_AktAuswertung.GeaendertDatum = DateTime.Now;
_AktAuswertung.GeaendertName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
_Db.SaveChanges();
}
catch (Exception f)
{
Helper.InfoBox("Fehler beim speichern des Reports!", f);
}
finally
{
memStr.Dispose();
}
};
_TimerAktualisierungTreeView = new DispatcherTimer(new TimeSpan(0, 1, 0), DispatcherPriority.ApplicationIdle, (sen, erg) =>
{
TreeViewMaschinenAktualisieren();
}, Dispatcher.CurrentDispatcher);
}
public void DatenInDatenbankEintragen(List <HandyDaten> ListeDaten)
{
var listeAuswertung = ListeDaten.Select(s => new ArbeitszeitImportDaten()
{
Datum = s.timestamp,
MatchCode = s.userId,
Vorgang = s.isCheckIn ? ArbeitszeitImportDaten.EnumVorgang.Komme : ArbeitszeitImportDaten.EnumVorgang.Gehen,
Baustelle = s.construction
}).ToList();
var msg = "";
try
{
using (var Db = new JgModelContainer())
{
if (!string.IsNullOrWhiteSpace(_ConnectionString))
{
Db.Database.Connection.ConnectionString = _ConnectionString;
}
var azImport = new ArbeitszeitImport();
azImport.ImportStarten(Db, listeAuswertung);
Db.SaveChanges();
msg = $"{azImport.AnzahlAnmeldungen} Handy Anmeldungen in Datenbank gespeichert.\n{azImport.ProtokollOk}";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
if (azImport.ProtokollFehler != null)
{
msg = $"Anmeldungen ohne Benutzerzuordnung.\n{azImport.ProtokollFehler}";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
}
}
}
catch (Exception f)
{
msg = "Fehler beim eintragen der Anmeldedaten in die Datenbank.";
throw new MyException(msg, f);
}
}
public static async Task ListeAktualisieren<T>(JgModelContainer Db, IEnumerable<T> Liste)
where T : class
{
var propId = typeof(T).GetProperty("Id");
var propDateAbleich = typeof(T).GetProperty("DatenAbgleich");
var dicDs = new SortedDictionary<Guid, T>();
foreach (var ds in Liste)
dicDs.Add((Guid)propId.GetValue(ds), ds);
// geänderte Datensätze aktualisieren, Wenn mehr als 500 Datensätze dann keine Aktualisierung
if ((dicDs.Count != 0) && (dicDs.Count < 2000))
{
var sbAbfrageText = new StringBuilder();
foreach (var ds in dicDs)
sbAbfrageText.AppendLine($" ('{ds.Key.ToString()}','{(propDateAbleich.GetValue(ds.Value) as DatenAbgleich).Datum.ToString("dd.MM.yyyy HH:mm:ss")}'),");
var sqlText = "IF OBJECT_ID(N'tempdb..#TempDs', N'U') IS NOT NULL DROP TABLE #TempDs \n"
+ "CREATE TABLE #TempDs (Id uniqueidentifier NOT NULL, Datum char(19) NOT NULL) \n"
+ "INSERT INTO #TempDs VALUES \n"
+ sbAbfrageText.ToString().Substring(0, sbAbfrageText.ToString().Length - 3) + "\n"
+ "SELECT Id FROM #TempDs as t \n"
+ " WHERE EXISTS(SELECT * FROM " + typeof(T).Name + "Set WHERE (Id = t.Id) AND (FORMAT(DatenAbgleich_Datum , 'dd/MM/yyyy HH:mm:ss') <> t.Datum))";
var idisAendern = new List<Guid>();
var sc = Db.Database.Connection.ConnectionString;
using (var con = new SqlConnection(sc))
{
await con.OpenAsync();
var cl = new SqlCommand(sqlText, con);
using (var reader = await cl.ExecuteReaderAsync())
{
while (reader.Read())
idisAendern.Add((Guid)reader[0]);
}
}
foreach (var ds in idisAendern)
await Db.Entry<T>(dicDs[ds]).ReloadAsync();
}
}
public void Init(JgModelContainer Db, ArbeitszeitRunden AzRunden)
{
_Db = Db;
_AzRunden = AzRunden;
}
public ArbeitszeitBediener(JgModelContainer Db, ArbeitszeitRunden AzRunden)
{
Init(Db, AzRunden);
}
private async void HelperReparaturAnmeldungen(JgModelContainer d, IEnumerable <tabReparatur> dat)
{
await JgList.ListeAktualisieren <tabAnmeldungReparatur>(d, dat.SelectMany(s => s.sAnmeldungen).ToList());
}
public MaschineSchnell(JgModelContainer Db, string StartPfad)
{
_Db = Db;
_StartPfad = StartPfad;
}
public void ImportStarten(JgModelContainer Db, List <ArbeitszeitImportDaten> NeuListeArbeitszeiten)
{
var lArbeitzeiten = from z in NeuListeArbeitszeiten
group z by z.MatchCode into erg
select new { MatchCode = erg.Key, Anmeldungen = erg.OrderBy(o => o.Datum) };
var listeMatchCodes = lArbeitzeiten.Select(s => s.MatchCode).ToArray();
var listeBediener = Db.tabBedienerSet.Where(w => listeMatchCodes.Contains(w.MatchCode))
.Include(i => i.eAktivArbeitszeit)
.ToDictionary(t => t.MatchCode, t => t);
var listeStandorte = Db.tabStandortSet.ToDictionary(t => t.Id, t => t);
foreach (var mc in lArbeitzeiten)
{
var bediener = listeBediener[mc.MatchCode];
if (bediener == null)
{
_StringBuilderFehler.AppendLine($" {mc.MatchCode}");
_StringBuilderFehler.AppendLine($" ---------------------------------------------");
foreach (var anm in mc.Anmeldungen)
{
_StringBuilderFehler.AppendLine($" -> {anm.Datum} {anm.Vorgang}");
}
continue;
}
_StringBuilderOk.AppendLine($" {mc.MatchCode} - {bediener.Name}");
_StringBuilderOk.AppendLine($" ---------------------------------------------");
foreach (var anm in mc.Anmeldungen)
{
AnzahlAnmeldungen++;
var standort = listeStandorte[anm.IdStandort ?? bediener.fStandort];
var ss = (standort == null) ? " - " : standort.Bezeichnung;
_StringBuilderOk.AppendLine($" -> {anm.Datum} - {anm.Vorgang} / {ss} ");
if (anm.Vorgang == ArbeitszeitImportDaten.EnumVorgang.Komme)
{
var arbZeit = ArbeitszeitErstellen(bediener.Id, standort.Id, anm.Datum, anm.Baustelle);
Db.tabArbeitszeitSet.Add(arbZeit);
bediener.eAktivArbeitszeit = arbZeit;
}
else if (anm.Vorgang == ArbeitszeitImportDaten.EnumVorgang.Gehen)
{
if (bediener.eAktivArbeitszeit != null)
{
bediener.eAktivArbeitszeit.Abmeldung = anm.Datum;
bediener.eAktivArbeitszeit.ManuelleAbmeldung = false;
bediener.eAktivArbeitszeit = null;
}
else
{
var arbZeit = ArbeitszeitErstellen(bediener.Id, standort.Id, anm.Datum, anm.Baustelle);
Db.tabArbeitszeitSet.Add(arbZeit);
}
}
}
}
}
public DatenKontrolle(JgModelContainer Db)
{
_Db = Db;
_Entity = _Db.Set <T>();
}
public static void ArbeitszeitenInDatenbank(OptionenArbeitszeit Optionen)
{
var msg = "";
try
{
using (var Db = new JgModelContainer())
{
if (Optionen.VerbindungsString != "")
{
Db.Database.Connection.ConnectionString = Optionen.VerbindungsString;
}
msg = "Beginne Eintragungen in Datenbank.";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
if (Optionen.ListeAnmeldungen.Count > 0)
{
var azImport = new ArbeitszeitImport();
azImport.ImportStarten(Db, Optionen.ListeAnmeldungen);
Db.SaveChanges();
msg = $"{azImport.AnzahlAnmeldungen} Anmeldungen erfolgreich in Datenbank gespeichert.\n\n{azImport.ProtokollOk}";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
if (azImport.ProtokollFehler != null)
{
msg = $"Anmeldungen ohne Benutzerzuordnung!\n\n{azImport.ProtokollFehler}";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Warning);
}
}
foreach (var term in Optionen.ListeTerminals)
{
if ((term.TerminaldatenWurdenAktualisiert) ||
(term.FehlerTerminalAusgeloest) ||
((!term.FehlerTerminalAusgeloest) && (term.AnzahlFehler != 0)))
{
Db.tabArbeitszeitTerminalSet.Attach(term);
Db.Entry(term).State = EntityState.Modified;
// Terminals die erfolgreich geUpdatet wurden eintragen
if (term.TerminaldatenWurdenAktualisiert)
{
term.UpdateTerminal = false;
}
// Wenn Fehleranzahl erreicht wurde, Fehler anzeigen und FehlerAnzahl auf 0 setzen
if (term.FehlerTerminalAusgeloest)
{
term.AnzahlFehler = (short)(term.AnzahlFehler + 1);
if (term.AnzahlFehler >= Optionen.AnzahlBisFehlerAusloesen)
{
term.AnzahlFehler = 0;
msg = $"Fehleranzahl Verbindungsaufbau Terminal {term.Bezeichnung} / {term.eStandort.Bezeichnung} größer {Optionen.AnzahlBisFehlerAusloesen}.";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Error);
}
}
else
{
if (term.AnzahlFehler != 0)
{
term.AnzahlFehler = 0;
}
}
msg = $"Terminal {term.Bezeichnung} / {term.eStandort.Bezeichnung} aktualisiert.";
Logger.Write(msg, "Service", 0, 0, TraceEventType.Verbose);
}
}
Db.SaveChanges();
}
}
catch (Exception f)
{
msg = "Fehler beim eintragen der Anmeldedaten in die Datenbank.";
throw new MyException(msg, f);
}
}
/// <summary>
///
/// </summary>
/// <param name="Db"></param>
/// <param name="DatenAnViewSourceBinden">Bei Detailtabellen dürfen die Daten nicht an Viesource gebunden Werden</param>
public JgEntityList(JgModelContainer NeuDb)
{
_Db = NeuDb;
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
this.Title += " - V " + version.ToString();
_Db = new JgModelContainer();
if (Properties.Settings.Default.DatenbankVerbindungsString != "")
{
_Db.Database.Connection.ConnectionString = Properties.Settings.Default.DatenbankVerbindungsString;
}
var heute = DateTime.Now.Date;
_AzRunden = new ArbeitszeitRunden(_Db, heute.Year);
_DzArbeitszeitVon.AnzeigeDatumZeit = heute;
_DzArbeitszeitBis.AnzeigeDatumZeit = new DateTime(heute.Year, heute.Month, heute.Day, 23, 59, 59);
_ListeArbeitszeitenAuswahl = new JgEntityList <tabArbeitszeit>(_Db)
{
ViewSource = (CollectionViewSource)FindResource("vsArbeitszeitAuswahl"),
Tabellen = new DataGrid[] { dgArbeitszeitAuswahl },
OnDatenLaden = (d, p) =>
{
var datVom = (DateTime)p.Params["DatumVon"];
var datBis = (DateTime)p.Params["DatumBis"];
var azRunden = (ArbeitszeitRunden)p.Params["AzRunden"];
var lZeiten = d.tabArbeitszeitSet.Where(w => (((w.Anmeldung >= datVom) && (w.Anmeldung <= datBis)) ||
((w.Anmeldung == null) && (w.Abmeldung >= datVom) && (w.Abmeldung <= datBis))));
if (!p.IstSortiert)
{
lZeiten = lZeiten.OrderBy(o => o.Anmeldung);
}
foreach (var zeit in lZeiten.ToList())
{
zeit.AnmeldungGerundet = azRunden.GetZeitGerundet(EnumZeitpunkt.Anmeldung, zeit.fStandort, zeit.Anmeldung);
zeit.AbmeldungGerundet = azRunden.GetZeitGerundet(EnumZeitpunkt.Abmeldung, zeit.fStandort, zeit.Abmeldung);
}
return(lZeiten);
}
};
_ListeArbeitszeitenAuswahl.Parameter["AzRunden"] = _AzRunden;
_ListeArbeitszeitenAuswahl.Parameter["DatumVon"] = _DzArbeitszeitVon.AnzeigeDatumZeit;
_ListeArbeitszeitenAuswahl.Parameter["DatumBis"] = _DzArbeitszeitBis.AnzeigeDatumZeit;
_ListeArbeitszeitenAuswahl.DatenLaden();
// Report initialisieren ********************************
_ListeReporteArbeitszeiten = new JgEntityList <tabAuswertung>(_Db)
{
ViewSource = (CollectionViewSource)FindResource("vsReporteArbeitszeit"),
OnDatenLaden = (d, p) =>
{
return(_Db.tabAuswertungSet.Where(w => (w.FilterAuswertung == EnumFilterAuswertung.Arbeitszeit) && (!w.DatenAbgleich.Geloescht))
.OrderBy(o => o.ReportName).ToList());
}
};
_ListeReporteArbeitszeiten.DatenLaden();
_ListeReporteAuswertung = new JgEntityList <tabAuswertung>(_ListeReporteArbeitszeiten.Db)
{
ViewSource = (CollectionViewSource)FindResource("vsReporteAuswertung"),
OnDatenLaden = (d, p) =>
{
return(_Db.tabAuswertungSet.Where(w => (w.FilterAuswertung == EnumFilterAuswertung.ArbeitszeitAuswertung) && (!w.DatenAbgleich.Geloescht))
.OrderBy(o => o.ReportName).ToList());
}
};
_ListeReporteAuswertung.DatenLaden();
// Klasse Auswertung intitialisieren
_Erstellung = new AnmeldungAuswertung(_Db, cbJahr, cbMonat,
(CollectionViewSource)FindResource("vsBediener"),
_AzRunden,
(ArbeitszeitBediener)FindResource("ArbeitszeitBediener"),
(CollectionViewSource)FindResource("vsArbeitszeitTage"));
// Report für Auswertung erstellen
_Report = new FastReport.Report()
{
FileName = "Datenbank"
};
_ReportSettings.CustomSaveReport += (obj, repEvent) =>
{
MemoryStream memStr = new MemoryStream();
try
{
repEvent.Report.Save(memStr);
_AktuellerReport.Report = memStr.ToArray();
_AktuellerReport.GeaendertDatum = DateTime.Now;
_AktuellerReport.GeaendertName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
_ListeReporteArbeitszeiten.DsSave(_AktuellerReport);
if (_AktuellerReport.FilterAuswertung == EnumFilterAuswertung.ArbeitszeitAuswertung)
{
_ListeReporteAuswertung.Refresh();
}
else
{
_ListeReporteArbeitszeiten.Refresh();
}
}
catch (Exception f)
{
MessageBox.Show("Fehler beim speichern des Reports !\r\nGrund: " + f.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
memStr.Dispose();
}
};
}
public void Start()
{
string msg = "";
while (true)
{
using (var db = new JgModelContainer())
{
var standort = db.tabStandortSet.FirstOrDefault(w => w.Bezeichnung.ToUpper() == Properties.Settings.Default.Standort);
if (standort == null)
{
msg = $"Standort {Properties.Settings.Default.Standort} nicht gefunden!";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Error);
break;
}
var lMaschinen = db.tabMaschineSet.Where(w => (w.fStandort == standort.Id) && (w.Status != EnumStatusMaschine.Stillgelegt) &&
(w.MaschinenArt != EnumMaschinenArt.Handbiegung) && (w.ProdDatenabfrage)).ToList();
if (lMaschinen.Count == 0)
{
msg = $"Für Standort {standort.Bezeichnung} sind keine Maschinen vorhanden!";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
break;
}
MaschinenStamm maStamm = null;
MaschineEvg maEvg = null;
MaschineSchnell maSchnell = null;
MaschineProgress maProgress = null;
foreach (var maschine in lMaschinen)
{
var pr = maschine.eProtokoll;
pr.AuswertungStart = DateTime.Now;
pr.AnzahlDurchlauf++;
if (!Helper.IstPingOk(maschine.MaschineAdresse, out msg))
{
maschine.eProtokoll.FehlerVerbindungMaschine++;
continue;
}
switch (maschine.MaschinenArt)
{
case EnumMaschinenArt.Evg:
if (maEvg == null)
{
maEvg = new MaschineEvg(db, _Optionen.PfadEvg);
}
maStamm = maEvg;
break;
case EnumMaschinenArt.Progress:
if (maProgress == null)
{
maProgress = new MaschineProgress(db, _Optionen.PfadProgress);
}
maStamm = maProgress;
break;
case EnumMaschinenArt.Schnell:
if (maSchnell == null)
{
maSchnell = new MaschineSchnell(db, _Optionen.PfadSchnell);
}
maStamm = maSchnell;
break;
}
try
{
maStamm.Start(maschine);
}
catch (Exception f)
{
msg = $"Fehler import Daten in Maschine {maschine.MaschinenName}\nGrund: {f.Message}";
maschine.eProtokoll.FehlerDatenImport++;
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Warning);
continue;
}
finally
{
pr.AuswertungEnde = DateTime.Now;
}
try
{
msg = $"Protokoll für Maschine {maschine.MaschinenName} gesichert.";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Verbose);
}
catch (Exception f)
{
msg = $"Fehler beim speichern des Maschinenprotokolls: {maschine.MaschinenName}\nGrund: {f.Message}";
Logger.Write(msg, "Service", 1, 0, System.Diagnostics.TraceEventType.Error);
break;
}
}
}
}
}
public MaschineProgress(JgModelContainer Db, string PfadStart)
{
_Db = Db;
_StartPfad = PfadStart;
}
