GCHR/Main.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using GCHR.Control;
using GCHR.Control.Tasks;
using GCHR.Model;
using GCHR.View;

namespace GCHR
{
    public partial class Main
    {
        private TaskManager _aufgabenListe;

        private List<string> _historie; 

        //private readonly List<Periode> _periodenListe = new List<Periode>();

        private bool ImportdatenSichern
        {
            get { return (BtnImportdatenSichern.IsChecked != null) && (bool) BtnImportdatenSichern.IsChecked; }
        }

        private bool Offlinemodus
        {
            get { return (BtnOffline.IsChecked != null) && (bool)BtnOffline.IsChecked; }
        }

        private bool Exportprotokoll
        {
            get { return false; }
        }

        private bool KeinJahresabschluss
        {
            get { return (BtnKeinJahresabschluss.IsChecked != null) && (bool)BtnKeinJahresabschluss.IsChecked; }
        }

        public Main()
        {
            InitializeComponent();
        }

        private void WindowLoaded(object sender, RoutedEventArgs e)
        {
            var config = Konfiguration.CreateInstance(Constants.ConfigDatei);
            Historie();
            AktuellenMonatEinstellen();
            Kopfzeile.Content = config.Haendler + " - " + config.HaendlernummerBmCode + " - " + config.Mandantenname;
        }

        private void AktuellenMonatEinstellen()
        {
            Jahrbox.Items.Clear();
            for (var i = 2012; i <= DateTime.Today.Year; i++)
            {
                Jahrbox.Items.Add(i);
            }

            var aktPeriode = AktuellenMonatBestimmen();

            Monatsbox.SelectedIndex = Int32.Parse(aktPeriode.Monat) - 1;
            Jahrbox.SelectedValue = Int32.Parse(aktPeriode.Jahr);
        }

        private void Historie()
        {
            _historie = Logger.Historie();
            _historie.Reverse();
            LvPerioden.ItemsSource = _historie;
        }

        private Periode AktuellenMonatBestimmen()
        {
            var vormonat = new Periode(DateTime.Today.Year, DateTime.Today.Month).Vorgaenger;
            if (_historie.Count == 0) return vormonat;

            var match = Regex.Match(_historie[0], @"(\d{2})/(\d{4})$");
            if (!match.Success) return vormonat;

            var aktMonat = new Periode(match.Groups[2].Value + match.Groups[1].Value); 
            var letzteFuenfTage = File.GetLastWriteTime(aktMonat.BalanceDatei).AddDays(5).CompareTo(DateTime.Now) >= 0;
            if (!File.Exists(aktMonat.BalanceDatei) || letzteFuenfTage) return aktMonat;
            return aktMonat.Nachfolger;
        }

        private void BtnStartenClick(object sender, RoutedEventArgs e)
        {
            BtnStarten.IsEnabled = false;

            AufgabenListeErstellen();
            AmpelnRegistrieren();
            _aufgabenListe.TryRunNextWorker();
        }

        private string PeriodeAusAuswahl()
        {
            var monat = (Monatsbox.SelectedIndex + 1).ToString(CultureInfo.InvariantCulture).PadLeft(2, '0');
            return Jahrbox.Text + monat;
        }

        private void AufgabenListeErstellen()
        {
            _aufgabenListe = new TaskManager
                                 {
                                     Data =
                                         {
                                             ImportdatenSichern = ImportdatenSichern,
                                             Offlinemodus = Offlinemodus,
                                             Exportprotokoll = Exportprotokoll,
                                             KeinJahresabschluss = KeinJahresabschluss
                                         }
                                 };
            _aufgabenListe.CreateTasks(Ablaufsteuerung, new Periode(PeriodeAusAuswahl(), KeinJahresabschluss));
        }

        private void AmpelnRegistrieren()
        {
            var ampeln = new[]
                             {
                                 AmpelKontenrahmenLaden, AmpelÜbersetzungstabelleLaden,
                                 AmpelÜbersetzungstabelleStatLaden,
                                 AmpelManuelleLaden, AmpelSuSaKontenImport, AmpelStatKontenImport,
                                 AmpelSuSaKontenVerarbeitung,
                                 AmpelManuelleKontenVerarbeitung, AmpelExport
                             };

            _aufgabenListe.RegisterAmpeln(ampeln);
        }

        private void Ablaufsteuerung(object s, RunWorkerCompletedEventArgs e)
        {
            var aktuellerWorker = (BackgroundWorker)s;
            var aktuelleAufgabe = _aufgabenListe.GetAufgabeByWorker(aktuellerWorker);

            if (e.Error != null)
            {
                BtnStarten.IsEnabled = true;
            }
            else
            {
                if (aktuelleAufgabe.ID == 3 && AmpelManuelleLaden.Done)
                {
                    var manuelleKonten = _aufgabenListe.Data.GetManuelleKonten();
                    if (manuelleKonten.Count == 0)
                    {
                        _aufgabenListe.Data.AufManuelleKontenWarten.Set();
                    }
                    else
                    {
                        var mkb = new ManuelleKontenBearbeiten(manuelleKonten);
                        mkb.Closed += ManuelleKontenBearbeitenClosed;
                        mkb.Show();
                    }
                }

                if (aktuelleAufgabe.ID == 8)
                {
                    BtnStarten.IsEnabled = true;
                    BtnProtokoll.Visibility = Visibility.Visible;
                    Historie();
                    Logger.Progress(DateTime.Now + " Prozess beendet.");
                    Logger.Progress("------------------------------------");
                    Logger.Progress("");
                }
            }
        }

        private void ManuelleKontenBearbeitenClosed(object sender, EventArgs e)
        {
            var mkb = (ManuelleKontenBearbeiten)sender;
            _aufgabenListe.Data.SetManuelleKonten(mkb.ManuelleKonten);
            _aufgabenListe.Data.AufManuelleKontenWarten.Set();                
        }


        #region Events für Checkboxen

        private void BtnOfflineChecked(object sender, RoutedEventArgs e)
        {
            var chk = sender as CheckBox;
            BtnImportdatenSichern.IsChecked = false;
            if (chk != null && chk.IsChecked != null) BtnImportdatenSichern.IsEnabled = !(bool)chk.IsChecked;
        }

        private void BtnImportdatenSichernChecked(object sender, RoutedEventArgs e)
        {
            BtnOffline.IsChecked = false;
            BtnOffline.Visibility = Visibility.Hidden;
        }

        private void BtnImportdatenSichernUnchecked(object sender, RoutedEventArgs e)
        {
            BtnOffline.Visibility = Visibility.Visible;
        }

        #endregion

        private void BtnProtokollClick(object sender, RoutedEventArgs e)
        {
            var dateiInfo = new FileInfo(Logger.ExportLog);
            if (dateiInfo.Directory == null) return;
            ProzessStarten("explorer.exe", dateiInfo.Directory.ToString());
        }

        private void LvPeriodenDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var match = Regex.Match(_historie[LvPerioden.SelectedIndex], @"(\d{2})/(\d{4})$");
            var log = new Periode(match.Groups[2].Value + match.Groups[1].Value).LogDatei;
            ProzessStarten("notepad.exe", log);
        }

        private static void ProzessStarten(string programm, string parameter)
        {
            var psi = new ProcessStartInfo(programm, parameter)
                {
                    RedirectStandardOutput = true,
                    WindowStyle = ProcessWindowStyle.Normal,
                    UseShellExecute = false
                };
            Process.Start(psi);
        }
    }
}