using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BeWo.ViewModel
{
    public class CustomerVermittlungArbeitVM : AbstractDCMapperVM<CustomerVermittlungArbeitDC>
    {
        private VgaTypeEnum _VgaType;
        private string _Fallnummer;
        private string _AktenzeichenGericht;
        private string _EigenesAktenzeichen;
        private CompactOrganisationDC _Auftraggeber;
        private CompactPersonDC _AuftraggeberAnsprechpartner;
        private CompactOrganisationDC _Einsatzstelle;
        private CompactPersonDC _EinsatzstelleAnsprechpartner;
        private DateTime? _Auftragseingang;
        private ValueListEntryDC _Auftragsherkunft;
        private ObservableSortCollection<ValueListEntryDC> _Auftragsherkunfte;
        private ValueListEntryDC _Vermittlungsgrundlage;
        private ObservableSortCollection<ValueListEntryDC> _Vermittlungsgrundlagen;
        private decimal? _Tagessatze;
        private decimal? _Tagessatzhohe;
        private decimal? _HoheDerGeldstrafe;
        private decimal? _ZuLeistendeArbeitsstunden;
        private string _Hinweis;
        private DateTime? _Termin;
        private CustomerVermittlungBearbeitungsstatus? _CustomerVermittlungBearbeitungsstatus;
        private DateTime? _Auftragsruckgabe;
        private ObservableSortCollection<ValueListEntryDC> _Verlaeufe;
        private ValueListEntryDC _Verlauf;
        private decimal? _AbgeleisteteStunden;
        private decimal? _ErsparteHafttage;
        private decimal? _GeleisteteRatenzahlung;
        private string _Bemerkung;
        private decimal? _GeleisteteEinmalzahlung;
        private bool _GrundArbeitsunfahig;
        private bool _GrundSuchtproblem;
        private bool _GrundPsychischeProbleme;
        private bool _GrundKeineMotivation;
        private bool _GrundInHaft;
        private bool _GrundUnbekannt;
        private bool _GrundKeinKontakt;
        private bool _GrundNichtAngetreten;
        private bool _GrundAbbruchDerTatigkeit;
        private bool _GrundWiderruf;
        private bool _Grund459StPO;
        private bool _GrundAusbleibenDerZahlung;
        private bool _BesonderheitMehrfacheBeauftragung;
        private bool _BesonderheitMehrfacheVermittlung;
        private bool _BesonderheitVermittlungAusHaft;
        private bool _BesonderheitDurchBGBWAufgesucht;
        
        public CustomerVermittlungArbeitVM()
        {

        }

        public CustomerVermittlungArbeitVM(CustomerVermittlungArbeitDC vermittlung) : base(vermittlung, vermittlung.Oid == null)
        {

        }

        public VgaTypeEnum VgaType
        {
            get { return _VgaType; }
            set
            {
                if (!AreDifferent(_VgaType, value))
                    return;

                _VgaType = value;
                StoreDirtyInformation(AreDifferent(DataContract.VgaType, value), nameof(VgaType));
                FirePropertyChanged(nameof(VgaType));
            }
        }

        public string Displayname => $"AZ: {AktenzeichenGericht}";

        public string Fallnummer
        {
            get { return _Fallnummer; }
            set
            {
                if (!AreDifferent(_Fallnummer, value))
                    return;

                _Fallnummer = value;
                StoreDirtyInformation(AreDifferent(DataContract.Fallnummer, value), nameof(Fallnummer));
                FirePropertyChanged(nameof(Fallnummer));
            }
        }

        public string AktenzeichenGericht
        {
            get { return _AktenzeichenGericht; }
            set
            {
                if (!AreDifferent(_AktenzeichenGericht, value))
                    return;

                _AktenzeichenGericht = value;
                StoreDirtyInformation(AreDifferent(DataContract.AktenzeichenGericht, value), nameof(AktenzeichenGericht));
                FirePropertyChanged(nameof(AktenzeichenGericht));
                FirePropertyChanged(nameof(Displayname));
            }
        }
        public string EigenesAktenzeichen
        {
            get { return _EigenesAktenzeichen; }
            set
            {
                if (!AreDifferent(_EigenesAktenzeichen, value))
                    return;

                _EigenesAktenzeichen = value;
                StoreDirtyInformation(AreDifferent(DataContract.EigenesAktenzeichen, value), nameof(EigenesAktenzeichen));
                FirePropertyChanged(nameof(EigenesAktenzeichen));
            }
        }

        public CompactOrganisationDC Auftraggeber
        {
            get
            {
                return this._Auftraggeber;
            }

            set
            {
                if (this.AreDifferent(this._Auftraggeber, value))
                {
                    this._Auftraggeber = value;
                    this.StoreDirtyInformation(this.AreDifferent(this.DataContract.Auftraggeber, value), nameof(Auftraggeber));
                    this.FirePropertyChanged(nameof(Auftraggeber));
                }
            }
        }

        public CompactPersonDC AuftraggeberAnsprechpartner
        {
            get
            {
                return this._AuftraggeberAnsprechpartner;
            }

            set
            {
                if (this.AreDifferent(this._AuftraggeberAnsprechpartner, value))
                {
                    this._AuftraggeberAnsprechpartner = value;
                    this.StoreDirtyInformation(this.AreDifferent(this.DataContract.AuftraggeberAnsprechpartner, value), nameof(AuftraggeberAnsprechpartner));
                    this.FirePropertyChanged(nameof(AuftraggeberAnsprechpartner));
                }
            }
        }

        public CompactOrganisationDC Einsatzstelle
        {
            get
            {
                return this._Einsatzstelle;
            }

            set
            {
                if (this.AreDifferent(this._Einsatzstelle, value))
                {
                    this._Einsatzstelle = value;
                    this.StoreDirtyInformation(this.AreDifferent(this.DataContract.Einsatzstelle, value), nameof(Einsatzstelle));
                    this.FirePropertyChanged(nameof(Einsatzstelle));
                }
            }
        }

        public CompactPersonDC EinsatzstelleAnsprechpartner
        {
            get
            {
                return this._EinsatzstelleAnsprechpartner;
            }

            set
            {
                if (this.AreDifferent(this._EinsatzstelleAnsprechpartner, value))
                {
                    this._EinsatzstelleAnsprechpartner = value;
                    this.StoreDirtyInformation(this.AreDifferent(this.DataContract.EinsatzstelleAnsprechpartner, value), nameof(EinsatzstelleAnsprechpartner));
                    this.FirePropertyChanged(nameof(EinsatzstelleAnsprechpartner));
                }
            }
        }

        public DateTime? Auftragseingang
        {
            get { return _Auftragseingang; }
            set
            {
                if (!AreDifferent(_Auftragseingang, value))
                    return;

                _Auftragseingang = value;
                StoreDirtyInformation(AreDifferent(DataContract.Auftragseingang, value), nameof(Auftragseingang));
                FirePropertyChanged(nameof(Auftragseingang));
            }
        }
        public ValueListEntryDC Auftragsherkunft
        {
            get { return _Auftragsherkunft; }
            set
            {
                if (!AreDifferent(_Auftragsherkunft, value))
                    return;

                _Auftragsherkunft = value;
                StoreDirtyInformation(AreDifferent(DataContract.Auftragsherkunft, value), nameof(Auftragsherkunft));
                FirePropertyChanged(nameof(Auftragsherkunft));
            }
        }
        public ValueListEntryDC Vermittlungsgrundlage
        {
            get { return _Vermittlungsgrundlage; }
            set
            {
                if (!AreDifferent(_Vermittlungsgrundlage, value))
                    return;

                _Vermittlungsgrundlage = value;
                StoreDirtyInformation(AreDifferent(DataContract.Vermittlungsgrundlage, value), nameof(Vermittlungsgrundlage));
                FirePropertyChanged(nameof(Vermittlungsgrundlage));
            }
        }
        public decimal? Tagessatze
        {
            get { return _Tagessatze; }
            set
            {
                if (!AreDifferent(_Tagessatze, value))
                    return;

                _Tagessatze = value;
                StoreDirtyInformation(AreDifferent(DataContract.Tagessatze, value), nameof(Tagessatze));
                FirePropertyChanged(nameof(Tagessatze));
                UpdateHoheDerGeldstrafe();
            }
        }
        public decimal? Tagessatzhohe
        {
            get { return _Tagessatzhohe; }
            set
            {
                if (!AreDifferent(_Tagessatzhohe, value))
                    return;

                _Tagessatzhohe = value;
                StoreDirtyInformation(AreDifferent(DataContract.Tagessatzhohe, value), nameof(Tagessatzhohe));
                FirePropertyChanged(nameof(Tagessatzhohe));
                UpdateHoheDerGeldstrafe();
            }
        }
        public decimal? HoheDerGeldstrafe
        {
            get { return _HoheDerGeldstrafe; }
            set
            {
                if (!AreDifferent(_HoheDerGeldstrafe, value))
                    return;

                _HoheDerGeldstrafe = value;
                StoreDirtyInformation(AreDifferent(DataContract.HoheDerGeldstrafe, value), nameof(HoheDerGeldstrafe));
                FirePropertyChanged(nameof(HoheDerGeldstrafe));
            }
        }
        public decimal? ZuLeistendeArbeitsstunden
        {
            get { return _ZuLeistendeArbeitsstunden; }
            set
            {
                if (!AreDifferent(_ZuLeistendeArbeitsstunden, value))
                    return;

                _ZuLeistendeArbeitsstunden = value;
                StoreDirtyInformation(AreDifferent(DataContract.ZuLeistendeArbeitsstunden, value), nameof(ZuLeistendeArbeitsstunden));
                FirePropertyChanged(nameof(ZuLeistendeArbeitsstunden));
            }
        }
        public string Hinweis
        {
            get { return _Hinweis; }
            set
            {
                if (!AreDifferent(_Hinweis, value))
                    return;

                _Hinweis = value;
                StoreDirtyInformation(AreDifferent(DataContract.Hinweis, value), nameof(Hinweis));
                FirePropertyChanged(nameof(Hinweis));
            }
        }
        public DateTime? Termin
        {
            get { return _Termin; }
            set
            {
                if (!AreDifferent(_Termin, value))
                    return;

                _Termin = value;
                StoreDirtyInformation(AreDifferent(DataContract.Termin, value), nameof(Termin));
                FirePropertyChanged(nameof(Termin));
            }
        }
        public IEnumerable<CustomerVermittlungBearbeitungsstatus> CustomerVermittlungBearbeitungsstatusTypes => Utils.GetAllEnumValues<CustomerVermittlungBearbeitungsstatus>();
        public CustomerVermittlungBearbeitungsstatus? CustomerVermittlungBearbeitungsstatus
        {
            get { return _CustomerVermittlungBearbeitungsstatus; }
            set
            {
                if (!AreDifferent(_CustomerVermittlungBearbeitungsstatus, value))
                    return;

                _CustomerVermittlungBearbeitungsstatus = value;
                StoreDirtyInformation(AreDifferent(DataContract.CustomerVermittlungBearbeitungsstatus, value), nameof(CustomerVermittlungBearbeitungsstatus));
                FirePropertyChanged(nameof(CustomerVermittlungBearbeitungsstatus));
            }
        }
        public DateTime? Auftragsruckgabe
        {
            get { return _Auftragsruckgabe; }
            set
            {
                if (!AreDifferent(_Auftragsruckgabe, value))
                    return;

                _Auftragsruckgabe = value;
                StoreDirtyInformation(AreDifferent(DataContract.Auftragsruckgabe, value), nameof(Auftragsruckgabe));
                FirePropertyChanged(nameof(Auftragsruckgabe));
            }
        }
        public ValueListEntryDC Verlauf
        {
            get { return _Verlauf; }
            set
            {
                if (!AreDifferent(_Verlauf, value))
                    return;

                _Verlauf = value;
                StoreDirtyInformation(AreDifferent(DataContract.Verlauf, value), nameof(Verlauf));
                FirePropertyChanged(nameof(Verlauf));
            }
        }
        public decimal? AbgeleisteteStunden
        {
            get { return _AbgeleisteteStunden; }
            set
            {
                if (!AreDifferent(_AbgeleisteteStunden, value))
                    return;

                _AbgeleisteteStunden = value;
                StoreDirtyInformation(AreDifferent(DataContract.AbgeleisteteStunden, value), nameof(AbgeleisteteStunden));
                FirePropertyChanged(nameof(AbgeleisteteStunden));
            }
        }
        public decimal? ErsparteHafttage
        {
            get { return _ErsparteHafttage; }
            set
            {
                if (!AreDifferent(_ErsparteHafttage, value))
                    return;

                _ErsparteHafttage = value;
                StoreDirtyInformation(AreDifferent(DataContract.ErsparteHafttage, value), nameof(ErsparteHafttage));
                FirePropertyChanged(nameof(ErsparteHafttage));
            }
        }
        public decimal? GeleisteteRatenzahlung
        {
            get { return _GeleisteteRatenzahlung; }
            set
            {
                if (!AreDifferent(_GeleisteteRatenzahlung, value))
                    return;

                _GeleisteteRatenzahlung = value;
                StoreDirtyInformation(AreDifferent(DataContract.GeleisteteRatenzahlung, value), nameof(GeleisteteRatenzahlung));
                FirePropertyChanged(nameof(GeleisteteRatenzahlung));
            }
        }
        public string Bemerkung
        {
            get { return _Bemerkung; }
            set
            {
                if (!AreDifferent(_Bemerkung, value))
                    return;

                _Bemerkung = value;
                StoreDirtyInformation(AreDifferent(DataContract.Bemerkung, value), nameof(Bemerkung));
                FirePropertyChanged(nameof(Bemerkung));
            }
        }
        public decimal? GeleisteteEinmalzahlung
        {
            get { return _GeleisteteEinmalzahlung; }
            set
            {
                if (!AreDifferent(_GeleisteteEinmalzahlung, value))
                    return;

                _GeleisteteEinmalzahlung = value;
                StoreDirtyInformation(AreDifferent(DataContract.GeleisteteEinmalzahlung, value), nameof(GeleisteteEinmalzahlung));
                FirePropertyChanged(nameof(GeleisteteEinmalzahlung));
            }
        }
        public bool GrundArbeitsunfahig
        {
            get { return _GrundArbeitsunfahig; }
            set
            {
                if (!AreDifferent(_GrundArbeitsunfahig, value))
                    return;

                _GrundArbeitsunfahig = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundArbeitsunfahig, value), nameof(GrundArbeitsunfahig));
                FirePropertyChanged(nameof(GrundArbeitsunfahig));
            }
        }
        public bool GrundSuchtproblem
        {
            get { return _GrundSuchtproblem; }
            set
            {
                if (!AreDifferent(_GrundSuchtproblem, value))
                    return;

                _GrundSuchtproblem = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundSuchtproblem, value), nameof(GrundSuchtproblem));
                FirePropertyChanged(nameof(GrundSuchtproblem));
            }
        }
        public bool GrundPsychischeProbleme
        {
            get { return _GrundPsychischeProbleme; }
            set
            {
                if (!AreDifferent(_GrundPsychischeProbleme, value))
                    return;

                _GrundPsychischeProbleme = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundPsychischeProbleme, value), nameof(GrundPsychischeProbleme));
                FirePropertyChanged(nameof(GrundPsychischeProbleme));
            }
        }
        public bool GrundKeineMotivation
        {
            get { return _GrundKeineMotivation; }
            set
            {
                if (!AreDifferent(_GrundKeineMotivation, value))
                    return;

                _GrundKeineMotivation = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundKeineMotivation, value), nameof(GrundKeineMotivation));
                FirePropertyChanged(nameof(GrundKeineMotivation));
            }
        }
        public bool GrundInHaft
        {
            get { return _GrundInHaft; }
            set
            {
                if (!AreDifferent(_GrundInHaft, value))
                    return;

                _GrundInHaft = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundInHaft, value), nameof(GrundInHaft));
                FirePropertyChanged(nameof(GrundInHaft));
            }
        }
        public bool GrundUnbekannt
        {
            get { return _GrundUnbekannt; }
            set
            {
                if (!AreDifferent(_GrundUnbekannt, value))
                    return;

                _GrundUnbekannt = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundUnbekannt, value), nameof(GrundUnbekannt));
                FirePropertyChanged(nameof(GrundUnbekannt));
            }
        }
        public bool GrundKeinKontakt
        {
            get { return _GrundKeinKontakt; }
            set
            {
                if (!AreDifferent(_GrundKeinKontakt, value))
                    return;

                _GrundKeinKontakt = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundKeinKontakt, value), nameof(GrundKeinKontakt));
                FirePropertyChanged(nameof(GrundKeinKontakt));
            }
        }
        public bool GrundNichtAngetreten
        {
            get { return _GrundNichtAngetreten; }
            set
            {
                if (!AreDifferent(_GrundNichtAngetreten, value))
                    return;

                _GrundNichtAngetreten = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundNichtAngetreten, value), nameof(GrundNichtAngetreten));
                FirePropertyChanged(nameof(GrundNichtAngetreten));
            }
        }
        public bool GrundAbbruchDerTatigkeit
        {
            get { return _GrundAbbruchDerTatigkeit; }
            set
            {
                if (!AreDifferent(_GrundAbbruchDerTatigkeit, value))
                    return;

                _GrundAbbruchDerTatigkeit = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundAbbruchDerTatigkeit, value), nameof(GrundAbbruchDerTatigkeit));
                FirePropertyChanged(nameof(GrundAbbruchDerTatigkeit));
            }
        }
        public bool GrundWiderruf
        {
            get { return _GrundWiderruf; }
            set
            {
                if (!AreDifferent(_GrundWiderruf, value))
                    return;

                _GrundWiderruf = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundWiderruf, value), nameof(GrundWiderruf));
                FirePropertyChanged(nameof(GrundWiderruf));
            }
        }
        public bool Grund459StPO
        {
            get { return _Grund459StPO; }
            set
            {
                if (!AreDifferent(_Grund459StPO, value))
                    return;

                _Grund459StPO = value;
                StoreDirtyInformation(AreDifferent(DataContract.Grund459StPO, value), nameof(Grund459StPO));
                FirePropertyChanged(nameof(Grund459StPO));
            }
        }
        public bool GrundAusbleibenDerZahlung
        {
            get { return _GrundAusbleibenDerZahlung; }
            set
            {
                if (!AreDifferent(_GrundAusbleibenDerZahlung, value))
                    return;

                _GrundAusbleibenDerZahlung = value;
                StoreDirtyInformation(AreDifferent(DataContract.GrundAusbleibenDerZahlung, value), nameof(GrundAusbleibenDerZahlung));
                FirePropertyChanged(nameof(GrundAusbleibenDerZahlung));
            }
        }
        public bool BesonderheitMehrfacheBeauftragung
        {
            get { return _BesonderheitMehrfacheBeauftragung; }
            set
            {
                if (!AreDifferent(_BesonderheitMehrfacheBeauftragung, value))
                    return;

                _BesonderheitMehrfacheBeauftragung = value;
                StoreDirtyInformation(AreDifferent(DataContract.BesonderheitMehrfacheBeauftragung, value), nameof(BesonderheitMehrfacheBeauftragung));
                FirePropertyChanged(nameof(BesonderheitMehrfacheBeauftragung));
            }
        }
        public bool BesonderheitMehrfacheVermittlung
        {
            get { return _BesonderheitMehrfacheVermittlung; }
            set
            {
                if (!AreDifferent(_BesonderheitMehrfacheVermittlung, value))
                    return;

                _BesonderheitMehrfacheVermittlung = value;
                StoreDirtyInformation(AreDifferent(DataContract.BesonderheitMehrfacheVermittlung, value), nameof(BesonderheitMehrfacheVermittlung));
                FirePropertyChanged(nameof(BesonderheitMehrfacheVermittlung));
            }
        }
        public bool BesonderheitVermittlungAusHaft
        {
            get { return _BesonderheitVermittlungAusHaft; }
            set
            {
                if (!AreDifferent(_BesonderheitVermittlungAusHaft, value))
                    return;

                _BesonderheitVermittlungAusHaft = value;
                StoreDirtyInformation(AreDifferent(DataContract.BesonderheitVermittlungAusHaft, value), nameof(BesonderheitVermittlungAusHaft));
                FirePropertyChanged(nameof(BesonderheitVermittlungAusHaft));
            }
        }
        public bool BesonderheitDurchBGBWAufgesucht
        {
            get { return _BesonderheitDurchBGBWAufgesucht; }
            set
            {
                if (!AreDifferent(_BesonderheitDurchBGBWAufgesucht, value))
                    return;

                _BesonderheitDurchBGBWAufgesucht = value;
                StoreDirtyInformation(AreDifferent(DataContract.BesonderheitDurchBGBWAufgesucht, value), nameof(BesonderheitDurchBGBWAufgesucht));
                FirePropertyChanged(nameof(BesonderheitDurchBGBWAufgesucht));
            }
        }

        public void UpdateHoheDerGeldstrafe()
        {
            if (!Tagessatze.HasValue || !Tagessatzhohe.HasValue)
                return;

            HoheDerGeldstrafe = Tagessatze * Tagessatzhohe;
        }

        protected override void InitByDataContract(CustomerVermittlungArbeitDC pDataContract)
        {
            _VgaType = pDataContract.VgaType;
            _Fallnummer = pDataContract.Fallnummer;
            _AktenzeichenGericht = pDataContract.AktenzeichenGericht;
            _EigenesAktenzeichen = pDataContract.EigenesAktenzeichen;
            _Auftragseingang = pDataContract.Auftragseingang;
            _Auftragsherkunft = pDataContract.Auftragsherkunft;
            _Vermittlungsgrundlage = pDataContract.Vermittlungsgrundlage;
            _Tagessatze = pDataContract.Tagessatze;
            _Tagessatzhohe = pDataContract.Tagessatzhohe;
            _HoheDerGeldstrafe = pDataContract.HoheDerGeldstrafe;
            _ZuLeistendeArbeitsstunden = pDataContract.ZuLeistendeArbeitsstunden;
            _Hinweis = pDataContract.Hinweis;
            _Termin = pDataContract.Termin;
            _CustomerVermittlungBearbeitungsstatus = pDataContract.CustomerVermittlungBearbeitungsstatus;
            _Auftragsruckgabe = pDataContract.Auftragsruckgabe;
            _Verlauf = pDataContract.Verlauf;
            _AbgeleisteteStunden = pDataContract.AbgeleisteteStunden;
            _ErsparteHafttage = pDataContract.ErsparteHafttage;
            _GeleisteteRatenzahlung = pDataContract.GeleisteteRatenzahlung;
            _Bemerkung = pDataContract.Bemerkung;
            _GeleisteteEinmalzahlung = pDataContract.GeleisteteEinmalzahlung;
            _GrundArbeitsunfahig = pDataContract.GrundArbeitsunfahig;
            _GrundSuchtproblem = pDataContract.GrundSuchtproblem;
            _GrundPsychischeProbleme = pDataContract.GrundPsychischeProbleme;
            _GrundKeineMotivation = pDataContract.GrundKeineMotivation;
            _GrundInHaft = pDataContract.GrundInHaft;
            _GrundUnbekannt = pDataContract.GrundUnbekannt;
            _GrundKeinKontakt = pDataContract.GrundKeinKontakt;
            _GrundNichtAngetreten = pDataContract.GrundNichtAngetreten;
            _GrundAbbruchDerTatigkeit = pDataContract.GrundAbbruchDerTatigkeit;
            _GrundWiderruf = pDataContract.GrundWiderruf;
            _Grund459StPO = pDataContract.Grund459StPO;
            _GrundAusbleibenDerZahlung = pDataContract.GrundAusbleibenDerZahlung;
            _BesonderheitMehrfacheBeauftragung = pDataContract.BesonderheitMehrfacheBeauftragung;
            _BesonderheitMehrfacheVermittlung = pDataContract.BesonderheitMehrfacheVermittlung;
            _BesonderheitVermittlungAusHaft = pDataContract.BesonderheitVermittlungAusHaft;
            _BesonderheitDurchBGBWAufgesucht = pDataContract.BesonderheitDurchBGBWAufgesucht;
            _Auftraggeber = pDataContract.Auftraggeber;
            _AuftraggeberAnsprechpartner = pDataContract.AuftraggeberAnsprechpartner;
            _Einsatzstelle = pDataContract.Einsatzstelle;
            _EinsatzstelleAnsprechpartner = pDataContract.EinsatzstelleAnsprechpartner;
        }

        internal void InitValueListEntrys(ObservableSortCollection<ValueListEntryDC> auftragsherkunfte, ObservableSortCollection<ValueListEntryDC> vermittlungsgrundlage, ObservableSortCollection<ValueListEntryDC> verlaeufe)
        {
            _Auftragsherkunfte = auftragsherkunfte;
            _Vermittlungsgrundlagen = vermittlungsgrundlage;
            _Verlaeufe = verlaeufe;
        }

        protected override CustomerVermittlungArbeitDC MapToDataContract(CustomerVermittlungArbeitDC pDataContract, bool doCommit)
        {
            pDataContract.VgaType = _VgaType;
            pDataContract.Fallnummer = _Fallnummer;
            pDataContract.AktenzeichenGericht = _AktenzeichenGericht;
            pDataContract.EigenesAktenzeichen = _EigenesAktenzeichen;
            pDataContract.Auftragseingang = _Auftragseingang;
            pDataContract.Auftragsherkunft = _Auftragsherkunft;
            pDataContract.Vermittlungsgrundlage = _Vermittlungsgrundlage;
            pDataContract.Tagessatze = _Tagessatze;
            pDataContract.Tagessatzhohe = _Tagessatzhohe;
            pDataContract.HoheDerGeldstrafe = _HoheDerGeldstrafe;
            pDataContract.ZuLeistendeArbeitsstunden = _ZuLeistendeArbeitsstunden;
            pDataContract.Hinweis = _Hinweis;
            pDataContract.Termin = _Termin;
            pDataContract.CustomerVermittlungBearbeitungsstatus = _CustomerVermittlungBearbeitungsstatus;
            pDataContract.Auftragsruckgabe = _Auftragsruckgabe;
            pDataContract.Verlauf = _Verlauf;
            pDataContract.AbgeleisteteStunden = _AbgeleisteteStunden;
            pDataContract.ErsparteHafttage = _ErsparteHafttage;
            pDataContract.GeleisteteRatenzahlung = _GeleisteteRatenzahlung;
            pDataContract.Bemerkung = _Bemerkung;
            pDataContract.GeleisteteEinmalzahlung = _GeleisteteEinmalzahlung;
            pDataContract.GrundArbeitsunfahig = _GrundArbeitsunfahig;
            pDataContract.GrundSuchtproblem = _GrundSuchtproblem;
            pDataContract.GrundPsychischeProbleme = _GrundPsychischeProbleme;
            pDataContract.GrundKeineMotivation = _GrundKeineMotivation;
            pDataContract.GrundInHaft = _GrundInHaft;
            pDataContract.GrundUnbekannt = _GrundUnbekannt;
            pDataContract.GrundKeinKontakt = _GrundKeinKontakt;
            pDataContract.GrundNichtAngetreten = _GrundNichtAngetreten;
            pDataContract.GrundAbbruchDerTatigkeit = _GrundAbbruchDerTatigkeit;
            pDataContract.GrundWiderruf = _GrundWiderruf;
            pDataContract.Grund459StPO = _Grund459StPO;
            pDataContract.GrundAusbleibenDerZahlung = _GrundAusbleibenDerZahlung;
            pDataContract.BesonderheitMehrfacheBeauftragung = _BesonderheitMehrfacheBeauftragung;
            pDataContract.BesonderheitMehrfacheVermittlung = _BesonderheitMehrfacheVermittlung;
            pDataContract.BesonderheitVermittlungAusHaft = _BesonderheitVermittlungAusHaft;
            pDataContract.BesonderheitDurchBGBWAufgesucht = _BesonderheitDurchBGBWAufgesucht;
            pDataContract.Auftraggeber = _Auftraggeber;
            pDataContract.AuftraggeberAnsprechpartner = _AuftraggeberAnsprechpartner;
            pDataContract.Einsatzstelle = _Einsatzstelle;
            pDataContract.EinsatzstelleAnsprechpartner = _EinsatzstelleAnsprechpartner;

            return pDataContract;
        }
    }
}