GCHR/Model/Konto/HaendlerKonto.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Serialization;

namespace GCHR.Model.Konto
{
    [XmlRoot("Konto")]
    public class HaendlerKonto : IKonto
    {
        internal static Periode AktuellePeriode = new Periode("200001");

        private static int _markeLength = 1;
        private static int _betriebLength = 2;


        public HaendlerKonto()
            : this(KontoTypen.ManStat)
        {
        }

        public HaendlerKonto(KontoTypen typ)
        {
            KontoTyp = typ;
            if (typ != KontoTypen.Debug) return;
            Marke = new string('0', _markeLength);
            Betrieb = new string('0', _betriebLength);
        }

        public static HaendlerKonto ManStatNeu(string kontonummer)
        {
            var kto = new HaendlerKonto(KontoTypen.ManStat) {DepartmentImport = "000", Kontonummer = kontonummer};
            return kto;
        }

        #region KontoXml-Umwandlung

        [XmlAttribute("kontonummer")]
        public string KontonummerAlt
        {
            set { Kontonummer = value; }
            get { return null; }
        }

        [XmlElement("periode")]
        public List<Saldo> Periode;

        #endregion


        [XmlAttribute("Konto_Nr")]
        public string Kontonummer { get; set; }

        [XmlAttribute("Konto_Bezeichnung")]
        public string Bezeichnung { get; set; }

        [XmlAttribute("Konto_Typ")]
        public KontoTypen KontoTyp { get; set; }

        [XmlIgnore]
        public string DepartmentImport { get; set; }

        [XmlAttribute("Konto_Marke")]
        public string Marke { get; set; }

        [XmlAttribute("Konto_Betrieb")]
        public string Betrieb { get; set; }

        [XmlAttribute("Ebene1")]
        public string Ebene1 { get; set; }

        [XmlAttribute("Konto_Case")]
        public string Case { get; set; }

        [XmlIgnore]
        public decimal Faktor { get { return (Case != null && Case.Contains("-")) ? -1m : 1m; } }

        [XmlAttribute("Soll")]
        public decimal Soll 
        {
            get
            {
                return (KontoTyp == KontoTypen.ManStat)
                           ? SaldoVon(AktuellePeriode.ToString())
                           : Math.Round(
                               Faktor*
                               (_soll + ZugeordneteKonten.Sum(kto => kto.Soll) +
                                ZugeordneteSaldi.Sum(saldo => saldo.Soll)), 2);
            }
            set
            {
                _soll = value;
            }
        }
        private decimal _soll;

        [XmlAttribute("Haben")]
        public decimal Haben
        {
            get
            {
                return (KontoTyp == KontoTypen.ManStat)
                           ? 0m
                           : Math.Round(
                               Faktor*
                               (_haben + ZugeordneteKonten.Sum(kto => kto.Haben) +
                                ZugeordneteSaldi.Sum(saldo => saldo.Haben)), 2);
            }
            set
            {
                _haben = value;
            }
        }
        private decimal _haben;

        [XmlIgnore]
        public decimal Summe
        {
            get
            {
                if (KontoTyp == KontoTypen.Debug) return 0m;
                return Soll + Haben;
            }
        }

        [XmlIgnore]
        public decimal SummeOhneFaktor
        {
            get
            {
                return (KontoTyp == KontoTypen.ManStat)
                           ? 0m
                           : Math.Round(
                               (_soll + _haben) + ZugeordneteKonten.Sum(kto => (kto.SummeOhneFaktor)) +
                               ZugeordneteSaldi.Sum(saldo => (saldo.Soll + saldo.Haben)), 2);
            }
        }

        public override string ToString()
        {
            return Marke + Betrieb + Kontonummer;
        }


        [XmlElement("Konto")]
        public List<HaendlerKonto> ZugeordneteKonten = new List<HaendlerKonto>();

        public bool KontoZuordnen(HaendlerKonto kto)
        {
            if (KontoTyp != KontoTypen.Debug && KontoTyp != kto.KontoTyp) return false;
            ZugeordneteKonten.Add(kto);
            ZugeordneteKonten.Sort((k1, k2) => k1.Kontonummer.CompareTo(k2.Kontonummer));
            return true;
        }

        [XmlElement("Saldo")]
        public List<Saldo> ZugeordneteSaldi = new List<Saldo>();

