GCHR/Control/Tasks/Datenimport.cs

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Data.Odbc;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using GCHR.Model;
using GCHR.Model.Konto;

namespace GCHR.Control.Tasks
{
    class Datenimport : Task
    {
        public static Datenimport DatenimportSuSa(int id, string name)
        {
            return new Datenimport(id, name) {_kontoTyp = KontoTypen.SuSa};
        }

        public static Datenimport DatenimportStat(int id, string name)
        {
            return new Datenimport(id, name) {_kontoTyp = KontoTypen.Stat};
        }

        private Datenimport(int id, string name)
            : base(id, name) { }



        private KontoTypen _kontoTyp;
        private string QueryStr
        {
            get { return (_kontoTyp == KontoTypen.SuSa) ? Config.SuSaKontenQuery : Config.StatKontenQuery; }
        }
                


        protected override void AufgabeAusfuehren()
        {
            if (_kontoTyp == KontoTypen.Stat && !Config.StatKontenImportieren) return;
            var import = Importieren();
            if (Data.ImportdatenSichern)
            {
                ImportdatenSichern(import);
            }
            var konten = ImportInKontenUmwandeln(import);
            ReportProgress(80);
            if (_kontoTyp == KontoTypen.SuSa)
            {
                var saldo = konten.Sum(konto => konto.Summe);
                SummeSaldiPruefen(saldo);
                Data.JahresergebnisKonto.SaldoZuordnen(HaendlerKonto.AktuellePeriode.Jahresbeginn.Vorgaenger.ToString(), saldo * -1, 0);
            }
            Data.AddKonten(konten);
        }

        private IList<string> Importieren()
        {
            if (Data.Offlinemodus && File.Exists(Dateiname))
            {
                return File.ReadAllLines(Dateiname).ToList();
            }
            return (Config.WebserviceAktiv) ? KontenVonWebserviceLaden() : KontenVonOdbcLaden();
        }

        private IList<string> KontenVonWebserviceLaden()
        {
            var args = new NameValueCollection
                {
                    { "dsn", "odbc:" + Config.OdbcConnectionString },
                    { "query", QueryStr }
                };

            using (var web = new WebClient())
            {
                web.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
                var responsebytes = web.UploadValues(Config.Webservice, "POST", args);
                return Encoding.Default.GetString(responsebytes).Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries).ToList();
            }
        }

        private IList<string> KontenVonOdbcLaden()
        {
            var result = new List<string>();
            using (var con = new OdbcConnection(Config.OdbcConnectionString))
            {
                con.ConnectionTimeout = 300;
                con.Open();
                var query = new OdbcCommand(QueryStr, con) {CommandTimeout = 300};
                var reader = query.ExecuteReader();

                while (reader.Read())
                {
                    var zeile = reader.GetString(0).Trim();
                    for (var i = 1; i < reader.FieldCount; i++)
                    {
                        zeile += ";" + reader.GetString(i).Trim();
                    }
                    result.Add(zeile);
                }
                reader.Close();
                con.Close();
            }

            return result;
        }

        private void ImportdatenSichern(IEnumerable<string> import)
        {
            using (var sw = new StreamWriter(Dateiname, false, Constants.CsvEncoding))
            {
                sw.WriteLine(string.Join(Environment.NewLine, import.ToArray()));
            }
        }

        private string Dateiname
        {
            get { return String.Format(Config.Importdaten, Config.AktuellePeriode, _kontoTyp); }
        }


        private IList<HaendlerKonto> ImportInKontenUmwandeln(IList<string> import)
        {
            if (import == null || !import.Any())
            {
                ReportProgress(90, "Die Abfrage '" + _kontoTyp + "' lieferte keine Ergebnisse.");
                return new List<HaendlerKonto>();
            }


            try
            {
                return (from tempZeile in import
                        select tempZeile.Split(';')
                        into feld
                        group feld by (feld[0] + ";" + feld[3])
                        into kontoSaldi
                        select NeuesKonto(kontoSaldi.ToList())).ToList();
            }
            catch (IndexOutOfRangeException ex)
            {
                Logger.Info("Fehler in der Abfrage '" + _kontoTyp + "':" + ex.Message);
                if (import.Count() > 10)
                {
                    Logger.Info("Erste Zeile: " + import[0]);
                }
                else
                {
                    Logger.Info("Import: " + Environment.NewLine + string.Join(Environment.NewLine, import.ToArray()));
                    
                }
                ReportProgress(90, "Fehler in der Abfrage '" + _kontoTyp + "':" + Environment.NewLine + "Erste Zeile: " + import[0]);
                return new List<HaendlerKonto>();
            }
        }

        private void SummeSaldiPruefen(Decimal summe)
        {
            var summeString = String.Format(Constants.Zahlenformat, "{0:c}", summe);
            Logger.Progress("Summe über alle SuSa-Konten: " + summeString);

            if (summe != 0.0m)
            {
                ReportProgress(75, "Beim Import der SuSa-Konten trat ein Fehler auf." + Environment.NewLine +
                                          "Die Summe über alle SuSa-Konten ist " + summeString);
            }
        }

        private HaendlerKonto NeuesKonto(IList<string[]> kontoSaldi)
        {
            var neuesKonto = new HaendlerKonto(_kontoTyp);
            var feld = kontoSaldi.First();

            neuesKonto.Kontonummer = Config.HaendlerKontonummerFormatieren(feld[0].Trim());
            neuesKonto.DepartmentImport = feld[3].Trim();
            Config.DepartmentAnpassen(neuesKonto);

            if (PeriodeMitgeliefert(feld))
            {
                foreach (var saldo in kontoSaldi)
                {
                    neuesKonto.SaldoZuordnen(saldo[4].Substring(0,6), ToDecimal(saldo[1]), ToDecimal(saldo[2]));
                }
            }
            else
            {
                neuesKonto.Soll = (from saldo in kontoSaldi
                                    select ToDecimal(saldo[1])).Sum();
                neuesKonto.Haben = (from saldo in kontoSaldi
                                     select ToDecimal(saldo[2])).Sum();
            }

            if (KontoartMitgeliefert(feld))
            {
                neuesKonto.Kontoart = feld[5];
            }

            if (BezeichnungMitgeliefert(feld))
            {
                neuesKonto.Bezeichnung = feld[6];
            }
            return neuesKonto;
        }

        private static Decimal ToDecimal(string feld)
        {
            return Decimal.Parse(feld, Constants.ZahlenformatImport);
        }

        private static bool PeriodeMitgeliefert(IEnumerable<string> feld)
        {
            return feld.Count() > 4;
        }

        private static bool KontoartMitgeliefert(IEnumerable<string> feld)
        {
            return feld.Count() > 5;
        }

        private static bool BezeichnungMitgeliefert(IEnumerable<string> feld)
        {
            return feld.Count() > 6;
        }
    }
}