using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;

using BeWo.Core;
using BeWo.Validation;
using BeWo.View;
using BeWo.ViewModel.ListViewModel;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.DataContracts.Wohnhilfe;
using BS.Shared.Extensions;

namespace BeWo.ViewModel
{
	public class CustomerVM : AbstractDCMapperVM<CustomerDC>, IArbeitszeitenVM
    {
		#region PropertyNames
		public static string PropertyName_AbsenceTimes                   = "AbsenceTimes";
        public static string PropertyName_Ansprechpartner                = "Ansprechpartner";
        public static string PropertyName_AssessmentSheetCategories      = "AssessmentSheetCategories";
        public static string PropertyName_Childs                         = "Childs";
        public static string PropertyName_Confidant                      = "Confidant";
        public static string PropertyName_ConfidantString                = "ConfidantString";
        public static string PropertyName_CostBearers                    = "CostBearers";
        public static string PropertyName_CustomerCareTypes              = "CustomerCareTypes";
        public static string PropertyName_DateOfBirth                    = "DateOfBirth";
		public static string PropertyName_PlaceOfBirth = "PlaceOfBirth";
		public static string PropertyName_AufenthaltGueltigBis = "AufenthaltGueltigBis";
		public static string PropertyName_DebitorNumber                  = "DebitorNumber";
        public static string PropertyName_CostCenter                     = "CostCenter";
        public static string PropertyName_Diagnosis                      = "Diagnosis";
        public static string PropertyName_Disabilities                   = "Disabilities";
        public static string PropertyName_EMail                          = "EMail";
        public static string PropertyName_EmployeeRelations              = "EmployeeRelations";
        public static string PropertyName_WohnheimRelations              = "WohnheimRelations"; 
        public static string PropertyName_TeamRelations                  = "TeamRelations";
        public static string PropertyName_EnvironmentPersons             = "EnvironmentPersons";
	    public static string PropertyName_EnvironmentPersonsWithFamily   = "EnvironmentPersonsWithFamily";
        public static string PropertyName_EnvironmentOrganisations       = "EnvironmentOrganisations";
        public static string PropertyName_EquityContribution             = "EquityContribution";
        public static string PropertyName_FamilyStatus                   = "FamilyStatus";
        public static string PropertyName_FamilyDataRelation             = "FamilyDataRelation";
        public static string PropertyName_Fax                            = "Fax";
        public static string PropertyName_FirstName                      = "FirstName";
        public static string PropertyName_ICD10Diagnosis                 = "ICD10Diagnosis";
        public static string PropertyName_InvoiceAddressLine1            = "InvoiceAddressLine1";
        public static string PropertyName_InvoiceAddressLine2            = "InvoiceAddressLine2";
        public static string PropertyName_InvoiceAddressPostalCode       = "InvoiceAddressPostalCode";
        public static string PropertyName_InvoiceAddressStreet           = "InvoiceAddressStreet";
        public static string PropertyName_InvoiceAddressTown             = "InvoiceAddressTown";
        public static string PropertyName_IsAdvised                      = "IsAdvised";
        public static string PropertyName_IsAdvisedOrAttended            = "IsAdvisedOrAttended";
        public static string PropertyName_IsArchived                     = "IsArchived";
        public static string PropertyName_IsMigrant                      = "IsMigrant";
        public static string PropertyName_IsAttended                     = "IsAttended";
        public static string PropertyName_IsFemale                       = "IsFemale";
        public static string PropertyName_IsMale                         = "IsMale";
        public static string PropertyName_IsDivers = "IsDivers";
        public static string PropertyName_LastName                       = "LastName";
        public static string PropertyName_Medication                     = "Medication";
        public static string PropertyName_Environment                    = "Environment";
        public static string PropertyName_MobilePhone                    = "MobilePhone";
        public static string PropertyName_Notice                         = "Notice";
        public static string PropertyName_Jugendamt                      = "Jugendamt";
        public static string PropertyName_Phone                          = "Phone";
        public static string PropertyName_PlacementList                  = "PlacementList";
        public static string PropertyName_PostalCode                     = "PostalCode";
        public static string PropertyName_Profession                     = "Profession";
        public static string PropertyName_ReferenceNumber                = "ReferenceNumber";
        public static string PropertyName_Representative                 = "Representative";
        public static string PropertyName_RepresentativeString           = "RepresentativeString";
        public static string PropertyName_Sex                            = "Sex";
        public static string PropertyName_Street                         = "Street";
        public static string PropertyName_TerminationDate                = "TerminationDate";
        public static string PropertyName_TerminationReason              = "TerminationReason";
		public static string PropertyName_EinkommenBeginnType			 = "EinkommenBeginnType";
		public static string PropertyName_EinkommenEndeType				 = "EinkommenEndeType";
		public static string PropertyName_FremdHilfeType				 = "FremdHilfeType";
		public static string PropertyName_SozSchwierigkeitenType		 = "SozSchwierigkeitenType";
		public static string PropertyName_SozBeziehungenType			 = "SozBeziehungenType";
		public static string PropertyName_ErstaufnahmeType				 = "ErstaufnahmeType";
		public static string PropertyName_RegionType					 = "RegionType";
		public static string PropertyName_Town                           = "Town";
        public static string PropertyName_VarFields                      = "VarFields";
        public static string PropertyName_Kindesmutter                   = "Kindesmutter";
        public static string PropertyName_Kindesvater                    = "Kindesvater";
        public static string PropertyName_Geschwister                    = "Geschwister";
        public static string PropertyName_Vormund                        = "Vormund";
        public static string PropertyName_AddressLine1                   = "AddressLine1";
        public static string PropertyName_DistanceInMeter                = "DistanceInMeter";
        public static string PropertyName_MedArten                       = "MedArten";
        public static string PropertyName_Medikamentenverordnungslisten  = "Medikamentenverordnungslisten";
        public static string PropertyName_MedVerordnungslisten           = "MedVerordnungslisten";
        public static string PropertyName_AssistanceBegin                = "AssistanceBegin";
        public static string PropertyName_Schwerbehindertenausweis       = "Schwerbehindertenausweis";
        public static string PropertyName_AusstVersAmt                   = "AusstVersAmt";
        public static string PropertyName_AusweisGueltigVon              = "AusweisGueltigVon";
        public static string PropertyName_AusweisGueltigBis              = "AusweisGueltigBis";
        public static string PropertyName_AusweisUnbefristetGueltig      = "AusweisUnbefristetGueltig";
        public static string PropertyName_AusweisAktenzeichen		     = "AusweisAktenzeichen";
        public static string PropertyName_BeiblattGueltigBis             = "BeiblattGueltigBis";
        public static string PropertyName_GradDerBehinderung             = "GradDerBehinderung";
        public static string PropertyName_MerkzeichenListe               = "MerkzeichenListe";
        public static string PropertyName_BehinderungsartenListe         = "BehinderungsartenListe";
        public static string PropertyName_CustomerAlias                  = "CustomerAlias";
        public static string PropertyName_Wohnheimbuchungen              = "Wohnheimbuchungen";
        public static string PropertyName_Pflegegrad                     = "Pflegegrad";
        public static string PropertyName_CustomerImage                  = "CustomerImage";
		public static string PropertyName_Nationalitaet					 = "Nationalitaet";
		public static string PropertyName_AufenthaltsStatus              = "AufenthaltsStatus";
	    public static string PropertyName_VertretungGewuenscht           = "VertretungGewuenscht";
	    public static string PropertyName_AbWelchemKrankheitsTag         = "AbWelchemKrankheitsTag";
	    public static string PropertyName_VertretungDringendErforderlich = "VertretungDringendErforderlich";
	    public static string PropertyName_Pflege						 = "Pflege";
	    public static string PropertyName_Toilettengang					 = "Toilettengang";
	    public static string PropertyName_Aggressiv						 = "Aggressiv";
        public static string PropertyName_Schutzstufe					 = "Schutzstufe";
        public static string PropertyName_Hygienebelehrung				 = "Hygienebelehrung";
        public static string PropertyName_ActivationType                 = "ActivationType";
	    public static string PropertyName_Arbeitszeiten					 = "Arbeitszeiten";
		public static string PropertyName_Uebernahmeort = "Uebernahmeort";
		public static string PropertyName_Verhalten = "Verhalten";
		public static string PropertyName_Betreuungsbedarf = "Betreuungsbedarf";
		public static string PropertyName_BemerkungenSbd = "BemerkungenSbd";
		public static string PropertyName_HealthInsurance = "HealthInsurance";
		public static string PropertyName_InsuranceNumber = "InsuranceNumber";
		

		#endregion

		private readonly                                   ObservableSortCollection<ValueListEntryDC> _PossibleCustomerCareTypes;
        private readonly                                   ObservableSortCollection<ValueListEntryDC> _PossibleDisabilities;
        private AbsenceTimeListVM                          _AbsenceTimes;
		private CompactPersonDC                            _Ansprechpartner;
        private BindingList<AssessmentSheetCategoryDC>     _AssessmentSheetCategories;
        private BindingList<MedArtDC>                      _MedArten;
        private string                                     _Childs;
        private CustomerCostBearerRelationListVM           _CostBearers;
		private string                                     _CostCenter;
        private ObservableSortCollection<ValueListEntryDC> _CustomerCareTypes;
        private DateTime?                                  _DateOfBirth;
		private string _PlaceOfBirth;
		private string                                     _DebitorNumber;
		private string                                     _Diagnosis;
        private ObservableSortCollection<ValueListEntryDC> _Disabilities;
        private string                                     _EMail;
        private CustomerEmployeeRelationListVM             _EmployeeRelations;
        private WohnheimCustomerRelationListVM             _WohnheimRelations;
		private bool                                       _EnableLogging;
		private string                                     _Environment;
		private CustomerOrganisationRelationListVM         _EnvironmentOrganisations;
		private CustomerPersonRelationListVM               _EnvironmentPersons;
        private CustomerPersonRelationListVM               _EnvironmentPersonsWithFamily;
        private decimal?                                   _EquityContribution;
        private FamilyStatus?                              _FamilyStatus;
        private string                                     _Fax;
        private string                                     _FirstName;
		private string                                     _Geschwister;
        private string                                     _ICD10Diagnosis;
		private AssessmentSheetCategoryListVM              _IndividualAssessmentSheetCategories;
        private string                                     _InvoiceAddressLine1;
        private string                                     _InvoiceAddressLine2;
        private string                                     _InvoiceAddressPostalCode;
        private string                                     _InvoiceAddressStreet;
        private string                                     _InvoiceAddressTown;
        private bool                                       _IsAdvised;
        private bool                                       _IsArchived;
		private bool									   _IsMigrant;
        private bool                                       _IsAttended;
        private bool                                       _IsFemale;
        private bool                                       _IsMale;
        private bool									   _IsDivers;
        private CompactOrganisationDC                      _Jugendamt;
		private string                                     _Kindesmutter;
        private string                                     _Kindesvater;
        private string                                     _LastName;
		private StringBuilder                              _Log;
		private string                                     _Medication;
		private string									   _Migrationshintergrund;
		private string                                     _MobilePhone;
		private string                                     _Notice;
		private string                                     _Phone;
		private PlacementListVM                            _PlacementList;
        private ObservableSortCollection<ValueListEntryDC> _PlacementObjectives;
        private string                                     _PostalCode;
        private string                                     _Profession;
        private string                                     _ReferenceNumber;
        private string                                     _Street;
        private string                                     _AddressLine1;
        private CustomerTeamRelationListVM                 _TeamRelations;
        private DateTime?                                  _TerminationDate;
        private ValueListEntryDC                           _TerminationReason;
        private ObservableSortCollection<ValueListEntryDC> _TerminationReasons;
        private string                                     _Town;
        private VarFieldListVM                             _VarFields;
        private int?                                       _DistanceInMeter;
        private string                                     _Vormund;
        private DateTime?                                  _AssistanceBegin;
        private string                                     _AusstVersAmt;
        private DateTime?                                  _AusweisGueltigVon;
        private DateTime?                                  _AusweisGueltigBis;
        private bool                                       _AusweisUnbefristetGueltig;
		private string									   _AusweisAktenzeichen;
		private DateTime?                                  _BeiblattGueltigBis;
        private string                                     _GradDerBehinderung;
        private ObservableCollection<Merkzeichen>          _MerkzeichenListe;
        private ObservableCollection<Behinderungsart>      _BehinderungsartenListe;
	    private string                                     _CustomerAlias;
        private Pflegegrad?                                _Pflegegrad;
        private byte[]                                     _CustomerImage;
	    private bool                                       _VertretungGewuenscht;
	    private int                                        _AbWelchemKrankheitsTag;
	    private bool                                       _VertretungDringendErforderlich;
	    private bool									   _Pflege;
	    private bool									   _Toilettengang;
	    private bool									   _Aggressiv;
        private bool                                       _Hygienebelehrung;
        private String                                     _Schutzstufe;
		private String									   _Uebernahmeort;
		private String									   _Verhalten;
		private String									   _Betreuungsbedarf;
		private String									   _BemerkungenSbd;
		private String									   _HealthInsurance;
		private String									   _InsuranceNumber;
		private string									   _VersichertenStatus;
        private string									    _BGNummer;

