Beispiel #1
0
        private void BtnExporteren_Click(object sender, RoutedEventArgs e)
        {
            var datName = Properties.Settings.Default.NameXmlDatei;

            if (string.IsNullOrWhiteSpace(datName))
            {
                datName = Environment.GetFolderPath(Environment.SpecialFolder.CommonDocuments) + @"\JgArbeitszeit.xml";
            }

            var fo = new SaveFileDialog()
            {
                Title            = "Xml Datei speichern",
                FileName         = Path.GetFileName(datName),
                InitialDirectory = Path.GetDirectoryName(datName),
                Filter           = "Xml Files | *.xml | Alle Dateien | *.*",
            };

            if (fo.ShowDialog() ?? false)
            {
                var lBediener = _Erstellung.ListeBediener.Daten.Where(w => (w.EArbeitszeitHelper != null) && (w.EArbeitszeitHelper.Status == EnumStatusArbeitszeitAuswertung.Fertig)).ToList();

                var listeAuswertungen = new List <ArbeitszeitBediener>();
                foreach (var bedAusw in lBediener)
                {
                    var ds = new ArbeitszeitBediener(_Db, _AzRunden);
                    ds.BedienerBerechnen(bedAusw, _Erstellung.Jahr, _Erstellung.Monat, _Erstellung.SollStundenMonat, _Erstellung.ListeFeiertageMonat, _Erstellung.ListePausen.Daten);
                    listeAuswertungen.Add(ds);
                }
                ;

                var en            = new CultureInfo("en-US", false);
                var formatDezimal = Properties.Settings.Default.FormatXmlAusgabeDezimal;
                var formatZeit    = Properties.Settings.Default.FormatXmlAusgabeZeit;

                XDocument xDoc = new XDocument(
                    new XComment($"Arbeitszeit Monat: {_Erstellung.Monat}.{_Erstellung.Jahr} Datum: {DateTime.Now.ToString("dd.MM.yy HH:mm")}"),
                    new XElement("Root",
                                 new XElement("Monat", $"{(JgZeit.Monate)_Erstellung.Monat} {_Erstellung.Jahr.ToString()}"),

                                 from z in listeAuswertungen
                                 let azMonat = z.AuswertungMonat.AzAuswertung
                                               let normalStunden = JgZeit.StringInZeit(azMonat.SollStunden) - (new TimeSpan(8 * (azMonat.Urlaub + azMonat.Krank + azMonat.Feiertage), 0, 0))
                                                                   let istStunden = JgZeit.ZeitStringAddieren(azMonat.SollStunden, azMonat.Ueberstunden)
                                                                                    select new XElement("Datensatz",
                                                                                                        new XElement("Mitarbeiter", z.Bediener.Name),
                                                                                                        new XElement("Nachname", z.Bediener.NachName),
                                                                                                        new XElement("Vorname", z.Bediener.VorName),
                                                                                                        new XElement("IdBuchhaltung", z.Bediener.IdBuchhaltung),

                                                                                                        new XElement("Standort", z.Bediener.eStandort.Bezeichnung),
                                                                                                        new XElement("Zahltag", z.Bediener.AuszahlungGehalt),
                                                                                                        new XElement("Urlaubstage", z.Bediener.Urlaubstage),

                                                                                                        // Formatierung als Dezimalzahl mit einer Kommastelle mit Frau Glatter besprochen

                                                                                                        new XElement("IstStunden", istStunden.TotalHours.ToString(formatDezimal, en)),
                                                                                                        new XElement("Normalstunden", normalStunden.TotalHours.ToString(formatDezimal, en)),
                                                                                                        new XElement("SollStunden", JgZeit.StringInZeit(azMonat.SollStunden).TotalHours.ToString(formatDezimal, en)),

                                                                                                        new XElement("UeberStunden", JgZeit.StringInZeit(azMonat.Ueberstunden).TotalHours.ToString(formatDezimal, en)),
                                                                                                        new XElement("UeberstundenAusgezahlt", JgZeit.StringInZeit(azMonat.AuszahlungUeberstunden).TotalHours.ToString(formatDezimal, en)),
                                                                                                        new XElement("UeberstundenGesamt", z.AuswertungGesamt.fUeberstunden.TotalHours.ToString(formatDezimal, en)),

                                                                                                        new XElement("Urlaub", (azMonat.Urlaub * 8).ToString(formatDezimal, en)),
                                                                                                        new XElement("UrlaubstageOffen", z.AuswertungMonat.UrlaubOffenAnzeige),

                                                                                                        new XElement("Krank", (azMonat.Krank * 8).ToString(formatDezimal, en)),
                                                                                                        new XElement("Feiertage", (azMonat.Feiertage * 8).ToString(formatDezimal, en)),

                                                                                                        new XElement("NachtschichtZuschlag", JgZeit.StringInZeit(azMonat.NachtschichtZuschlaege).TotalHours.ToString(formatDezimal, en)),
                                                                                                        new XElement("NachtschichtZuschlagGerundet", azMonat.NachtschichtZuschlaegeGerundet.TotalHours.ToString(formatDezimal, en)),
                                                                                                        new XElement("FeiertagsZuschlag", JgZeit.StringInZeit(azMonat.FeiertagZuschlaege).TotalHours.ToString(formatDezimal, en)),
                                                                                                        new XElement("FeiertagsZuschlagGerundet", azMonat.FeiertagZuschlaegeGerundet.TotalHours.ToString(formatDezimal, en)),


                                                                                                        // Ausgabe als Zeit

                                                                                                        new XElement("IstStundenD", XmlZeitInString(istStunden, formatZeit)),
                                                                                                        new XElement("NormalstundenD", XmlZeitInString(normalStunden, formatZeit)),
                                                                                                        new XElement("SollStundenD", XmlZeitInString(JgZeit.StringInZeit(azMonat.SollStunden), formatZeit)),

                                                                                                        new XElement("UeberStundenD", XmlZeitInString(JgZeit.StringInZeit(azMonat.Ueberstunden), formatZeit)),
                                                                                                        new XElement("UeberstundenAusgezahltD", XmlZeitInString(JgZeit.StringInZeit(azMonat.AuszahlungUeberstunden), formatZeit)),
                                                                                                        new XElement("UeberstundenGesamtD", XmlZeitInString(z.AuswertungGesamt.fUeberstunden, formatZeit)),


                                                                                                        new XElement("UrlaubD", XmlZeitInString(new TimeSpan(azMonat.Urlaub * 8, 0, 0), formatZeit)),
                                                                                                        new XElement("UrlaubstageOffenD", XmlZeitInString(new TimeSpan(z.AuswertungMonat.UrlaubOffenAnzeige * 8, 0, 0), formatZeit)),

                                                                                                        new XElement("KrankD", XmlZeitInString(new TimeSpan(azMonat.Krank * 8), formatZeit)),
                                                                                                        new XElement("FeiertageD", XmlZeitInString(new TimeSpan(azMonat.Feiertage * 8), formatZeit)),

                                                                                                        new XElement("NachtschichtZuschlagD", XmlZeitInString(JgZeit.StringInZeit(azMonat.NachtschichtZuschlaege), formatZeit)),
                                                                                                        new XElement("NachtschichtZuschlagGerundetD", XmlZeitInString(azMonat.NachtschichtZuschlaegeGerundet, formatZeit)),
                                                                                                        new XElement("FeiertagsZuschlagD", XmlZeitInString(JgZeit.StringInZeit(azMonat.FeiertagZuschlaege), formatZeit)),
                                                                                                        new XElement("FeiertagsZuschlagGerundetD", XmlZeitInString(azMonat.FeiertagZuschlaegeGerundet, formatZeit))
                                                                                                        )
                                 )
                    );

                try
                {
                    xDoc.Save(fo.FileName);
                }
                catch (Exception f)
                {
                    var msg = $"Datei konnte nicht erstellt werden.\nGrund: {f.Message}";
                    MessageBox.Show(msg, "Fehlermeldung", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                if (Properties.Settings.Default.NameXmlDatei != fo.FileName)
                {
                    Properties.Settings.Default.NameXmlDatei = fo.FileName;
                }

                foreach (var bed in lBediener)
                {
                    bed.EArbeitszeitHelper.StatusAnzeige = EnumStatusArbeitszeitAuswertung.Erledigt;
                }

                _Erstellung.Db.SaveChanges();

                Helper.InfoBox($"{lBediener.Count} Mitarbeiter in Datei gespeichert !", Helper.ProtokollArt.Info);
            }
        }
Beispiel #2
0
        private void BtnDrucken_Click(object sender, RoutedEventArgs e)
        {
            _Report.Clear();
            var vorgang = Convert.ToInt32((sender as Button).Tag);  // 1 - Anzeigen, 2 - Drucken, 3 - Design, 4 - Neuer Report, 5 - Report Exportieren, 6 - Löschen

            var auswahl = EnumFilterAuswertung.Arbeitszeit;

            if (tcArbeitszeit.SelectedIndex == 1)
            {
                auswahl = EnumFilterAuswertung.ArbeitszeitAuswertung;
            }

            if (vorgang != 4)
            {
                switch (auswahl)
                {
                case EnumFilterAuswertung.Arbeitszeit: _AktuellerReport = _ListeReporteArbeitszeiten.Current; break;

                case EnumFilterAuswertung.ArbeitszeitAuswertung: _AktuellerReport = _ListeReporteAuswertung.Current; break;
                }

                if (_AktuellerReport == null)
                {
                    MessageBox.Show("Es wurde kein Report ausgewählt.", "Fehler !", MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }

                switch (vorgang)
                {
                case 0:     // Reportname ändern
                    var formNeu = new Fenster.FormReportName(_AktuellerReport.ReportName);
                    if (formNeu.ShowDialog() ?? false)
                    {
                        _AktuellerReport.AnzeigeReportname = formNeu.ReportName;
                        _ListeReporteArbeitszeiten.DsSave();
                    }
                    return;

                case 5:     // Exportieren
                    SaveFileDialog dia = new SaveFileDialog()
                    {
                        FileName    = _AktuellerReport.ReportName,
                        Filter      = "Fastreport (*.frx)|*.frx|Alle Dateien (*.*)|*.*",
                        FilterIndex = 1
                    };
                    if (dia.ShowDialog() ?? false)
                    {
                        _Report.Save(dia.FileName);
                        MemoryStream mem;
                        mem = new MemoryStream(_AktuellerReport.Report);
                        using (Stream f = File.Create(dia.FileName))
                        {
                            mem.CopyTo(f);
                        }
                    }
                    return;

                case 6:      // Report löschen
                    var mb = MessageBox.Show($"Report {_AktuellerReport.ReportName} löschen ?", "Löschabfrage", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.None);
                    if (mb == MessageBoxResult.Yes)
                    {
                        _AktuellerReport.DatenAbgleich.Geloescht = true;
                        switch (auswahl)
                        {
                        case EnumFilterAuswertung.Arbeitszeit: _ListeReporteArbeitszeiten.Remove(_AktuellerReport); break;

                        case EnumFilterAuswertung.ArbeitszeitAuswertung: _ListeReporteAuswertung.Remove(_AktuellerReport); break;
                        }
                    }
                    return;
                }

                if (_AktuellerReport.Report == null)
                {
                    vorgang = 3;
                }
                else
                {
                    var mem = new MemoryStream(_AktuellerReport.Report);
                    _Report.Load(mem);
                }
            }

            switch (auswahl)
            {
            case EnumFilterAuswertung.Arbeitszeit:
                var bediener = _ListeArbeitszeitenAuswahl.Daten.Select(s => s.eBediener).Distinct().ToList();
                _Report.RegisterData(bediener.Select(s => new { s.Id, s.Name }).ToList(), "Bediener");

                var dat         = _DzArbeitszeitBis.AnzeigeDatumZeit;
                var db          = _ListeArbeitszeitenAuswahl.Db;
                var sollStunden = JgZeit.StringInZeit(db.tabSollStundenSet.FirstOrDefault(w => (w.Jahr == dat.Year) && (w.Monat == dat.Month) && !w.DatenAbgleich.Geloescht).SollStunden, TimeSpan.Zero);
                var lFeiertage  = db.tabFeiertageSet.Where(w => (w.Datum.Year == dat.Year) && (w.Datum.Month == dat.Month) && !w.DatenAbgleich.Geloescht).ToList();
                var lPausen     = db.tabPausenzeitSet.Where(w => !w.DatenAbgleich.Geloescht).ToList();

                var listeAuswertungen = new List <ArbeitszeitBediener>();

                foreach (var bedAusw in bediener)
                {
                    var ds = new ArbeitszeitBediener(_Erstellung.Db, _AzRunden);
                    ds.BedienerBerechnen(bedAusw, (short)dat.Year, (byte)dat.Month, sollStunden, lFeiertage, lPausen);
                    listeAuswertungen.Add(ds);
                }
                _Report.RegisterData(listeAuswertungen, "Auswertungen");

                _Report.RegisterData(_ListeArbeitszeitenAuswahl.Daten, "Stechzeiten");
                _Report.SetParameterValue("Zeitraum.DatumVon", _DzArbeitszeitVon.AnzeigeDatumZeit);
                _Report.SetParameterValue("Zeitraum.DatumBis", _DzArbeitszeitBis.AnzeigeDatumZeit);
                break;

            case EnumFilterAuswertung.ArbeitszeitAuswertung:
                var aktStandort = _Erstellung.AktuellerBediener.eStandort;

                var bedienerImStandort = _Erstellung.ListeBediener.Daten.Where(w => w.fStandort == aktStandort.Id).ToList();
                var listeAuswertung    = new List <ArbeitszeitBediener>();

                foreach (var bedAusw in bedienerImStandort)
                {
                    var ds = new ArbeitszeitBediener(_Erstellung.Db, _AzRunden);
                    ds.BedienerBerechnen(bedAusw, _Erstellung.Jahr, _Erstellung.Monat, _Erstellung.SollStundenMonat, _Erstellung.ListeFeiertageMonat, _Erstellung.ListePausen.Daten);
                    listeAuswertung.Add(ds);
                }

                _Report.RegisterData(bedienerImStandort.Select(s => new { s.Id, s.Name }).ToList(), "Bediener");
                _Report.RegisterData(listeAuswertung, "ListeAuswertung");
                _Report.SetParameterValue("Auswertung.Monat", (JgZeitHelper.JgZeit.Monate)_Erstellung.Monat);
                _Report.SetParameterValue("Auswertung.Jahr", _Erstellung.Jahr);
                break;

            default:
                break;
            }

            if (vorgang == 4) // Neuer Report
            {
                var repName = "";

                var formNeu = new Fenster.FormReportName();
                if (!formNeu.ShowDialog() ?? false)
                {
                    return;
                }
                repName = formNeu.ReportName;

                string username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                _AktuellerReport = new tabAuswertung()
                {
                    Id = Guid.NewGuid(),
                    FilterAuswertung = auswahl,
                    ReportName       = repName,
                    ErstelltDatum    = DateTime.Now,
                    ErstelltName     = username,
                    GeaendertDatum   = DateTime.Now,
                    GeaendertName    = username,
                };

                switch (auswahl)
                {
                case EnumFilterAuswertung.Arbeitszeit: _ListeReporteArbeitszeiten.Add(_AktuellerReport); break;

                case EnumFilterAuswertung.ArbeitszeitAuswertung: _ListeReporteAuswertung.Add(_AktuellerReport); break;
                }

                _Report.Design();
            }

            else
            {
                switch (vorgang)
                {
                case 1:
                    try
                    {
                        _Report.Show();
                    }
                    catch (Exception ex)
                    {
                        Helper.InfoBox("Fehler beim Aufruf der Auswertung", ex);
                    }
                    break;

                case 2:
                    try
                    {
                        _Report.Print();
                    }
                    catch (Exception ex)
                    {
                        Helper.InfoBox("Fehler beim Drucken der Auswertung", ex);
                    }
                    break;

                case 3:
                    try
                    {
                        _Report.Design();
                    }
                    catch { }
                    break;
                }
            }
        }