GCHR/Control/ThreadXData.cs

using System;
using System.Collections.Generic;
using System.Threading;
using GCHR.Model.Konto;

namespace GCHR.Control
{
    public class ThreadXData
    {
        #region Singleton
        private static ThreadXData _instance;

        public static ThreadXData GetInstance()
        {
            return _instance ?? (_instance = new ThreadXData());
        }

        public static ThreadXData CreateInstance()
        {
            _instance = new ThreadXData();
            return _instance;
        }

        private ThreadXData()
        {
        }
        #endregion

        public AutoResetEvent AufSusaStatWarten = new AutoResetEvent(false);
        public AutoResetEvent AufManuelleKontenWarten = new AutoResetEvent(false);

        private List<HaendlerKonto> _konten = new List<HaendlerKonto>();
        private List<HaendlerKonto> _manuelleKonten = new List<HaendlerKonto>();

        private DepartmentCase _departmentCase;

        public bool Offlinemodus;
        public bool ImportdatenSichern;
        public bool Exportprotokoll;
        public bool KeinJahresabschluss;
        public bool KontoOhneUebersetzungUebernehmen;

        private Dictionary<String, String[]> _kontenrahmen = new Dictionary<string,string[]>();
        private Dictionary<String, String> _uebersetzungSuSa = new Dictionary<string,string>();
        private Dictionary<String, String> _uebersetzungStat = new Dictionary<string,string>();

        public List<HaendlerKonto> GetKonten()
        {
            lock (_konten)
            {
                _konten.Sort((k1, k2) => String.Compare(k1.ToString(), k2.ToString(), StringComparison.Ordinal));
                return _konten;
            }
        }

        public void SetKonten(List<HaendlerKonto> konten)
        {
            lock (this)
            {
                _konten = konten;
            }
        }

        public List<HaendlerKonto> GetManuelleKonten()
        {
            lock (_manuelleKonten)
            {
                return _manuelleKonten;
            }
        }

        public void AddKonten(IList<HaendlerKonto> konten)
        {
            lock (_konten)
            {
                _konten.AddRange(konten);
            }
        }

        public void SetManuelleKonten(List<HaendlerKonto> konten)
        {
            lock (_manuelleKonten)
            {
                _manuelleKonten = konten;
            }
        }

        public void SetKontenrahmen(Dictionary<string, string[]> kontenrahmen)
        {
            lock (_kontenrahmen)
            {
                _kontenrahmen = kontenrahmen;
            }
        }

        public bool KontenrahmenTryGetValue(string kontonummer, out string[] kontoDescriptionCase)
        {
            lock (_kontenrahmen)
            {
                return _kontenrahmen.TryGetValue(kontonummer, out kontoDescriptionCase);
            }
        }

        public bool AddManStatKonto(HaendlerKonto konto)
        {
            lock (_manuelleKonten)
            {
                if (!_kontenrahmen.ContainsKey(konto.Kontonummer))
                {
                    if (!_kontenrahmen.ContainsKey(konto.ToString())) return false;
                    konto.Bezeichnung = _kontenrahmen[konto.ToString()][0];
                    konto.Case = _kontenrahmen[konto.ToString()][1];
                    konto.Ebene1 = _kontenrahmen[konto.ToString()][2];
                }
                else
                {
                    konto.Bezeichnung = _kontenrahmen[konto.Kontonummer][0];
                    konto.Case = _kontenrahmen[konto.Kontonummer][1];
                    konto.Ebene1 = _kontenrahmen[konto.Kontonummer][2];
                }
                _departmentCase.DepartmentUmwandeln(konto);
                _manuelleKonten.Add(konto);
                return true;
            }
        }

        public string KontoUebersetzen(HaendlerKonto aktKonto)
        {
            if (aktKonto.KontoTyp == KontoTypen.SuSa && _uebersetzungSuSa.ContainsKey(aktKonto.Kontonummer))
            {
                return _uebersetzungSuSa[aktKonto.Kontonummer];
            }
            if (aktKonto.KontoTyp == KontoTypen.Stat && _uebersetzungStat.ContainsKey(aktKonto.Kontonummer))
            {
                return _uebersetzungStat[aktKonto.Kontonummer];
            }
            if (KontoOhneUebersetzungUebernehmen)
            {
                return aktKonto.Kontonummer;
            }
            return null;
        }

        public void SetUebersetzungSuSa(Dictionary<string, string> dictionary)
        {
            lock (_uebersetzungSuSa)
            {
                _uebersetzungSuSa = dictionary;
            }
        }

        public void SetUebersetzungStat(Dictionary<string, string> dictionary)
        {
            lock (_uebersetzungStat)
            {
                _uebersetzungStat = dictionary;
            }
        }

        public void SetDepartmentCase(DepartmentCase departmentCase)
        {
            _departmentCase = departmentCase;
        }

        public HaendlerKonto KontoAusKontenrahmen(string kontonummer, HaendlerKonto child)
        {
            if (!_kontenrahmen.ContainsKey(kontonummer))
                return null;

            var konto = new HaendlerKonto(child.KontoTyp)
            {
                Kontonummer = kontonummer,
                Bezeichnung = _kontenrahmen[kontonummer][0],
                Case = _kontenrahmen[kontonummer][1],
                Ebene1 = _kontenrahmen[kontonummer][2],
                Kontoart = child.Kontoart,
                DepartmentImport = child.DepartmentImport,
                Marke = child.Marke,
                Betrieb = child.Betrieb
            };
            _departmentCase.DepartmentUmwandeln(konto);
            return konto;
        }
    }
}