        private ActivationTypeId                           _ActivationType;
	    private ArbeitszeitListVM                          _Arbeitszeiten;
		private DateTime?								   _AufenthaltGueltigBis;

		private ValueListEntryDC                           _Nationalitaet;  
        private ObservableSortCollection<ValueListEntryDC> _Nationalitaeten;

        private ValueListEntryDC                           _AufenthaltsStatus;
        private ObservableSortCollection<ValueListEntryDC> _AufenthaltsStatuse;

		private ValueListEntryDC _EinkommenBeginnType;
		private ObservableSortCollection<ValueListEntryDC> _EinkommenBeginnTypen;

		private ValueListEntryDC _EinkommenEndeType;
		private ObservableSortCollection<ValueListEntryDC> _EinkommenEndeTypen;

		private ValueListEntryDC _FremdHilfeType;
		private ObservableSortCollection<ValueListEntryDC> _FremdHilfeTypen;

		private ValueListEntryDC _SozSchwierigkeitenType;
		private ObservableSortCollection<ValueListEntryDC> _SozSchwierigkeitenTypen;

		private ValueListEntryDC _SozBeziehungenType;
		private ObservableSortCollection<ValueListEntryDC> _SozBeziehungenTypen;

		private ValueListEntryDC _ErstaufnahmeType;
		private ObservableSortCollection<ValueListEntryDC> _ErstaufnahmeTypen;

		private ValueListEntryDC _RegionType;
		private ObservableSortCollection<ValueListEntryDC> _RegionTypen;

		private ObservableSortCollection<ValueListEntryDC> _RoleInFamilys;
        private ObservableSortCollection<ValueListEntryDC> _EintragKategorien;

        private SubstitutionNeed						   _SubstitutionNeed;
		private CustomerWohnhilfeListVM					   _CustomerWohnhilfeListVM;
		private CustomerVermittlungArbeitListVM			   _CustomerGemeinnutzigeArbeitListVM;

		public CustomerVM()
        {

		}
        public CustomerVM(CustomerDC pDataContract, IEnumerable<ValueListEntryDC> pValueList, List<AssessmentSheetCategoryDC> pPossibleASCs, List<AssessmentSheetValueDC> pPossibleASVs, List<MedArtDC> pPossibleMedArten) : base(pDataContract, pDataContract.CustomerOid == null)
		{
		    var possibleDisabilities			= pValueList.Where(vle => vle.Type == ValueListEntryType.DisabilityType);
		    var possibleCustomerCareTypes		= pValueList.Where(vle => vle.Type == ValueListEntryType.CustomerCareType);
		    var possibleTerminationReasons		= pValueList.Where(vle => vle.Type == ValueListEntryType.TerminationReasonType);
		    var possiblePlacementObjectives		= pValueList.Where(vle => vle.Type == ValueListEntryType.PlacementObjectiveType);
            var possibleNationalitaeten			= pValueList.Where(vle => vle.Type == ValueListEntryType.Nationality);
            var possibleAufenthaltsStatuse		= pValueList.Where(vle => vle.Type == ValueListEntryType.Aufenthaltsstatus);
            var possibleFamilyStatuse			= pValueList.Where(vle => vle.Type == ValueListEntryType.RoleInFamily);
            var possibleEintragKategorien		= pValueList.Where(vle => vle.Type == ValueListEntryType.NotizenKategorieCustomer);
			var possibleEinkommenBeginnTypen	= pValueList.Where(vle => vle.Type == ValueListEntryType.EinkommenBeginnType);
			var possibleEinkommenEndeTypen		= pValueList.Where(vle => vle.Type == ValueListEntryType.EinkommenEndeType);
			var possibleFremdHilfeTypen			= pValueList.Where(vle => vle.Type == ValueListEntryType.FremdHilfeType);
			var possibleSozSchwierigkeitenTypen = pValueList.Where(vle => vle.Type == ValueListEntryType.SozSchwierigkeitenType);
			var possibleSozBeziehungenTypen		= pValueList.Where(vle => vle.Type == ValueListEntryType.SozBeziehungenType);
			var possibleErstaufnahmeTypen		= pValueList.Where(vle => vle.Type == ValueListEntryType.ErstaufnahmeType);
			var possibleRegionTypen				= pValueList.Where(vle => vle.Type == ValueListEntryType.RegionType);


			_PossibleDisabilities = pDataContract.Disabilities != null
		        ? new ObservableSortCollection<ValueListEntryDC>(possibleDisabilities.Except(pDataContract.Disabilities), Comparer.ValueListEntryDCComparer)
		        : new ObservableSortCollection<ValueListEntryDC>(possibleDisabilities, Comparer.ValueListEntryDCComparer);

		    _PossibleCustomerCareTypes = new ObservableSortCollection<ValueListEntryDC>(possibleCustomerCareTypes, Comparer.ValueListEntryDCComparer);
		    _TerminationReasons        = new ObservableSortCollection<ValueListEntryDC>(possibleTerminationReasons, Comparer.ValueListEntryDCComparer);
		    _PlacementObjectives       = new ObservableSortCollection<ValueListEntryDC>(possiblePlacementObjectives, Comparer.ValueListEntryDCComparer);
            _Nationalitaeten           = new ObservableSortCollection<ValueListEntryDC>(possibleNationalitaeten,Comparer.ValueListEntryDCComparer);
            _AufenthaltsStatuse        = new ObservableSortCollection<ValueListEntryDC>(possibleAufenthaltsStatuse, Comparer.ValueListEntryDCComparer);
            _RoleInFamilys             = new ObservableSortCollection<ValueListEntryDC>(possibleFamilyStatuse,Comparer.ValueListEntryDCComparer);
            _EintragKategorien         = new ObservableSortCollection<ValueListEntryDC>(possibleEintragKategorien, Comparer.ValueListEntryDCComparer);
			_EinkommenBeginnTypen	   = new ObservableSortCollection<ValueListEntryDC>(possibleEinkommenBeginnTypen, Comparer.ValueListEntryDCComparer);
			_EinkommenEndeTypen        = new ObservableSortCollection<ValueListEntryDC>(possibleEinkommenEndeTypen, Comparer.ValueListEntryDCComparer);
			_FremdHilfeTypen		   = new ObservableSortCollection<ValueListEntryDC>(possibleFremdHilfeTypen, Comparer.ValueListEntryDCComparer);
			_SozSchwierigkeitenTypen   = new ObservableSortCollection<ValueListEntryDC>(possibleSozSchwierigkeitenTypen, Comparer.ValueListEntryDCComparer);
			_SozBeziehungenTypen	   = new ObservableSortCollection<ValueListEntryDC>(possibleSozBeziehungenTypen, Comparer.ValueListEntryDCComparer);
			_ErstaufnahmeTypen		   = new ObservableSortCollection<ValueListEntryDC>(possibleErstaufnahmeTypen, Comparer.ValueListEntryDCComparer);
			_RegionTypen			   = new ObservableSortCollection<ValueListEntryDC>(possibleRegionTypen, Comparer.ValueListEntryDCComparer);
			

			_MedArten = new BindingList<MedArtDC>(pPossibleMedArten);

		    pPossibleASCs.Sort((x, y) => x.Position.CompareTo(y.Position));
		    _AssessmentSheetCategories = new BindingList<AssessmentSheetCategoryDC>(pPossibleASCs);

		    foreach (var i in _AssessmentSheetCategories)
		    {
		        i.IsSelected = pDataContract.AssessmentSheetCategoryDCs != null &&
		                       pDataContract.AssessmentSheetCategoryDCs.Exists(j => j.AssessmentSheetCategoryOid.Equals(i.AssessmentSheetCategoryOid));
		    }

		    _AssessmentSheetCategories.ListChanged += (s, e) => StoreDirtyInformation(true, "AssessmentSheetCategories");

		    if (pDataContract.AssessmentSheetCategoryDCs != null)
		    {
		        var individualServices = pDataContract.AssessmentSheetCategoryDCs.FindAll(cat => cat.ScopeType == ScopeTypeId.Individual);

		        _IndividualAssessmentSheetCategories = new AssessmentSheetCategoryListVM(individualServices, pPossibleASVs);

		        //this._ServiceAccountings = new ServiceAccountingListVM(pDataContract.ServiceAccountings);
		    }
		    else
		    {
		        _IndividualAssessmentSheetCategories = new AssessmentSheetCategoryListVM(new List<AssessmentSheetCategoryDC>(), pPossibleASVs);
		    }

            Arbeitszeiten = new ArbeitszeitListVM(DataContract.Arbeitszeiten);
		}

		public bool PermissionFalldatenView { get; } = BeWoApp.HasLoggedOnUserRight(UserRightType.Customer_GemeinnutzigeArbeit_View);
		public bool PermissionGemeinnutzigeArbeitView { get; } = BeWoApp.HasLoggedOnUserRight(UserRightType.Customer_GemeinnutzigeArbeit_View);
		public bool PermissionWohnhilfeView { get; } = BeWoApp.HasLoggedOnUserRight(UserRightType.Customer_Wohnhilfe_View);

		public ArbeitszeitListVM Arbeitszeiten
	    {
	        get => _Arbeitszeiten;

            set
	        {
	            _Arbeitszeiten = value;
	            FirePropertyChanged(PropertyName_Arbeitszeiten);
	        }
	    }
        public SubstitutionNeed SubstitutionNeed
        {
            get => _SubstitutionNeed;

            set
            {
                if(AreDifferent(_SubstitutionNeed, value))
                {
                    _SubstitutionNeed = value;
                    StoreDirtyInformation(AreDifferent(DataContract.SubstitutionNeed, value), nameof(SubstitutionNeed));
                    FirePropertyChanged(nameof(SubstitutionNeed));
                }
            }
        }
        //Wird noch benötigt
        //public BargeldverwaltungsVM Bargeldverwaltung
        //{
        //	get { return _Bargeldverwaltung; }

