GCHR/Model/Konto/HaendlerKonto.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Controls;
using System.Windows.Input;
using System.Xml.Serialization;
using GCHR.Model.Mandant;

namespace GCHR.Model.Konto
{
    [XmlRoot("Konto")]
    public class HaendlerKonto : IKonto
    {
        private static int _markeLength = 1;
        private static int _betriebLength = 2;
        private static IMandant _mandant = new Csv();

        public static Periode AktuellePeriode = new Periode("200001");


        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);
            //ClickMeCommand = new RoutedCommand(SaldoAusAuswahl);
        }

        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; }

        [XmlIgnore]
        public string KontonummerFormatiert
        {
            get { return Mandant.KontonummerFormatieren(this); }
        }

        [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()
        {
            if (KontoTyp == KontoTypen.ManStat)
                return Marke + Betrieb + Kontonummer;

            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) => String.Compare(k1.Kontonummer, k2.Kontonummer, StringComparison.Ordinal));
            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) => String.Compare(s1.Periode, s2.Periode, StringComparison.Ordinal));
        }

        [XmlIgnore]
        public List<string> KontoCsv
        {
            get
            {
                if (ZugeordneteKonten.Count > 0)
                {
                    var csv = "'" + KontonummerFormatiert + ";" +
                              Bezeichnung + ";";

                    return ZugeordneteKonten.FindAll(kto => kto.Summe != 0).Select(kto => csv + kto.KontoCsv[0]).ToList();
                }

                if (KontoTyp == KontoTypen.ManStat)
                {
                    return new List<string>
                    {
                        string.Format("'{0};{8};;{1}{2};;'{3};'{4};{5:0.00};{6:0.00};{7:0.00}", KontonummerFormatiert,
                                      KontoTypKuerzel(KontoTyp), Minus, Marke, Betrieb, Soll, Haben, Summe, Bezeichnung)
                    };
                }

                return new List<string>
                    {
                        string.Format("'{0};{1}{2};{8};'{3};'{4};{5:0.00};{6:0.00};{7:0.00}", Kontonummer,
                                      KontoTypKuerzel(KontoTyp), Minus, Marke, Betrieb, Soll, Haben, Summe, Kontoart)
                    };
            }
        }

        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());
                return (saldo != null) ? saldo.Soll.ToString(Constants.Zahlenformat) : (0m).ToString(Constants.Zahlenformat);
            }
            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); }
        }

        public decimal Monatssumme(int monatAbJahresbeginn)
        {
            var periode = AktuellePeriode.MonatDesJahres(monatAbJahresbeginn);
            return Monatssumme(periode);
        }

        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 Eroeffnungsbilanz
        {
            get
            {
                if (ZugeordneteSaldi.Count > 0)
                {
                    return
                        ZugeordneteSaldi.Sum(s => (String.Compare(s.Periode, AktuellePeriode.Jahresbeginn.ToString(), StringComparison.Ordinal) < 0) ? s.Summe : 0m);
                }
                return (ZugeordneteKonten.Count > 0) ? ZugeordneteKonten.Sum(k => k.Eroeffnungsbilanz) : 0m;
            }
        }

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

        public string Kontoart { get; set; }

        internal static IMandant Mandant
        {
            get { return _mandant; }
            set { _mandant = value; }
        }

        internal void SaldoAusVormonat()
        {
            if (SaldoSuchen(AktuellePeriode.ToString()) != null) return;
            Saldo = (ZugeordneteSaldi.Count == 0) ? "0" : ZugeordneteSaldi.Last().Soll.ToString(Constants.Zahlenformat);
        }

        //public ICommand ClickMeCommand { get; set; }

        public void SaldoAusAuswahl(object sender)
        {
            Saldo = ((TextBox)sender).Text;
        }
    }
}