GCHR/Control/Tasks/Export.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using GCHR.Mandantenschnittstelle;
using GCHR.Model;
using GCHR.Model.Konto;

namespace GCHR.Control.Tasks
{
    sealed class Export : Task
    {
        private List<HaendlerKonto> _konten;
        private readonly IMandant _mandant;

        private readonly string _debugExportFile;

        public Export(int id, string name)
            : base(id, name) 
        {
            _mandant = MandantRegistrieren();
            HaendlerKonto.Mandant = _mandant;
            _debugExportFile = Config.AktuellePeriode.ProtokollDatei;
        }

        private const String DebugHeader =
            "Konto_Nr_Hersteller;Konto_Bezeichnung;Konto_Nr_Haendler;Konto_Typ;Marke_Haendler;Betrieb_Haendler;Soll;Haben;Summe";


        private IMandant MandantRegistrieren()
        {
            switch (Config.Mandantenname)
            {
                case Mandanten.Citroen:
                    return new Citroen();
                case Mandanten.Fiat:
                    return new Fiat();
                case Mandanten.Ford:
                    return new Ford();
                case Mandanten.Honda:
                    return new Honda();
                case Mandanten.Opel:
                    return new Opel();
                case Mandanten.Peugeot:
                    return new Peugeot();
                case Mandanten.Renault:
                    return new Renault();
                case Mandanten.Volkswagen:
                    return new Volkswagen();
                case Mandanten.Volvo:
                    return new Volvo();
            }
            return null;
        }

        /// <summary>
        /// Wartet auf das Eintreffen der manuellen Konten und startet dann den Export von Balance, Accounts und Debug, 
        /// falls entsprechende Dateiangaben gesetzt sind.
        /// </summary>
        protected override void AufgabeAusfuehren()
        {
            ReportProgress(5);
            _konten = Data.GetKonten();
            
            if (_mandant.BalanceDatei)
            {
                var balanceStream = DateiStream(Config.AktuellePeriode.BalanceDatei);
                ReportProgress(20);

                balanceStream.WriteLine(_mandant.BalanceHeader);

                foreach (var kto in _konten.Where(k => (k.Summe != 0.0m)))
                {
                    var zeile = _mandant.BalanceBody(kto);
                    if (zeile.Length > 0)
                    {
                        balanceStream.WriteLine(zeile);
                    }
                }
                balanceStream.Write(_mandant.BalanceFooter);
                balanceStream.Close();
            }

            ReportProgress(40);

            if (_mandant.AccountsDatei)
            {
                var accountsStream = DateiStream(Config.AktuellePeriode.AccountsDatei);
                ReportProgress(60);

                accountsStream.WriteLine(_mandant.AccountsHeader);
                foreach (var kto in _konten.Where(k => (k.Summe != 0.0m)))
                {
                    accountsStream.WriteLine(_mandant.AccountsBody(kto));
                }
                accountsStream.Write(_mandant.AccountsFooter);
                accountsStream.Close();
            }

            if (!_debugExportFile.Equals(""))
            {
                var debugStream = DateiStream(_debugExportFile);
                ReportProgress(80);

                var liste = new List<string>();
                foreach (var kto in _konten)
                {
                    liste.AddRange(kto.KontoCsv);
                }
                liste.Sort();

                debugStream.WriteLine(DebugHeader);
                liste.ForEach(debugStream.WriteLine);
                debugStream.Close();
            }

            var summeSusa = String.Format("{0:c}", _konten.Sum(k => (k.KontoTyp == KontoTypen.SuSa) ? k.Summe : 0.0m));
            var summeOhneFaktor = String.Format("{0:c}", _konten.Sum(k => (k.KontoTyp == KontoTypen.SuSa) ? k.Summe : 0.0m));
            var summeBilanz = String.Format("{0:c}", _konten.Sum(k => (k.Kontoart == "1") ? k.Summe : 0.0m));

            Logger.Progress("Export-Summe über alle SuSa-Konten: " + summeSusa);
            Logger.Progress("Export-Summe ohne Faktoren: " + summeOhneFaktor);
            Logger.Progress("Export-Summe über alle Bilanz-Konten: " + summeBilanz);

            var zero = String.Format("{0:c}", 0);

            if (!summeSusa.Equals(zero) && !summeOhneFaktor.Equals(zero))
            {
                ReportProgress(80, "Der Export war erfolgreich" + Environment.NewLine +
                                          "ACHTUNG SuSa Abweichung im Export!" + Environment.NewLine +
                                          "Export-Summe über alle SuSa-Konten: " + summeSusa);
            }

            ReportProgress(100);
        }

        private static StreamWriter DateiStream (string datei)
        {
            var info = new FileInfo(datei);
            if (info.Directory != null) info.Directory.Create();
            return new StreamWriter(info.FullName, false, Constants.CsvEncoding);
        }
    }
}