        //	set
        //	{
        //		_Bargeldverwaltung = value;
        //		StoreDirtyInformation(AreDifferent(DataContract.Bargeldverwaltung, value), PropertyName_Bargeldverwaltung);
        //		FirePropertyChanged(PropertyName_Bargeldverwaltung);
        //	}
        //}
        public AbsenceTimeListVM AbsenceTimes
		{
			get => _AbsenceTimes;

            set
			{
				_AbsenceTimes = value;
				FirePropertyChanged(PropertyName_AbsenceTimes);
			}
		}
		public CompactPersonDC Ansprechpartner
		{
			get { return _Ansprechpartner; }

			set
			{
				if (!AreDifferent(_Ansprechpartner, value))
					return;

				_Ansprechpartner = value;
				StoreDirtyInformation(AreDifferent(DataContract.Ansprechpartner, value), PropertyName_Ansprechpartner);
				FirePropertyChanged(PropertyName_Ansprechpartner);
			}
		}
		public BindingList<MedArtDC> MedArten
		{
			get { return _MedArten; }
			set
			{
				_MedArten = value;
				FirePropertyChanged(PropertyName_MedArten);
			}
		}
		public BindingList<AssessmentSheetCategoryDC> AssessmentSheetCategories
		{
			get { return _AssessmentSheetCategories; }

			set
			{
				_AssessmentSheetCategories = value;
				FirePropertyChanged(PropertyName_AssessmentSheetCategories);
			}
		}
		public AssessmentSheetCategoryListVM IndividualAssessmentSheetCategories
		{
			get { return _IndividualAssessmentSheetCategories; }

			set
			{
				_IndividualAssessmentSheetCategories = value;
				FirePropertyChanged("IndividualAssessmentSheetCategories");
			}
		}
		public string Childs
		{
			get { return _Childs; }

			set
			{
				if (AreDifferent(_Childs, value))
				{
					_Childs = value;

					StoreDirtyInformation(AreDifferent(DataContract.Childs, value), PropertyName_Childs);

					FirePropertyChanged(PropertyName_Childs);
				}
			}
		}
		public CustomerCostBearerRelationListVM CostBearers
		{
			get { return _CostBearers; }

			set
			{
				_CostBearers = value;
				FirePropertyChanged(PropertyName_CostBearers);
			}
		}
		public ObservableSortCollection<ValueListEntryDC> CustomerCareTypes
		{
			get { return _CustomerCareTypes ?? (_CustomerCareTypes = new ObservableSortCollection<ValueListEntryDC>(Comparer.ValueListEntryDCComparer)); }
		}
		public DateTime? DateOfBirth
		{
			get { return _DateOfBirth; }

			set
			{
				if (AreDifferent(_DateOfBirth, value))
				{
					_DateOfBirth = value;

					StoreDirtyInformation(AreDifferent(DataContract.DateOfBirth, value), PropertyName_DateOfBirth);

					FirePropertyChanged(PropertyName_DateOfBirth);
				}
			}
		}

		public String PlaceOfBirth
		{
			get { return _PlaceOfBirth; }

			set
			{
				if (AreDifferent(_PlaceOfBirth, value))
				{
					_PlaceOfBirth = value;

					StoreDirtyInformation(AreDifferent(DataContract.PlaceOfBirth, value), PropertyName_PlaceOfBirth);

					FirePropertyChanged(PropertyName_PlaceOfBirth);
				}
			}
		}

