GCHR/Model/Konfiguration.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
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)
        {
            return _instance ?? (_instance = new Konfiguration(cfgDatei));
        }

        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;

        public Konfiguration(string cfgDatei)
        {
            _configDatei = cfgDatei;
            _gchrConfig = (GchrConfig)new GchrConfigIO(_configDatei).Laden();
            _konten = (Konten) new KontenIO(_gchrConfig.Dateipfade.ManuelleKonten).Laden();
            KontenXmlUmsortieren();
            Periode.Dateipfade = _gchrConfig.Dateipfade;
            Periode.ErsterMonatImGeschaeftsjahr = _gchrConfig.Einstellungen.Geschaeftsjahr;
        }

        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(_gchrConfig.Dateipfade.ManuelleKonten).Speichern(_konten);
        }

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


        public string Haendlernummer
        {
            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 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]?\>", Periode.AktuellePeriode.ToString());
            queryStr = Regex.Replace(queryStr, @"\<jahresbeginn\>", Periode.AktuellePeriode.Jahresbeginn.ToString());
            queryStr = Regex.Replace(queryStr, @"\<bilanzbeginn\>", Periode.AktuellePeriode.Bilanzbeginn.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 UebersetzungStat
        {
            get { return _gchrConfig.Dateipfade.UebersetzungStat; }
        }

        public string UebersetzungSusa
        {
            get { return _gchrConfig.Dateipfade.UebersetzungSusa; }
        }

        public string Kontenrahmen
        {
            get { return _gchrConfig.Dateipfade.Kontenrahmen; }
        }

        public string ManuelleKonten
        {
            get { return _gchrConfig.Dateipfade.ManuelleKonten; }
        }

        public string Importdaten
        {
            get { return _gchrConfig.Dateipfade.Importdaten; }
        }

        public string Webservice { get { return _gchrConfig.Webservice + ((_gchrConfig.Webservice.EndsWith("/")) ? "" : "/") + "?valid=1&gchr=1"; } }

        public bool WebserviceAktiv
        {
            get { return (!string.IsNullOrEmpty(_gchrConfig.Webservice)); }
        }
    }
}