        public void SaldoZuordnen(string periode, Decimal soll, Decimal haben)
        {
            ZugeordneteSaldi.Add(new Saldo { Periode = periode, Soll = soll, Haben = haben });
            ZugeordneteSaldi.Sort((s1, s2) => s1.Periode.CompareTo(s2.Periode));
        }

        [XmlIgnore]
        public List<string> KontoCsv
        {
            get
            {
                if (ZugeordneteKonten.Count > 0)
                {
                    var liste = new List<string>();
                    var csv = Kontonummer + ";" +
                              Marke + ";" +
                              Betrieb;

                    foreach (var kto in ZugeordneteKonten)
                    {
                        liste.Add(kto.KontoCsv[0] + ";" + csv);
                    }
                    return liste;
                }

                return new List<string>
                           {
                               Kontonummer + ";" +
                               KontoTypKuerzel(KontoTyp) + Minus + ";" +
                               Marke + ";" +
                               Betrieb
                           };
            }
        }

        private string Minus { get { return (Faktor < 0) ? "-" : ""; } }

        private string KontoTypKuerzel(KontoTypen kontoTyp)
        {
            switch(kontoTyp)
            {
                case KontoTypen.SuSa:
                    return "A";
                case KontoTypen.Stat:
                    return "Q";
                case KontoTypen.ManStat:
                    return "M";
                case KontoTypen.Debug:
                    return "D";
            }
            return "?";
        }

        public string DebugInfo()
        {
            return String.Format("{0} (Typ: {1}, Summe: {2}, Anzahl Perioden: {3})",
                                    Kontonummer, KontoTyp, Summe, ZugeordneteSaldi.Count);
        }

        private decimal SaldoVon(string periode)
        {
            var saldo = SaldoSuchen(periode);
            return (saldo != null) ? saldo.Soll : 0m;
        }

        private Saldo SaldoSuchen(string periode)
        {
            var saldi = (from saldo in ZugeordneteSaldi
                                 where saldo.Periode.Equals(periode)
                                 select saldo).ToList();
            return (saldi.Count > 0) ? saldi.First() : null;
        }

        [XmlIgnore]
        public string Saldo
        {
            get 
            {
                var saldo = SaldoSuchen(AktuellePeriode.ToString());
                if (saldo != null)
                    return saldo.Soll.ToString(Constants.Zahlenformat);
                SaldoZuordnen(AktuellePeriode.ToString(), Decimal.Parse(Vormonat1, Constants.Zahlenformat), 0m);
                return Vormonat1;
            }
            set
            {
                var saldo = SaldoSuchen(AktuellePeriode.ToString());
                if (saldo != null)
                    saldo.Soll = Decimal.Parse(value, Constants.Zahlenformat);
                else
                    SaldoZuordnen(AktuellePeriode.ToString(), Decimal.Parse(value, Constants.Zahlenformat), 0m);
            }
        }

        [XmlIgnore]
        public string Vormonat1
        {
            get { return SaldoVon(AktuellePeriode.Vormonat(1)).ToString(Constants.Zahlenformat); }
        }

        [XmlIgnore]
        public string Vormonat2
        {
            get { return SaldoVon(AktuellePeriode.Vormonat(2)).ToString(Constants.Zahlenformat); }
        }

        [XmlIgnore]
        public string Vormonat3
        {
            get { return SaldoVon(AktuellePeriode.Vormonat(3)).ToString(Constants.Zahlenformat); }
        }

        [XmlIgnore]
        public string Vormonat4
        {
            get { return SaldoVon(AktuellePeriode.Vormonat(4)).ToString(Constants.Zahlenformat); }
        }

        [XmlIgnore]
        public string Vormonat5
        {
            get { return SaldoVon(AktuellePeriode.Vormonat(5)).ToString(Constants.Zahlenformat); }
        }

        private decimal Monatssumme (string periode)
        {
            if (ZugeordneteSaldi.Count > 0)
            {
                return ZugeordneteSaldi.Sum(s => (s.Periode.Equals(periode)) ? s.Summe : 0m);
            }
            return (ZugeordneteKonten.Count > 0) ? ZugeordneteKonten.Sum(k => k.Monatssumme(periode)) : 0m;
        }

        public decimal SummeAktuellePeriode { get { return Monatssumme(AktuellePeriode.ToString()); } }
    }
}