		public DateTime? AufenthaltGueltigBis
		{
			get { return _AufenthaltGueltigBis; }

			set
			{
				if (AreDifferent(_AufenthaltGueltigBis, value))
				{
					_AufenthaltGueltigBis = value;

					StoreDirtyInformation(AreDifferent(DataContract.AufenthaltGueltigBis, value), PropertyName_AufenthaltGueltigBis);

					FirePropertyChanged(PropertyName_AufenthaltGueltigBis);
				}
			}
		}
		public string DebitorNumber
		{
			get { return _DebitorNumber; }

			set
			{
				if (AreDifferent(_DebitorNumber, value))
				{
					_DebitorNumber = value;

					StoreDirtyInformation(AreDifferent(DataContract.DebitorNumber, value), PropertyName_DebitorNumber);

					FirePropertyChanged(PropertyName_DebitorNumber);
				}
			}
		}
		public string CostCenter
		{
			get { return _CostCenter; }

			set
			{
				if (AreDifferent(_CostCenter, value))
				{
					_CostCenter = value;

					StoreDirtyInformation(AreDifferent(DataContract.CostCenter, value), PropertyName_CostCenter);

					FirePropertyChanged(PropertyName_CostCenter);
				}
			}
		}
		public string Diagnosis
		{
			get { return _Diagnosis; }

			set
			{
				if (AreDifferent(_Diagnosis, value))
				{
					_Diagnosis = value;

					StoreDirtyInformation(AreDifferent(DataContract.Diagnosis, value), PropertyName_Diagnosis);

					FirePropertyChanged(PropertyName_Diagnosis);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> Disabilities
		{
			get { return _Disabilities ?? (_Disabilities = new ObservableSortCollection<ValueListEntryDC>(Comparer.ValueListEntryDCComparer)); }
		}
		public string EMail
		{
			get { return _EMail; }

			set
			{
				if (AreDifferent(_EMail, value))
				{
					_EMail = value;

					StoreDirtyInformation(
						DataContract.ContactInformations.Where(con => con.ContactType == ContactType.business_Mail && con.ContactValue == value).SingleOrDefault() == null, PropertyName_EMail);

					FirePropertyChanged(PropertyName_EMail);
				}
			}
		}
		public CustomerEmployeeRelationListVM EmployeeRelations
		{
			get { return _EmployeeRelations; }

			set
			{
				_EmployeeRelations = value;
				FirePropertyChanged(PropertyName_EmployeeRelations);
			}
		}
        public WohnheimCustomerRelationListVM WohnheimRelations
		{
			get { return _WohnheimRelations; }

			set
			{
				_WohnheimRelations = value;
				FirePropertyChanged(PropertyName_WohnheimRelations);
			}
		}
		public CustomerTeamRelationListVM TeamRelations
		{
			get { return _TeamRelations; }
			set
			{
				_TeamRelations = value;
				FirePropertyChanged(PropertyName_TeamRelations);
			}
		}
        public CustomerPersonRelationListVM EnvironmentPersons
        {
            get
            {              
                return _EnvironmentPersons;
            }

            set
            {
                _EnvironmentPersons = value;
                FirePropertyChanged(PropertyName_EnvironmentPersons);
            }
        }
        public CustomerPersonRelationListVM EnvironmentPersonsWithFamily
        {
            get
            {
                return _EnvironmentPersonsWithFamily;
            }
            set
            {
                _EnvironmentPersonsWithFamily = value;
                FirePropertyChanged(PropertyName_EnvironmentPersonsWithFamily);
            }
        }
        public CustomerOrganisationRelationListVM EnvironmentOrganisations
		{
			get { return _EnvironmentOrganisations; }

			set
			{
				_EnvironmentOrganisations = value;
				FirePropertyChanged(PropertyName_EnvironmentOrganisations);
			}
		}
		public string EquityContribution
		{
			get { return String.Format("{0:n}", _EquityContribution); }

			set
			{
				decimal d = 0;
				Decimal.TryParse(value, out d);
				if (AreDifferent(_EquityContribution, d))
				{
					_EquityContribution = d;

					StoreDirtyInformation(AreDifferent(DataContract.EquityContribution, d), PropertyName_EquityContribution);

					FirePropertyChanged(PropertyName_EquityContribution);
				}
			}
		}
		public FamilyStatus? FamilyStatus
		{
			get { return _FamilyStatus; }

			set
			{
				if (AreDifferent(_FamilyStatus, value))
				{
					_FamilyStatus = value;
					StoreDirtyInformation(AreDifferent(DataContract.FamilyStatus, value), PropertyName_FamilyStatus);
					FirePropertyChanged(PropertyName_FamilyStatus);
				}
			}
		}
		public string Fax
		{
			get { return _Fax; }

			set
			{
				if (AreDifferent(_Fax, value))
				{
					_Fax = value;

					StoreDirtyInformation(
						DataContract.ContactInformations.SingleOrDefault(con => con.ContactType == ContactType.business_Fax && con.ContactValue == value) == null, PropertyName_Fax);

					FirePropertyChanged(PropertyName_Fax);
				}
			}
		}

		[Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
		public string FirstName
		{
			get { return _FirstName; }

			set
			{
				if (AreDifferent(_FirstName, value))
				{
					_FirstName = value;

					StoreDirtyInformation(AreDifferent(DataContract.FirstName, value), PropertyName_FirstName);

					FirePropertyChanged(PropertyName_FirstName);
				}
			}
		}
		public BindingList<String> ICD10Codes { get; set; }
		public string ICD10Diagnosis
		{
			get { return _ICD10Diagnosis; }

			set
			{
				if (AreDifferent(_ICD10Diagnosis, value))
				{
					_ICD10Diagnosis = value;

					StoreDirtyInformation(AreDifferent(DataContract.ICD10Diagnosis, value), PropertyName_ICD10Diagnosis);

					FirePropertyChanged(PropertyName_ICD10Diagnosis);
				}
			}
		}
		public string InvoiceAddressLine1
		{
			get { return _InvoiceAddressLine1; }

			set
			{
				if (AreDifferent(_InvoiceAddressLine1, value))
				{
					_InvoiceAddressLine1 = value;
					StoreDirtyInformation(AreDifferent(DataContract.InvoiceAddressLine1, value), PropertyName_InvoiceAddressLine1);
					FirePropertyChanged(PropertyName_InvoiceAddressLine1);
				}
			}
		}
		public string InvoiceAddressLine2
		{
			get { return _InvoiceAddressLine2; }

			set
			{
				if (AreDifferent(_InvoiceAddressLine2, value))
				{
					_InvoiceAddressLine2 = value;
					StoreDirtyInformation(AreDifferent(DataContract.InvoiceAddressLine2, value), PropertyName_InvoiceAddressLine2);
					FirePropertyChanged(PropertyName_InvoiceAddressLine2);
				}
			}
		}
		public string InvoiceAddressPostalCode
		{
			get { return _InvoiceAddressPostalCode; }

			set
			{
				if (AreDifferent(_InvoiceAddressPostalCode, value))
				{
					_InvoiceAddressPostalCode = value;
					StoreDirtyInformation(AreDifferent(DataContract.InvoiceAddressPostalCode, value), PropertyName_InvoiceAddressPostalCode);
					FirePropertyChanged(PropertyName_InvoiceAddressPostalCode);
				}
			}
		}
		public string InvoiceAddressStreet
		{
			get { return _InvoiceAddressStreet; }

			set
			{
				if (AreDifferent(_InvoiceAddressStreet, value))
				{
					_InvoiceAddressStreet = value;
					StoreDirtyInformation(AreDifferent(DataContract.InvoiceAddressStreet, value), PropertyName_InvoiceAddressStreet);
					FirePropertyChanged(PropertyName_InvoiceAddressStreet);
				}
			}
		}
		public string InvoiceAddressTown
		{
			get { return _InvoiceAddressTown; }

			set
			{
				if (AreDifferent(_InvoiceAddressTown, value))
				{
					_InvoiceAddressTown = value;
					StoreDirtyInformation(AreDifferent(DataContract.InvoiceAddressTown, value), PropertyName_InvoiceAddressTown);
					FirePropertyChanged(PropertyName_InvoiceAddressTown);
				}
			}
		}
		public bool IsAdvised
		{
			get { return _IsAdvised; }

			set
			{
				if (_IsAdvised != value)
				{
					_IsAdvised = value;
					_IsAttended = !value;

					StoreDirtyInformation(AreDifferent(DataContract.IsAdvisedOrAttended, value), PropertyName_IsAdvisedOrAttended);

					FirePropertyChanged(PropertyName_IsAttended);
					FirePropertyChanged(PropertyName_IsAdvised);
				}
			}
		}
		public bool IsArchived
		{
			get => _IsArchived;

		    set
			{
				if(AreDifferent(_IsArchived, value))
				{
					_IsArchived = value;
					StoreDirtyInformation(value && DataContract.ActivationType == ActivationTypeId.Active || !value && DataContract.ActivationType == ActivationTypeId.Archived, PropertyName_IsArchived);
					FirePropertyChanged(PropertyName_IsArchived);

				    ActivationType = value ? ActivationType = ActivationTypeId.Archived : ActivationType = ActivationTypeId.Active;
				}
			}
		}
	    public ActivationTypeId ActivationType
	    {
	        get => _ActivationType;

	        set
	        {
	            if(AreDifferent(_ActivationType, value))
	            {
	                _ActivationType = value;
	                StoreDirtyInformation(AreDifferent(DataContract.ActivationType, value), PropertyName_ActivationType);
	                
	                FirePropertyChanged(PropertyName_ActivationType);
	            }
	        }
	    }	    
        public bool IsMigrant
        {
            get { return _IsMigrant; }

            set
            {
                if (AreDifferent(_IsMigrant, value))
                {
                    _IsMigrant = value;
                    StoreDirtyInformation(AreDifferent(DataContract.IsMigrant, value), PropertyName_IsMigrant);
                    FirePropertyChanged(PropertyName_IsMigrant);
                }
            }
        }
		public bool IsAttended
		{
			get { return _IsAttended; }

			set
			{
				if (_IsAttended != value)
				{
					_IsAttended = value;
					_IsAdvised = !value;

					StoreDirtyInformation(AreDifferent(DataContract.IsAdvisedOrAttended, !value), PropertyName_IsAdvisedOrAttended);

					FirePropertyChanged(PropertyName_IsAttended);
					FirePropertyChanged(PropertyName_IsAdvised);
				}
			}
		}
		public override bool IsDirty
		{
			get
			{
				if (Utils.IsAnyNull(EmployeeRelations, TeamRelations, _EnvironmentPersons, _EnvironmentPersonsWithFamily ,_EnvironmentOrganisations, _AbsenceTimes, CostBearers, _PlacementList, _VarFields, _IndividualAssessmentSheetCategories, _Arbeitszeiten))
				{
					return false;
				}

				return base.IsDirty || TeamRelations.IsDirty || EmployeeRelations.IsDirty || _EnvironmentPersons.IsDirty ||
				       _EnvironmentOrganisations.IsDirty || _AbsenceTimes.IsDirty || _VarFields.IsDirty ||
				       CostBearers.IsDirty || _IndividualAssessmentSheetCategories.IsDirty ||
					   _PlacementList.IsDirty || _MedVerordnungslisten.IsDirty || _EnvironmentPersonsWithFamily.IsDirty || _Arbeitszeiten.IsDirty
					   || _CustomerGemeinnutzigeArbeitListVM.IsDirty || _CustomerWohnhilfeListVM.IsDirty
					   ;
			}
		}
		public bool IsFemale
		{
			get { return _IsFemale; }

			set
			{
				if (_IsFemale != value)
				{
					_IsFemale = value;
					_IsMale = !value;
				    _IsDivers = !value;

                    StoreDirtyInformation((DataContract.Sex == Sex.Female) != value, "sex");

					FirePropertyChanged(PropertyName_IsFemale);
					FirePropertyChanged(PropertyName_IsMale);
				    FirePropertyChanged(PropertyName_IsDivers);
                }
			}
		}
		public bool IsMale
		{
			get { return _IsMale; }

			set
			{
				if (_IsMale != value)
				{
					_IsMale = value;
					_IsFemale = !value;
				    _IsDivers = !value;

					StoreDirtyInformation((DataContract.Sex == Sex.Male) != value, "sex");

					FirePropertyChanged(PropertyName_IsFemale);
					FirePropertyChanged(PropertyName_IsMale);
				    FirePropertyChanged(PropertyName_IsDivers);
                }
			}
		}
        public bool IsDivers
        {
            get { return _IsDivers; }

            set
            {
                if (_IsDivers != value)
                {
                    _IsDivers = value;
                    _IsMale = !value;
                    _IsFemale = !value;

                    StoreDirtyInformation((DataContract.Sex == Sex.Divers) != value, "sex");

                    FirePropertyChanged(PropertyName_IsFemale);
                    FirePropertyChanged(PropertyName_IsMale);
                    FirePropertyChanged(PropertyName_IsDivers);
                }
            }
        }
        [Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
		public string LastName
		{
			get { return _LastName; }

			set
			{
				if (AreDifferent(_LastName, value))
				{
					_LastName = value;

					StoreDirtyInformation(AreDifferent(DataContract.LastName, value), PropertyName_LastName);

					FirePropertyChanged(PropertyName_LastName);
				}
			}
		}
		public string Medication
		{
			get { return _Medication; }

			set
			{
				if (AreDifferent(_Medication, value))
				{
					_Medication = value;
					StoreDirtyInformation(AreDifferent(DataContract.Medication, value), PropertyName_Medication);
					FirePropertyChanged(PropertyName_Medication);
				}
			}
		}

		public string InsuranceNumber
		{
			get { return _InsuranceNumber; }

			set
			{
				if (!AreDifferent(_InsuranceNumber, value))
					return;

				_InsuranceNumber = value;
				StoreDirtyInformation(AreDifferent(DataContract.InsuranceNumber, value), PropertyName_InsuranceNumber);
				FirePropertyChanged(PropertyName_InsuranceNumber);
			}
		}

		public string VersichertenStatus
		{
			get { return _VersichertenStatus; }

			set
			{
				if (!AreDifferent(_VersichertenStatus, value))
					return;

				_VersichertenStatus = value;
				StoreDirtyInformation(AreDifferent(DataContract.VersichertenStatus, value), nameof(VersichertenStatus));
				FirePropertyChanged(nameof(VersichertenStatus));
			}
		}

        public string BGNummer
        {
            get { return _BGNummer; }

            set
            {
                if (!AreDifferent(_BGNummer, value))
                    return;

                _BGNummer = value;
                StoreDirtyInformation(AreDifferent(DataContract.BGNummer, value), nameof(BGNummer));
                FirePropertyChanged(nameof(BGNummer));
            }
        }

        public string Environment
		{
			get { return _Environment; }

			set
			{
				if (AreDifferent(_Environment, value))
				{
					_Environment = value;
					StoreDirtyInformation(AreDifferent(DataContract.Environment, value), PropertyName_Environment);
					FirePropertyChanged(PropertyName_Environment);
				}
			}
		}
		public string MobilePhone
		{
			get { return _MobilePhone; }

			set
			{
				if (AreDifferent(_MobilePhone, value))
				{
					_MobilePhone = value;

					StoreDirtyInformation(
						DataContract.ContactInformations.Where(con => con.ContactType == ContactType.business_MobilePhone && con.ContactValue == value).SingleOrDefault() == null,
						PropertyName_MobilePhone);

					FirePropertyChanged(PropertyName_MobilePhone);
				}
			}
		}
		public string Migrationshintergrund
		{
			get { return this._Migrationshintergrund; }

			set
			{
				if (this.AreDifferent(this._Migrationshintergrund, value))
				{
					this._Migrationshintergrund = value;

					this.StoreDirtyInformation(this.AreDifferent(this.DataContract.Migrationshintergrund, value), nameof(_Migrationshintergrund));

					this.FirePropertyChanged(nameof(_Migrationshintergrund));
				}
			}
		}
		public string Notice
		{
			get { return _Notice; }

			set
			{
				Log("Set Notice");
				if (AreDifferent(_Notice, value))
				{
					_Notice = value;

					StoreDirtyInformation(AreDifferent(DataContract.Notice, value), PropertyName_Notice);

					FirePropertyChanged(PropertyName_Notice);

					if (_EnableLogging)
						Log(String.Format("Set Notice - is dirty = {0}", IsDirty));
				}
			}
		}
		public CompactOrganisationDC Jugendamt
		{
			get { return _Jugendamt; }

			set
			{
				if (!AreDifferent(_Jugendamt, value))
					return;

				_Jugendamt = value;
				StoreDirtyInformation(AreDifferent(DataContract.Jugendamt, value), PropertyName_Jugendamt);
				FirePropertyChanged(PropertyName_Jugendamt);
			}
		}
		public string Phone
		{
			get { return _Phone; }

			set
			{
				if (AreDifferent(_Phone, value))
				{
					_Phone = value;

					StoreDirtyInformation(
						DataContract.ContactInformations.Where(con => con.ContactType == ContactType.business_Phone && con.ContactValue == value).SingleOrDefault() == null, PropertyName_Phone);

					FirePropertyChanged(PropertyName_Phone);
				}
			}
		}
		public PlacementListVM PlacementList
		{
			get { return _PlacementList; }

			set
			{
				_PlacementList = value;
				FirePropertyChanged(PropertyName_PlacementList);
			}
		}
		public ObservableSortCollection<ValueListEntryDC> PlacementObjectives
		{
			get
			{
				if (_PlacementObjectives == null)
				{
					_PlacementObjectives = new ObservableSortCollection<ValueListEntryDC>();
				}

				return _PlacementObjectives;
			}
		}
		public ObservableSortCollection<ValueListEntryDC> PossibleCustomerCareTypes
		{
			get { return _PossibleCustomerCareTypes; }
		}
		public ObservableSortCollection<ValueListEntryDC> PossibleDisabilities
		{
			get { return _PossibleDisabilities; }
		}
		public string PostalCode
		{
			get { return _PostalCode; }

			set
			{
				if (AreDifferent(_PostalCode, value))
				{
					_PostalCode = value;

					StoreDirtyInformation(AreDifferent(DataContract.PostalCode, value), PropertyName_PostalCode);

					FirePropertyChanged(PropertyName_PostalCode);
				}
			}
		}
		public string Profession
		{
			get { return _Profession; }

			set
			{
				if (AreDifferent(_Profession, value))
				{
					_Profession = value;

					StoreDirtyInformation(AreDifferent(DataContract.Profession, value), PropertyName_Profession);

					FirePropertyChanged(PropertyName_Profession);
				}
			}
		}
		public string ReferenceNumber
		{
			get { return _ReferenceNumber; }

			set
			{
				if (AreDifferent(_ReferenceNumber, value))
				{
					_ReferenceNumber = value;

					StoreDirtyInformation(AreDifferent(DataContract.ReferenceNumber, value), PropertyName_ReferenceNumber);

					FirePropertyChanged(PropertyName_ReferenceNumber);
				}
			}
		}
		public string Street
		{
			get { return _Street; }

			set
			{
				if (AreDifferent(_Street, value))
				{
					_Street = value;

					StoreDirtyInformation(AreDifferent(DataContract.Street, value), PropertyName_Street);

					FirePropertyChanged(PropertyName_Street);
				}
			}
		}
		public int? DistanceInMeter
		{
			get { return _DistanceInMeter; }

			set
			{
				if (AreDifferent(_DistanceInMeter, value))
				{
					_DistanceInMeter = value;
					this.StoreDirtyInformation(this.AreDifferent(this.DataContract.DistanceInMeter, value), PropertyName_DistanceInMeter);
					FirePropertyChanged(PropertyName_DistanceInMeter);
				}
			}
		}
		public string AddressLine1
		{
			get { return this._AddressLine1; }

			set
			{
				if (this.AreDifferent(this._AddressLine1, value))
				{
					this._AddressLine1 = value;
					this.StoreDirtyInformation(this.AreDifferent(this.DataContract.AddressLine1, value), PropertyName_AddressLine1);
					this.FirePropertyChanged(PropertyName_AddressLine1);
				}
			}
		}
		public string Kindesmutter
		{
			get { return _Kindesmutter; }

			set
			{
				if (!AreDifferent(_Kindesmutter, value))
					return;

				_Kindesmutter = value;
				StoreDirtyInformation(AreDifferent(DataContract.Kindesmutter, value), PropertyName_Kindesmutter);
				FirePropertyChanged(PropertyName_Kindesmutter);
			}
		}
		public string Kindesvater
		{
			get { return _Kindesvater; }

			set
			{
				if (!AreDifferent(_Kindesvater, value))
					return;

				_Kindesvater = value;
				StoreDirtyInformation(AreDifferent(DataContract.Kindesvater, value), PropertyName_Kindesvater);
				FirePropertyChanged(PropertyName_Kindesvater);
			}
		}
		public string Geschwister
		{
			get { return _Geschwister; }

			set
			{
				if (!AreDifferent(_Kindesmutter, value))
					return;

				_Geschwister = value;
				StoreDirtyInformation(AreDifferent(DataContract.Geschwister, value), PropertyName_Geschwister);
				FirePropertyChanged(PropertyName_Geschwister);
			}
		}
		public string Vormund
		{
			get { return _Vormund; }

			set
			{
				if (!AreDifferent(_Vormund, value))
					return;

				_Vormund = value;
				StoreDirtyInformation(AreDifferent(DataContract.Vormund, value), PropertyName_Vormund);
				FirePropertyChanged(PropertyName_Vormund);
			}
		}
		public DateTime? TerminationDate
		{
			get { return _TerminationDate; }

			set
			{
				if (AreDifferent(_TerminationDate, value))
				{
					_TerminationDate = value;

					StoreDirtyInformation(AreDifferent(DataContract.TerminationDate, value), PropertyName_TerminationDate);

					FirePropertyChanged(PropertyName_TerminationDate);
				}
			}
		}
        public DateTime? AssistanceBegin
        {
            get { return _AssistanceBegin; }

            set
            {
                if (AreDifferent(_AssistanceBegin, value))
                {
                    _AssistanceBegin = value;

                    StoreDirtyInformation(AreDifferent(DataContract.AssistanceBegin, value), PropertyName_AssistanceBegin);

                    FirePropertyChanged(PropertyName_AssistanceBegin);
                }
            }
        }
		public ValueListEntryDC TerminationReason
		{
			get { return _TerminationReason; }
			set
			{
				if (AreDifferent(_TerminationReason, value))
				{
					_TerminationReason = value;
					StoreDirtyInformation(AreDifferent(DataContract.TerminationReason, value), PropertyName_TerminationReason);
					FirePropertyChanged(PropertyName_TerminationReason);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> TerminationReasons
		{
			get { return _TerminationReasons ?? (_TerminationReasons = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public ValueListEntryDC EinkommenBeginnType
		{
			get { return _EinkommenBeginnType; }
			set
			{
				if (AreDifferent(_EinkommenBeginnType, value))
				{
					_EinkommenBeginnType = value;
					StoreDirtyInformation(AreDifferent(DataContract.EinkommenBeginnType, value), PropertyName_EinkommenBeginnType);
					FirePropertyChanged(PropertyName_EinkommenBeginnType);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> EinkommenBeginnTypen
		{
			get { return _EinkommenBeginnTypen ?? (_EinkommenBeginnTypen = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public ValueListEntryDC EinkommenEndeType
		{
			get { return _EinkommenEndeType; }
			set
			{
				if (AreDifferent(_EinkommenEndeType, value))
				{
					_EinkommenEndeType = value;
					StoreDirtyInformation(AreDifferent(DataContract.EinkommenEndeType, value), PropertyName_EinkommenEndeType);
					FirePropertyChanged(PropertyName_EinkommenEndeType);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> EinkommenEndeTypen
		{
			get { return _EinkommenEndeTypen ?? (_EinkommenEndeTypen = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public ValueListEntryDC FremdHilfeType
		{
			get { return _FremdHilfeType; }
			set
			{
				if (AreDifferent(_FremdHilfeType, value))
				{
					_FremdHilfeType = value;
					StoreDirtyInformation(AreDifferent(DataContract.FremdHilfeType, value), PropertyName_FremdHilfeType);
					FirePropertyChanged(PropertyName_FremdHilfeType);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> FremdHilfeTypen
		{
			get { return _FremdHilfeTypen ?? (_FremdHilfeTypen = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public ValueListEntryDC SozSchwierigkeitenType
		{
			get { return _SozSchwierigkeitenType; }
			set
			{
				if (AreDifferent(_SozSchwierigkeitenType, value))
				{
					_SozSchwierigkeitenType = value;
					StoreDirtyInformation(AreDifferent(DataContract.SozSchwierigkeitenType, value), PropertyName_SozSchwierigkeitenType);
					FirePropertyChanged(PropertyName_SozSchwierigkeitenType);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> SozSchwierigkeitenTypen
		{
			get { return _SozSchwierigkeitenTypen ?? (_SozSchwierigkeitenTypen = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public ValueListEntryDC SozBeziehungenType
		{
			get { return _SozBeziehungenType; }
			set
			{
				if (AreDifferent(_SozBeziehungenType, value))
				{
					_SozBeziehungenType = value;
					StoreDirtyInformation(AreDifferent(DataContract.SozBeziehungenType, value), PropertyName_SozBeziehungenType);
					FirePropertyChanged(PropertyName_SozBeziehungenType);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> SozBeziehungenTypen
		{
			get { return _SozBeziehungenTypen ?? (_SozBeziehungenTypen = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public ValueListEntryDC ErstaufnahmeType
		{
			get { return _ErstaufnahmeType; }
			set
			{
				if (AreDifferent(_ErstaufnahmeType, value))
				{
					_ErstaufnahmeType = value;
					StoreDirtyInformation(AreDifferent(DataContract.ErstaufnahmeType, value), PropertyName_ErstaufnahmeType);
					FirePropertyChanged(PropertyName_ErstaufnahmeType);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> ErstaufnahmeTypen
		{
			get { return _ErstaufnahmeTypen ?? (_ErstaufnahmeTypen = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public ValueListEntryDC RegionType
		{
			get { return _RegionType; }
			set
			{
				if (AreDifferent(_RegionType, value))
				{
					_RegionType = value;
					StoreDirtyInformation(AreDifferent(DataContract.RegionType, value), PropertyName_RegionType);
					FirePropertyChanged(PropertyName_RegionType);
				}
			}
		}
		public ObservableSortCollection<ValueListEntryDC> RegionTypen
		{
			get { return _RegionTypen ?? (_RegionTypen = new ObservableSortCollection<ValueListEntryDC>()); }
		}
		public string Town
		{
			get { return _Town; }

			set
			{
				if (AreDifferent(_Town, value))
				{
					_Town = value;

					StoreDirtyInformation(AreDifferent(DataContract.Town, value), PropertyName_Town);

					FirePropertyChanged(PropertyName_Town);
				}
			}
		}
		public VarFieldListVM VarFields
		{
			get { return _VarFields; }

			set
			{
				if (AreDifferent(_VarFields, value))
				{
					_VarFields = value;
					FirePropertyChanged(PropertyName_VarFields);
				}
			}
		}
	    public string AusstVersAmt
	    {
            get { return _AusstVersAmt; }

	        set
	        {
	            if (AreDifferent(_AusstVersAmt, value))
	            {
	                _AusstVersAmt = value;
                    StoreDirtyInformation(AreDifferent(DataContract.AusstVersAmt, value), PropertyName_AusstVersAmt);
                    FirePropertyChanged(PropertyName_AusstVersAmt);
	            }
	        }
	    }
		public DateTime? AusweisGueltigVon
        {
            get { return _AusweisGueltigVon; }

            set
            {
                if (AreDifferent(_AusweisGueltigVon, value))
                {
                    _AusweisGueltigVon = value;
                    StoreDirtyInformation(AreDifferent(DataContract.AusweisGueltigVon, value), PropertyName_AusweisGueltigVon);
                    FirePropertyChanged(PropertyName_AusweisGueltigVon);
                }
            }
        }
        public DateTime? AusweisGueltigBis
        {
            get { return _AusweisGueltigBis; }

            set
            {
                if (AreDifferent(_AusweisGueltigBis, value))
                {
                    _AusweisGueltigBis = value;
                    StoreDirtyInformation(AreDifferent(DataContract.AusweisGueltigBis, value), PropertyName_AusweisGueltigBis);
                    FirePropertyChanged(PropertyName_AusweisGueltigBis);
                }
            }
        }
        public bool AusweisUnbefristetGueltig
        {
            get { return _AusweisUnbefristetGueltig; }

            set
            {
                if (AreDifferent(_AusweisUnbefristetGueltig, value))
                {
                    _AusweisUnbefristetGueltig = value;

                    if (value)
                    {
                        AusweisGueltigBis = null;
                    }

                    StoreDirtyInformation(AreDifferent(DataContract.AusweisUnbefristetGueltig, value), PropertyName_AusweisUnbefristetGueltig);
                    FirePropertyChanged(PropertyName_AusweisUnbefristetGueltig);
                }
            }
        }
		public string AusweisAktenzeichen
		{
			get { return _AusweisAktenzeichen; }

			set
			{
				if (AreDifferent(_AusweisAktenzeichen, value))
				{
					_AusweisAktenzeichen = value;

					StoreDirtyInformation(AreDifferent(DataContract.AusweisAktenzeichen, value), PropertyName_AusweisAktenzeichen);

					FirePropertyChanged(PropertyName_AusweisAktenzeichen);
				}
			}
		}
		public DateTime? BeiblattGueltigBis
        {
            get { return _BeiblattGueltigBis; }

            set
            {
                if (AreDifferent(_BeiblattGueltigBis, value))
                {
                    _BeiblattGueltigBis = value;
                    StoreDirtyInformation(AreDifferent(DataContract.BeiblattGueltigBis, value), PropertyName_BeiblattGueltigBis);
                    FirePropertyChanged(PropertyName_BeiblattGueltigBis);
                }
            }
        }
        public string GradDerBehinderung
        {
            get { return _GradDerBehinderung; }

            set
            {
                if (AreDifferent(_GradDerBehinderung, value))
                {
                    _GradDerBehinderung = value;
                    StoreDirtyInformation(AreDifferent(DataContract.GradDerBehinderung, value), PropertyName_GradDerBehinderung);
                    FirePropertyChanged(PropertyName_GradDerBehinderung);
                }
            }
        }        
        public Byte[] CustomerImage
        {
            get { return _CustomerImage; }

            set
            {
                if (AreDifferent(_CustomerImage, value))
                {
                    _CustomerImage = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Images, value), PropertyName_CustomerImage);
                    FirePropertyChanged(PropertyName_CustomerImage);
                }
            }
        }
        public ValueListEntryDC Nationalitaet
        {
            get { return this._Nationalitaet; }

            set
            {
                if (this.AreDifferent(this._Nationalitaet, value))
                {
                    this._Nationalitaet = value;

                    this.StoreDirtyInformation(this.AreDifferent(DataContract.Nationalitaet, value), PropertyName_Nationalitaet);

                    this.FirePropertyChanged(PropertyName_Nationalitaet);
                }
            }
        }
        public ValueListEntryDC AufenthaltsStatus
        {
            get { return this._AufenthaltsStatus; }

            set
            {
                if (this.AreDifferent(this._AufenthaltsStatus, value))
                {
                    this._AufenthaltsStatus = value;

                    this.StoreDirtyInformation(this.AreDifferent(DataContract.AufenthaltsStatus, value), PropertyName_AufenthaltsStatus);

                    this.FirePropertyChanged(PropertyName_AufenthaltsStatus);
                }
            }
        }
        public ObservableSortCollection<ValueListEntryDC> Nationalitaeten
        {
            get
            {
                if (_Nationalitaeten == null)
                {
                    this._Nationalitaeten = new ObservableSortCollection<ValueListEntryDC>();
                }

                return this._Nationalitaeten;
            }
        }
        public ObservableSortCollection<ValueListEntryDC> RoleInFamilys
        {
            get
            {
                if (_RoleInFamilys == null)
                {
                    this._RoleInFamilys = new ObservableSortCollection<ValueListEntryDC>();
                }

                return this._RoleInFamilys;
            }
        }
        public ObservableSortCollection<ValueListEntryDC> AufenthaltsStatuse
        {
            get
            {
                if (_AufenthaltsStatuse == null)
                {
                    this._AufenthaltsStatuse = new ObservableSortCollection<ValueListEntryDC>();
                }

                return this._AufenthaltsStatuse;
            }
        }
        public ObservableCollection<Behinderungsart> BehinderungsartenListe
        {
            get { return _BehinderungsartenListe ?? (_BehinderungsartenListe = new ObservableCollection<Behinderungsart>()); }

            set
            {
                if (AreDifferent(_BehinderungsartenListe, value))
                {
                    _BehinderungsartenListe = value;

                    StoreDirtyInformation(AreDifferent(DataContract.BehinderungsartenListe, value), PropertyName_BehinderungsartenListe);
                    FirePropertyChanged(PropertyName_BehinderungsartenListe);
                }
            }
        }
        public ObservableCollection<Merkzeichen> MerkzeichenListe
        {
            get { return _MerkzeichenListe ?? (_MerkzeichenListe = new ObservableCollection<Merkzeichen>()); }

            set
            {
                if (AreDifferent(_MerkzeichenListe, value))
                {
                    _MerkzeichenListe = value;

                    StoreDirtyInformation(AreDifferent(DataContract.MerkzeichenListe, value), PropertyName_MerkzeichenListe);
                    FirePropertyChanged(PropertyName_MerkzeichenListe);
                }
            }
        }
		public void EnableLogging(bool enable, StringBuilder log)
		{
			_EnableLogging = enable;
			_Log = log;
		}
        public bool VertretungGewuenscht
        {
            get { return _VertretungGewuenscht; }

            set
            {
                if (AreDifferent(_VertretungGewuenscht, value))
                {
                    _VertretungGewuenscht = value;
                    StoreDirtyInformation(AreDifferent(DataContract.VertretungGewuenscht, value), PropertyName_VertretungGewuenscht);
                    FirePropertyChanged(PropertyName_VertretungGewuenscht);
                }
            }
        }
        public int AbWelchemKrankheitsTag
        {
            get
            {
                if (_AbWelchemKrankheitsTag < 1)
                    return 1;

                return _AbWelchemKrankheitsTag;
            }

            set
            {
                if (AreDifferent(_AbWelchemKrankheitsTag, value))
                {
                    _AbWelchemKrankheitsTag = value;
                    StoreDirtyInformation(AreDifferent(DataContract.AbWelchemKrankheitsTag, value), PropertyName_AbWelchemKrankheitsTag);
                    FirePropertyChanged(PropertyName_AbWelchemKrankheitsTag);
                }
            }
        }        
        public bool VertretungDringendErforderlich
        {
            get { return _VertretungDringendErforderlich ; }

            set
            {
                if (AreDifferent(_VertretungDringendErforderlich, value))
                {
                    _VertretungDringendErforderlich = value;
                    StoreDirtyInformation(AreDifferent(DataContract.VertretungDringendErforderlich, value), PropertyName_VertretungDringendErforderlich);
                    FirePropertyChanged(PropertyName_VertretungDringendErforderlich);
                }
            }
        }
	    public bool Pflege
        {
	        get { return _Pflege; }

	        set
	        {
	            if (AreDifferent(_Pflege, value))
	            {
	                _Pflege = value;
	                StoreDirtyInformation(AreDifferent(DataContract.Pflege, value), PropertyName_Pflege);
	                FirePropertyChanged(PropertyName_Pflege);
	            }
	        }
	    }
		public bool Toilettengang
        {
	        get { return _Toilettengang; }

	        set
	        {
	            if (AreDifferent(_Toilettengang, value))
	            {
	                _Toilettengang = value;
	                StoreDirtyInformation(AreDifferent(DataContract.Toilettengang, value), PropertyName_Toilettengang);
	                FirePropertyChanged(PropertyName_Toilettengang);
	            }
	        }
	    }
	    public bool Aggressiv
        {
	        get { return _Aggressiv; }

	        set
	        {
	            if (AreDifferent(_Aggressiv, value))
	            {
	                _Aggressiv = value;
	                StoreDirtyInformation(AreDifferent(DataContract.Aggressiv, value), PropertyName_Aggressiv);
	                FirePropertyChanged(PropertyName_Aggressiv);
	            }
	        }
	    }
        public bool Hygienebelehrung
        {
            get { return _Hygienebelehrung; }

            set
            {
                if (AreDifferent(_Hygienebelehrung, value))
                {
                    _Hygienebelehrung = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Hygienebelehrung, value), PropertyName_Hygienebelehrung);
                    FirePropertyChanged(PropertyName_Hygienebelehrung);
                }
            }
        }
        public string Schutzstufe
        {
            get { return _Schutzstufe; }

            set
            {
                if (AreDifferent(_Schutzstufe, value))
                {
                    _Schutzstufe = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Schutzstufe, value), PropertyName_Schutzstufe);
                    FirePropertyChanged(PropertyName_Schutzstufe);
                }
            }
        }
		public string Uebernahmeort
		{
			get { return _Uebernahmeort; }

			set
			{
				if (AreDifferent(_Uebernahmeort, value))
				{
					_Uebernahmeort = value;
					StoreDirtyInformation(AreDifferent(DataContract.Uebernahmeort, value), PropertyName_Uebernahmeort);
					FirePropertyChanged(PropertyName_Uebernahmeort);
				}
			}
		}
		public string Verhalten
		{
			get { return _Verhalten; }

			set
			{
				if (AreDifferent(_Verhalten, value))
				{
					_Verhalten = value;
					StoreDirtyInformation(AreDifferent(DataContract.Verhalten, value), PropertyName_Verhalten);
					FirePropertyChanged(PropertyName_Verhalten);
				}
			}
		}
		public string Betreuungsbedarf
		{
			get { return _Betreuungsbedarf; }

			set
			{
				if (AreDifferent(_Betreuungsbedarf, value))
				{
					_Betreuungsbedarf = value;
					StoreDirtyInformation(AreDifferent(DataContract.Betreuungsbedarf, value), PropertyName_Betreuungsbedarf);
					FirePropertyChanged(PropertyName_Betreuungsbedarf);
				}
			}
		}
		public string BemerkungenSbd
		{
			get { return _BemerkungenSbd; }

			set
			{
				if (AreDifferent(_BemerkungenSbd, value))
				{
					_BemerkungenSbd = value;
					StoreDirtyInformation(AreDifferent(DataContract.BemerkungenSbd, value), PropertyName_BemerkungenSbd);
					FirePropertyChanged(PropertyName_BemerkungenSbd);
				}
			}
		}
		public string HealthInsurance
		{
			get { return _HealthInsurance; }

			set
			{
				if (!AreDifferent(_HealthInsurance, value))
					return;

				_HealthInsurance = value;
				StoreDirtyInformation(AreDifferent(DataContract.HealthInsurance, value), PropertyName_HealthInsurance);
				FirePropertyChanged(PropertyName_HealthInsurance);
			}
		}
		public ObservableSortCollection<ValueListEntryDC> EintragKategorien
        {
            get => _EintragKategorien;

            set
            {
                if (AreDifferent(_EintragKategorien, value))
                {
                    _EintragKategorien = value;
                    FirePropertyChanged(nameof(_EintragKategorien));
                }
            }
        }
		public CustomerWohnhilfeListVM CustomerWohnhilfeListVM
		{
			get { return _CustomerWohnhilfeListVM; }

			set
			{
				if (!AreDifferent(CustomerWohnhilfeListVM, value))
					return;
				_CustomerWohnhilfeListVM = value;
				FirePropertyChanged(nameof(CustomerWohnhilfeListVM));
			}
		}

		public CustomerVermittlungArbeitListVM CustomerVermittlungArbeitListVM
		{
			get { return _CustomerGemeinnutzigeArbeitListVM; }

			set
			{
				if (!AreDifferent(CustomerVermittlungArbeitListVM, value))
					return;
				_CustomerGemeinnutzigeArbeitListVM = value;
				FirePropertyChanged(nameof(CustomerVermittlungArbeitListVM));
			}
		}


		#region Medikamentenverordnungslisten

		private MedikamentenverordnungslisteListVM _MedVerordnungslisten;

		public MedikamentenverordnungslisteListVM MedVerordnungslisten
		{
			get => _MedVerordnungslisten;

            set
			{
				if (AreDifferent(_MedVerordnungslisten, value))
				{
					_MedVerordnungslisten = value;
					FirePropertyChanged(PropertyName_MedVerordnungslisten);
				}
			}
		}

		private BindingList<MedikamentenverordnungslisteDC> _Medikamentenverordnungslisten;
		public BindingList<MedikamentenverordnungslisteDC> Medikamentenverordnungslisten
		{
			get { return _Medikamentenverordnungslisten ?? (_Medikamentenverordnungslisten = new BindingList<MedikamentenverordnungslisteDC>()); }
			set
			{
				_Medikamentenverordnungslisten = value;
				StoreDirtyInformation(AreDifferent(DataContract.Medikamentenverordnungslisten, value), PropertyName_Medikamentenverordnungslisten);
				FirePropertyChanged(PropertyName_Medikamentenverordnungslisten);
			}
		}

		public MedikamentenverordnungslisteVM AktuelleMedikamentenverordnungsliste
		{
			get { return MedVerordnungslisten.VMList.FirstOrDefault(vm => vm.Gueltig && false == vm.MedListType); }
		}
		public MedikamentenverordnungslisteVM Bedarfsmedikamentenverordnungsliste
		{
			get { return MedVerordnungslisten.VMList.FirstOrDefault(vm => vm.Gueltig && vm.MedListType); }
		}
		public List<MedikamentenverordnungslisteVM> UngueltigeVerordnungen
		{
			get { return MedVerordnungslisten.VMList.Where(vm => !vm.Gueltig).ToList(); }
		}
	    public string CustomerAlias
	    {
            get { return _CustomerAlias; }

	        set
	        {
	            if (AreDifferent(_CustomerAlias, value))
	            {
	                _CustomerAlias = value;
                    StoreDirtyInformation(AreDifferent(DataContract.CustomerAlias, value), PropertyName_CustomerAlias);
                    FirePropertyChanged(PropertyName_CustomerAlias);
	            }
	        }
	    }        
        public Pflegegrad? Pflegegrad {

            get { return _Pflegegrad; }

            set
            {
                if (AreDifferent(_Pflegegrad, value))
                {
                    _Pflegegrad = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Pflegegrad, value), PropertyName_Pflegegrad);
                    FirePropertyChanged(PropertyName_Pflegegrad);
                }
            }
        
        }
        
		#endregion

		protected override void InitByDataContract(CustomerDC pDataContract)
		{
			if (!IsNew)
            {
                _SubstitutionNeed                           = pDataContract.SubstitutionNeed;
				_DateOfBirth                                = pDataContract.DateOfBirth;
				_PlaceOfBirth = pDataContract.PlaceOfBirth;
				_FirstName                                  = pDataContract.FirstName;
				_FamilyStatus                               = pDataContract.FamilyStatus;
				_LastName                                   = pDataContract.LastName;
				_PostalCode                                 = pDataContract.PostalCode;
				_Profession                                 = pDataContract.Profession;
				_Street                                     = pDataContract.Street;
				_AddressLine1                               = pDataContract.AddressLine1;
				_DistanceInMeter                            = pDataContract.DistanceInMeter;
				_Town                                       = pDataContract.Town;
				_InvoiceAddressLine1                        = pDataContract.InvoiceAddressLine1;
				_InvoiceAddressLine2                        = pDataContract.InvoiceAddressLine2;
				_InvoiceAddressPostalCode                   = pDataContract.InvoiceAddressPostalCode;
				_InvoiceAddressStreet                       = pDataContract.InvoiceAddressStreet;
				_InvoiceAddressTown                         = pDataContract.InvoiceAddressTown;
				_Medication                                 = pDataContract.Medication;
				_Environment                                = pDataContract.Environment;
				_Diagnosis                                  = pDataContract.Diagnosis;
				_Notice                                     = pDataContract.Notice;
				_ICD10Diagnosis                             = pDataContract.ICD10Diagnosis;
				_Childs                                     = pDataContract.Childs;
				_EquityContribution                         = pDataContract.EquityContribution;
				_ReferenceNumber                            = pDataContract.ReferenceNumber;
                _Kindesmutter                               = pDataContract.Kindesmutter;
				_Kindesvater                                = pDataContract.Kindesvater;
				_Geschwister                                = pDataContract.Geschwister;
				_Vormund                                    = pDataContract.Vormund;
			    _CustomerAlias                              = pDataContract.CustomerAlias;
                _Pflegegrad                                 = pDataContract.Pflegegrad;
			    _Nationalitaet                              = pDataContract.Nationalitaet;
			    _AufenthaltsStatus                          = pDataContract.AufenthaltsStatus;
			    _VertretungGewuenscht						= pDataContract.VertretungGewuenscht;
			    _AbWelchemKrankheitsTag						= pDataContract.AbWelchemKrankheitsTag;
			    _VertretungDringendErforderlich				= pDataContract.VertretungDringendErforderlich;
                _Pflege										= pDataContract.Pflege;
                _Toilettengang								= pDataContract.Toilettengang;
                _Aggressiv									= pDataContract.Aggressiv;
			    _Schutzstufe								= pDataContract.Schutzstufe;
				_Uebernahmeort = pDataContract.Uebernahmeort;
				_Verhalten = pDataContract.Verhalten;
				_Betreuungsbedarf = pDataContract.Betreuungsbedarf;
				_BemerkungenSbd = pDataContract.BemerkungenSbd;
				_HealthInsurance = pDataContract.HealthInsurance;
				_InsuranceNumber = pDataContract.InsuranceNumber;
				_VersichertenStatus = pDataContract.VersichertenStatus;
                _BGNummer = pDataContract.BGNummer;
                _Hygienebelehrung = pDataContract.Hygienebelehrung;
				_Migrationshintergrund = pDataContract.Migrationshintergrund;
				_AufenthaltGueltigBis = pDataContract.AufenthaltGueltigBis;

				if (pDataContract.Images != null && pDataContract.Images.Count > 0)
			    {
			        _CustomerImage = pDataContract.Images[0];
			    }

			    if (pDataContract.Jugendamt != null)
				{
				    _Jugendamt = pDataContract.Jugendamt;
				}

				if (pDataContract.Ansprechpartner != null)
				{
				    _Ansprechpartner = pDataContract.Ansprechpartner;
				}

				_IsArchived        = pDataContract.ActivationType == ActivationTypeId.Archived;
			    _ActivationType    = pDataContract.ActivationType;
			    _IsMigrant         = pDataContract.IsMigrant;
                _IsMale            = pDataContract.Sex == Sex.Male;
				_IsFemale          = pDataContract.Sex == Sex.Female;
			    _IsDivers = pDataContract.Sex == Sex.Divers;
                _IsAdvised         = pDataContract.IsAdvisedOrAttended == null || pDataContract.IsAdvisedOrAttended.Value;
                _IsAttended        = !IsAdvised;
                _DebitorNumber     = pDataContract.DebitorNumber;
				_CostCenter        = pDataContract.CostCenter;
			    _AssistanceBegin   = pDataContract.AssistanceBegin;
				_TerminationDate   = pDataContract.TerminationDate;
				_TerminationReason = pDataContract.TerminationReason;
				_EinkommenBeginnType = pDataContract.EinkommenBeginnType;
				_EinkommenEndeType = pDataContract.EinkommenEndeType;
				_FremdHilfeType = pDataContract.FremdHilfeType;
				_SozSchwierigkeitenType = pDataContract.SozSchwierigkeitenType;
				_SozBeziehungenType = pDataContract.SozBeziehungenType;
				_ErstaufnahmeType = pDataContract.ErstaufnahmeType;
				_RegionType = pDataContract.RegionType;

				_AusstVersAmt              = pDataContract.AusstVersAmt;
                _AusweisGueltigVon         = pDataContract.AusweisGueltigVon;
                _AusweisGueltigBis         = pDataContract.AusweisGueltigBis;
				_AusweisAktenzeichen	   = pDataContract.AusweisAktenzeichen;
			    _BeiblattGueltigBis        = pDataContract.BeiblattGueltigBis;
                _GradDerBehinderung        = pDataContract.GradDerBehinderung;
				_MerkzeichenListe          = new ObservableCollection<Merkzeichen>(pDataContract.MerkzeichenListe);
                _BehinderungsartenListe    = new ObservableCollection<Behinderungsart>(pDataContract.BehinderungsartenListe);
                _AusweisUnbefristetGueltig = pDataContract.AusweisUnbefristetGueltig != null && pDataContract.AusweisUnbefristetGueltig.Value;

				if (pDataContract.Disabilities != null)
				{
					_Disabilities = new ObservableSortCollection<ValueListEntryDC>(pDataContract.Disabilities, Comparer.ValueListEntryDCComparer);
				}

				if (pDataContract.CustomerCareTypes != null)
				{
					_CustomerCareTypes = new ObservableSortCollection<ValueListEntryDC>(pDataContract.CustomerCareTypes, Comparer.ValueListEntryDCComparer);
				}

				if (pDataContract.Medikamentenverordnungslisten != null)
				{
				    Medikamentenverordnungslisten.AddRange(pDataContract.Medikamentenverordnungslisten);
				}

				foreach (var iContactDC in pDataContract.ContactInformations)
				{
					if (iContactDC.ContactType == ContactType.business_Mail)
					{
						_EMail = iContactDC.ContactValue;
					}

					if (iContactDC.ContactType == ContactType.business_Fax)
					{
						_Fax = iContactDC.ContactValue;
					}

					if (iContactDC.ContactType == ContactType.business_Phone)
					{
						_Phone = iContactDC.ContactValue;
					}
					 
					if (iContactDC.ContactType == ContactType.business_MobilePhone)
					{
						_MobilePhone = iContactDC.ContactValue;
					}
				}
			}

			Disabilities.CollectionChanged += (s, e) => StoreDirtyInformation(!_Disabilities.ContainsSameItemsAs(pDataContract.Disabilities), PropertyName_Disabilities);
			CustomerCareTypes.CollectionChanged += (s, e) => StoreDirtyInformation(!_CustomerCareTypes.ContainsSameItemsAs(pDataContract.CustomerCareTypes), PropertyName_CustomerCareTypes);

			EmployeeRelations = VMFactory.CreateCustomerEmployeeRelationListVM(pDataContract.RelatedEmployees ?? (pDataContract.RelatedEmployees = new List<CustomerEmployeeRelationDC>()));

			TeamRelations = new CustomerTeamRelationListVM(pDataContract.RelatedTeams ?? (pDataContract.RelatedTeams = new List<CustomerTeamRelationDC>()));

            var dcListFamily = new List<CustomerPersonRelationDC>();
            var dcListUmfeld = new List<CustomerPersonRelationDC>();

		    if (pDataContract.EnvironmentPersons != null)
		    {
		        foreach (var customerPersonRelationDc in pDataContract.EnvironmentPersons)
		        {
		            if (customerPersonRelationDc.IstFamilie)
		            {
		                dcListFamily.Add(customerPersonRelationDc);
		            }
		            else
		            {
		                dcListUmfeld.Add(customerPersonRelationDc);
		            }
		        }
		    }

			EnvironmentPersons = VMFactory.CreateCustomerEnvironmentPersonRelListVM(dcListUmfeld, ValueListEntryType.EnvironmentPersonType);
            EnvironmentPersonsWithFamily = VMFactory.CreateCustomerEnvironmentPersonRelListVM(dcListFamily, ValueListEntryType.RoleInFamily);

            EnvironmentOrganisations = VMFactory.CreateCustomerEnvironmentOrganisationRelListVM(pDataContract.EnvironmentOrganisations ?? (pDataContract.EnvironmentOrganisations = new List<CustomerOrganisationRelationDC>()));

			AbsenceTimes = VMFactory.CreateAbsenceTimeListVM(pDataContract.AbsenceTimes ?? (pDataContract.AbsenceTimes = new List<AbsenceTimeDC>()), AbsenceReasonVisibilityType.Customer);

			CostBearers = new CustomerCostBearerRelationListVM(pDataContract.CostBearers ?? (pDataContract.CostBearers = new List<CustomerCostBearerRelationDC>()));

			_PlacementList = new PlacementListVM(pDataContract.PlacementList);
			_VarFields = new VarFieldListVM(pDataContract.CustomerVarFields);

			ICD10Codes = pDataContract.ICD10DiagnosisCodes == null ? new BindingList<string>() : new BindingList<string>(pDataContract.ICD10DiagnosisCodes);

			ICD10Codes.ListChanged += (s, e) => StoreDirtyInformation(true, "ICD10Codes");

			MedVerordnungslisten = VMFactory.CreateMedikementenverordnungslisteListVM(pDataContract.Medikamentenverordnungslisten);

			CustomerWohnhilfeListVM = new CustomerWohnhilfeListVM(this, pDataContract.CustomerWohnhilfeDC ?? (pDataContract.CustomerWohnhilfeDC = new List<CustomerWohnhilfeDC>()));

			CustomerVermittlungArbeitListVM = new CustomerVermittlungArbeitListVM(pDataContract.CustomerVermittlungArbeitDC ?? (pDataContract.CustomerVermittlungArbeitDC = new List<CustomerVermittlungArbeitDC>()));
		}
	    protected override CustomerDC MapToDataContract(CustomerDC pDataContract, bool doCommit)
		{
			pDataContract.DateOfBirth                       = _DateOfBirth;
			pDataContract.PlaceOfBirth = _PlaceOfBirth;
			pDataContract.FirstName                         = _FirstName;
			pDataContract.FamilyStatus                      = _FamilyStatus;
			pDataContract.LastName                          = _LastName;
			pDataContract.PostalCode                        = _PostalCode;
			pDataContract.Profession                        = _Profession;
			pDataContract.Street                            = _Street;
			pDataContract.AddressLine1                      = _AddressLine1;
			pDataContract.Town                              = _Town;
			pDataContract.DistanceInMeter                   = _DistanceInMeter;
			pDataContract.InvoiceAddressLine1               = _InvoiceAddressLine1;
			pDataContract.InvoiceAddressLine2               = _InvoiceAddressLine2;
			pDataContract.InvoiceAddressStreet              = _InvoiceAddressStreet;
			pDataContract.InvoiceAddressTown                = _InvoiceAddressTown;
			pDataContract.InvoiceAddressPostalCode          = _InvoiceAddressPostalCode;
            pDataContract.Jugendamt                         = _Jugendamt;
			pDataContract.Ansprechpartner                   = _Ansprechpartner;
            pDataContract.Kindesmutter                      = _Kindesmutter;
			pDataContract.Kindesvater                       = _Kindesvater;
			pDataContract.Geschwister                       = _Geschwister;
			pDataContract.Vormund                           = _Vormund;
            pDataContract.Diagnosis                         = _Diagnosis;
			pDataContract.Notice                            = _Notice;
			pDataContract.ICD10Diagnosis                    = _ICD10Diagnosis;
			pDataContract.Childs                            = _Childs;
			pDataContract.EquityContribution                = _EquityContribution;
			pDataContract.ReferenceNumber                   = _ReferenceNumber;
			pDataContract.Disabilities                      = _Disabilities.ToList();
			pDataContract.CustomerCareTypes                 = _CustomerCareTypes.ToList();
		    pDataContract.ActivationType                    = _ActivationType;
	        pDataContract.IsMigrant                         = _IsMigrant;
		    pDataContract.AusstVersAmt                      = _AusstVersAmt;
		    pDataContract.AusweisGueltigVon                 = _AusweisGueltigVon;
		    pDataContract.AusweisGueltigBis                 = _AusweisGueltigBis;
		    pDataContract.AusweisUnbefristetGueltig         = _AusweisUnbefristetGueltig;
		    pDataContract.AusweisAktenzeichen		        = _AusweisAktenzeichen;
		    pDataContract.BeiblattGueltigBis                = _BeiblattGueltigBis;
		    pDataContract.GradDerBehinderung                = _GradDerBehinderung;
	        pDataContract.Nationalitaet                     = _Nationalitaet;
	        pDataContract.AufenthaltsStatus                 = _AufenthaltsStatus;
		    pDataContract.VertretungGewuenscht              = _VertretungGewuenscht;
		    pDataContract.AbWelchemKrankheitsTag            = _AbWelchemKrankheitsTag;
		    pDataContract.VertretungDringendErforderlich    = _VertretungDringendErforderlich;
		    pDataContract.Pflege							= _Pflege;
		    pDataContract.Toilettengang						= _Toilettengang;
		    pDataContract.Aggressiv							= _Aggressiv;
		    pDataContract.Schutzstufe						= _Schutzstufe;
			pDataContract.Uebernahmeort						= _Uebernahmeort;
			pDataContract.Verhalten							= _Verhalten;
			pDataContract.Betreuungsbedarf					= _Betreuungsbedarf;
			pDataContract.BemerkungenSbd					= _BemerkungenSbd;
			pDataContract.HealthInsurance					= _HealthInsurance;
			pDataContract.InsuranceNumber					= _InsuranceNumber?.Trim();
			pDataContract.VersichertenStatus				= _VersichertenStatus?.Trim();
            pDataContract.BGNummer = _BGNummer;
            pDataContract.Hygienebelehrung					= _Hygienebelehrung;
			pDataContract.Migrationshintergrund				= _Migrationshintergrund;
            pDataContract.SubstitutionNeed                  = _SubstitutionNeed;
			pDataContract.AufenthaltGueltigBis = _AufenthaltGueltigBis;

			if (_MerkzeichenListe != null)
		    {
			    pDataContract.MerkzeichenListe = _MerkzeichenListe.ToList();
		    }

		    if (_BehinderungsartenListe != null)
		    {
			    pDataContract.BehinderungsartenListe = _BehinderungsartenListe.ToList();
		    }

		    pDataContract.CustomerAlias             = _CustomerAlias;
            pDataContract.Pflegegrad                = _Pflegegrad;
            pDataContract.Images?.Clear();

            if (_CustomerImage != null)
	        {
	            if (pDataContract.Images == null)
	            {
	                pDataContract.Images = new List<byte[]>();
	            }

                pDataContract.Images.Add(_CustomerImage);
            }

			CommitContact(_MobilePhone, ContactType.business_MobilePhone);
			CommitContact(_Phone, ContactType.business_Phone);
			CommitContact(_Fax, ContactType.business_Fax);
			CommitContact(_EMail, ContactType.business_Mail);

			if (_IsMale)
			{
			    pDataContract.Sex = Sex.Male;
			}

		    if (_IsFemale)
		    {
		        pDataContract.Sex = Sex.Female;
		    }

		    if (_IsDivers)
		    {
		        pDataContract.Sex = Sex.Divers;
		    }

            pDataContract.RelatedEmployees         = _EmployeeRelations.CopyToDCList(doCommit);
			pDataContract.RelatedTeams             = _TeamRelations.CopyToDCList(doCommit);

	        pDataContract.EnvironmentPersons = new List<CustomerPersonRelationDC>();

            foreach (var vm in EnvironmentPersonsWithFamily.VMList)
            {
                pDataContract.EnvironmentPersons.Add(vm.CommitToDataContract());
            }
            foreach (var vm in EnvironmentPersons.VMList)
            {
                pDataContract.EnvironmentPersons.Add(vm.CommitToDataContract());
            }

            //pDataContract.EnvironmentPersons     = _EnvironmentPersons.CopyToDCList(doCommit);
            pDataContract.EnvironmentOrganisations = _EnvironmentOrganisations.CopyToDCList(doCommit);
			pDataContract.AbsenceTimes             = _AbsenceTimes.CopyToDCList(doCommit);
			pDataContract.CostBearers              = _CostBearers.CopyToDCList(doCommit);
			pDataContract.PlacementList            = _PlacementList.CopyToDCList(doCommit);

			if (_VarFields != null)
			{
				pDataContract.CustomerVarFields = _VarFields.CopyToDCList(doCommit);
			}

			pDataContract.IsAdvisedOrAttended        = _IsAdvised;
            pDataContract.AssistanceBegin            = _AssistanceBegin;
			pDataContract.TerminationDate            = _TerminationDate;
			pDataContract.TerminationReason          = _TerminationReason;
			pDataContract.EinkommenBeginnType		 = _EinkommenBeginnType;
			pDataContract.EinkommenEndeType			 = _EinkommenEndeType;
			pDataContract.FremdHilfeType			 = _FremdHilfeType;
			pDataContract.SozSchwierigkeitenType	 = _SozSchwierigkeitenType;
			pDataContract.SozBeziehungenType		 = _SozBeziehungenType;
			pDataContract.ErstaufnahmeType			 = _ErstaufnahmeType;
			pDataContract.RegionType				 = _RegionType;
			pDataContract.DebitorNumber              = _DebitorNumber;
			pDataContract.CostCenter                 = _CostCenter;
			pDataContract.ICD10DiagnosisCodes        = ICD10Codes.ToList();
			pDataContract.Medication                 = _Medication;
			pDataContract.Environment                = _Environment;
			pDataContract.AssessmentSheetCategoryDCs = _AssessmentSheetCategories.Where(i => i.IsSelected).ToList();
            pDataContract.Type = PersonType.Customer;

			if(_Medikamentenverordnungslisten != null)
			{
			    pDataContract.Medikamentenverordnungslisten = _Medikamentenverordnungslisten.ToList();
			}

			pDataContract.Medikamentenverordnungslisten = _MedVerordnungslisten.CopyToDCList(doCommit);

			foreach (var vm in _IndividualAssessmentSheetCategories.VMList)
			{
				var dc = vm.CommitToDataContract();
				dc.ScopeType = ScopeTypeId.Individual;

				pDataContract.AssessmentSheetCategoryDCs.Add(dc);
			}

            if(_Arbeitszeiten != null)
            {
                pDataContract.Arbeitszeiten = _Arbeitszeiten.CopyToDCList(doCommit);
            }

			if (_CustomerGemeinnutzigeArbeitListVM != null)
			{
				pDataContract.CustomerVermittlungArbeitDC = _CustomerGemeinnutzigeArbeitListVM.CopyToDCList(doCommit);
			}

			if (_CustomerWohnhilfeListVM != null)
            {
				pDataContract.CustomerWohnhilfeDC = _CustomerWohnhilfeListVM.CopyToDCList(doCommit);
            }

            return pDataContract;
		}
		private void CommitContact(string pValue, ContactType pContactType)
		{
			var lOldContactDCs = DataContract.ContactInformations != null ? DataContract.ContactInformations.ToList() : new List<ContactDC>();

			var lContactDC = lOldContactDCs.SingleOrDefault(con => con.ContactType == pContactType);

			if (string.IsNullOrEmpty(pValue) && lContactDC != null)
			{
				lOldContactDCs.Remove(lContactDC);
			}
			else if (!string.IsNullOrEmpty(pValue))
			{
				if (lContactDC == null)
				{
					lContactDC = new ContactDC
					{
						ContactType = pContactType 
					};

					lOldContactDCs.Add(lContactDC);
				}

				lContactDC.ContactValue = pValue;
			}

			DataContract.ContactInformations = lOldContactDCs;
		}
		private void Log(string log)
		{
			if (_EnableLogging && _Log != null)
			{
				if (_Log.Length > 0)
				{
				    _Log.Append("\n");
				}

				_Log.Append(log);
			}
		}
	}
}