GCHR/Model/Konfiguration.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text.RegularExpressions;
using System.Windows;
using GCHR.Control;
using GCHR.Control.IO;
using GCHR.Mandantenschnittstelle;
using GCHR.Model.Konto;

namespace GCHR.Model
{
    public class Konfiguration
    {
        #region Singleton

        private static Konfiguration _instance;

        public static Konfiguration CreateInstance(string cfgDatei, string kontenDatei)
        {
            return _instance ?? (_instance = new Konfiguration(cfgDatei, kontenDatei));
        }

        public static Konfiguration GetInstance()
        {
            if (_instance == null)
            {
                throw new NullReferenceException("Konfiguration nicht initialisiert!");
            }
            return _instance;
        }

        #endregion

        private readonly GchrConfig _gchrConfig;
        private readonly Konten _konten;
        private readonly string _configDatei;
        private readonly string _kontenDatei;

        public Konfiguration(string cfgDatei, string kontenDatei)
        {
            _configDatei = cfgDatei;
            _gchrConfig = (GchrConfig)new GchrConfigIO(_configDatei).Laden();

            _kontenDatei = kontenDatei;
            _konten = (Konten) new KontenIO(_kontenDatei).Laden();
            KontenXmlUmsortieren();
        }

        private void KontenXmlUmsortieren()
        {
            if (_konten.Kontenliste.Count > 0 || _gchrConfig.Konten == null || _gchrConfig.Konten.Count == 0) return;

            foreach (var kto in _gchrConfig.Konten)
            {
                if (kto.Periode != null && kto.Periode.Count == 0) kto.Periode = null;

                if (kto.Periode == null) continue;
                kto.ZugeordneteSaldi = kto.Periode;
                kto.Periode = null;
            }
            _konten.Kontenliste = _gchrConfig.Konten;
            _gchrConfig.Konten = null;
            Speichern();
        }

        public void Speichern()
        {
            ManuelleKontenSpeichern();
            new GchrConfigIO(_configDatei).Speichern(_gchrConfig);
        }

        public void ManuelleKontenSpeichern()
        {
            new KontenIO(_kontenDatei).Speichern(_konten);
        }


        public string Händlernummer
        {
            get
            {
                return _gchrConfig.Einstellungen.Haendlernummer;
            }
        }
        public string Hauptmarke
        {
            get
            {
                return _gchrConfig.Einstellungen.Hauptmarke;
            }
        }
        public string Hauptbetrieb
        {
            get
            {
                return _gchrConfig.Einstellungen.Hauptbetrieb;
            }
        }

        public string BilanzMarke
        {
            get
            {
                return _gchrConfig.Einstellungen.BilanzMarke;
            }
        }

        public string BilanzBetrieb
        {
            get
            {
                return _gchrConfig.Einstellungen.BilanzBetrieb;
            }
        }

        public string Eurodatanummer
        {
            get
            {
                if (_gchrConfig.Einstellungen.Eurodatanummer == null)
                {
                    _gchrConfig.Einstellungen.Eurodatanummer = "00000000";
                    Logger.Info("Eurodatanummer wurde bisher noch nicht festgelegt. Bitte in config.xml anpassen!");
                }
                return _gchrConfig.Einstellungen.Eurodatanummer.PadLeft(8, '0');
            }
        }
        public string Geschaeftsjahr
        {
            get
            {
                return _gchrConfig.Einstellungen.Geschaeftsjahr;
            }
        }
        public int HerstellerKontenrahmenZiffern
        {
            get
            {
                return _gchrConfig.Einstellungen.Herstellerkontenrahmen;

            }
        }
        public int HaendlerKontenrahmenZiffern
        {
            get
            {
                return _gchrConfig.Einstellungen.Haendlerkontenrahmen;
            }
        }
        public string SuSaKontenQuery
        {
            get
            {
                return QueryAnpassen(Constants.Decrypt(_gchrConfig.Einstellungen.Abfragen.SuSaKontenQuery));
            }
        }
        public string StatKontenQuery
        {
            get
            {
                return QueryAnpassen(Constants.Decrypt(_gchrConfig.Einstellungen.Abfragen.StatKontenQuery));
            }
        }

        public Mandanten Mandantenname
        {
            get
            {
                return _gchrConfig.Einstellungen.Mandantenname;
            }
        }

        public bool KontoOhneUebersetzungUebernehmen 
        {
            get
            {
                return _gchrConfig.Einstellungen.KontoOhneUebersetzungUebernehmen;
            }
        }

        private String DepartmentFilter
        {
            get
            {
                return "'?'";
            }
        }

        public void DateiVonServerHolen(string dateiName)
        {
            try
            {
                return;
                var dateiTyp = _gchrConfig.Einstellungen.Steuerungsdateien.Typ;
                var dateiPfad = _gchrConfig.Einstellungen.Steuerungsdateien.Pfad;

                if (dateiPfad.Equals("")) return;

                if (!dateiPfad.EndsWith("/"))
                {
                    dateiPfad += "/";
                }

                if (dateiTyp.Equals("http"))
                {
                    var web = new WebClient();
                    web.DownloadFile(dateiPfad + dateiName, "data\\" + dateiName);
                }
                else if (dateiTyp.Equals("verzeichnis"))
                {
                    File.Copy(dateiPfad + dateiName, "data\\" + dateiName);
                }
            }
            catch (Exception e)
            {
                var message = string.Format("Beim Laden der Datei '{0}' ist ein Fehler aufgetreten.", dateiName);
                MessageBox.Show(message, "Fehler");
                Logger.Info(message);
                Logger.Info(e.Message);
            }
        }

        public string JuengstenVormonatBestimmen(string aktPeriode)
        {
            return Array.Find(VorhandenePerioden(), eintrag => String.CompareOrdinal(eintrag, aktPeriode) < 0) ?? aktPeriode;
        }

        private string[] VorhandenePerioden()
        {
            var vorhandenePerioden = (from HaendlerKonto konto in _konten.Kontenliste
                                      select konto.ZugeordneteSaldi
                                      into perioden
                                      from Saldo p in perioden
                                      select p.Periode).Distinct().ToArray();

            Array.Sort(vorhandenePerioden);
            Array.Reverse(vorhandenePerioden);
            return vorhandenePerioden;
        }

        public string OdbcConnectionString
        {
            get
            {
                return
                    (string.Format("DSN={0};UID={1};PWD={2};", _gchrConfig.Einstellungen.Odbc,
                                   Constants.Decrypt(_gchrConfig.Einstellungen.OdbcUsername),
                                   Constants.Decrypt(_gchrConfig.Einstellungen.OdbcPassword)));
            }
        }

        private string MarkeUebersetzen(string marke)
        {
            var suchergebnis = _gchrConfig.Einstellungen.DepartmentUebersetzung.Where(eintrag => eintrag.Von.Equals(marke)).ToArray();

            if (!suchergebnis.Any()) return marke;
            var uebersetzung = suchergebnis.First();
            return uebersetzung.Nach;
        }

        private string BetriebUebersetzen(string betrieb)
        {
            // Funktionen sind derzeit noch identisch
            return MarkeUebersetzen(betrieb);
        }

        public void DepartmentAnpassen(HaendlerKonto konto)
        {
            konto.Betrieb = BetriebUebersetzen(BetriebNormalisieren(BetriebExtrahieren(konto.DepartmentImport)));
            konto.Marke = MarkeUebersetzen(MarkeNormalisieren(MarkeExtrahieren(konto.DepartmentImport)));
        }

        private string BetriebNormalisieren(string betrieb)
        {
            return (betrieb.Length > Hauptbetrieb.Length)
                       ? betrieb.Substring(0, Hauptbetrieb.Length)
                       : betrieb.PadLeft(Hauptbetrieb.Length, '0');
        }

        private string MarkeNormalisieren(string marke)
        {
            return (marke.Length > Hauptmarke.Length)
                       ? marke.Substring(0, Hauptmarke.Length)
                       : marke.PadLeft(Hauptmarke.Length, '0');
        }

        private string BetriebExtrahieren(string department)
        {
            return (department.Length >= Hauptbetrieb.Length) 
                       ? department.Substring(0, Hauptbetrieb.Length) 
                       : department;
        }

        private string MarkeExtrahieren(string department)
        {
            return (department.Length > Hauptbetrieb.Length) 
                       ? department.Substring(Hauptbetrieb.Length) 
                       : "";
        }

        private string QueryAnpassen(string queryStr)
        {
            queryStr = Regex.Replace(queryStr, @"\<datenbank\>", "");

            queryStr = Regex.Replace(queryStr, @"\<period[e]?\>", HaendlerKonto.AktuellePeriode.ToString());
            queryStr = Regex.Replace(queryStr, @"\<jahresbeginn\>", HaendlerKonto.AktuellePeriode.Jahresbeginn(Geschaeftsjahr).ToString());
            queryStr = Regex.Replace(queryStr, @"\<bilanzbeginn\>", HaendlerKonto.AktuellePeriode.Bilanzbeginn(Geschaeftsjahr).ToString());

            return Regex.Replace(queryStr, @"\<department_filter\>", DepartmentFilter);
        }

        internal string HaendlerKontonummerFormatieren(string kontonummer)
        {
            return kontonummer.PadLeft(HaendlerKontenrahmenZiffern, '0');
        }

        public HaendlerKonto ManuellesKontoSuchen(string kontonummer)
        {
            var konten = (from HaendlerKonto kto in _konten.Kontenliste
                          where (kto.Kontonummer.Equals(kontonummer)
                                 || kto.ToString().Equals(kontonummer))
                          select kto).ToList();
            return (konten.Count > 0) ? konten.First() : HaendlerKonto.ManStatNeu(kontonummer);
        }

        public void ManuelleKontenSetzen(List<HaendlerKonto> manKonten)
        {
            _konten.Kontenliste = manKonten;
            ManuelleKontenSpeichern();
        }

        public string BalanceDatei
        {
            get
            {
                return string.Format(_gchrConfig.Dateipfade.BalanceDatei, HaendlerKonto.AktuellePeriode.Jahr, HaendlerKonto.AktuellePeriode.Monat);
            }
        }

        public string AccountsDatei
        {
            get
            {
                return string.Format(_gchrConfig.Dateipfade.AccountsDatei, HaendlerKonto.AktuellePeriode.Jahr, HaendlerKonto.AktuellePeriode.Monat);
            }
        }

        public string LogDatei
        {
            get
            {
                var datei = string.Format(_gchrConfig.Dateipfade.LogDatei, HaendlerKonto.AktuellePeriode.Jahr, HaendlerKonto.AktuellePeriode.Monat);
                var info = new FileInfo(datei);
                if (info.Directory != null) info.Directory.Create();
                return datei;
            }
        }

        public string ProtokollDatei
        {
            get
            {
                return string.Format(_gchrConfig.Dateipfade.ProtokollDatei, HaendlerKonto.AktuellePeriode.Jahr, HaendlerKonto.AktuellePeriode.Monat);
            }
        }
    }
}