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.ViewModel.ListViewModel;

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

namespace BeWo.ViewModel
{
	public class CustomerVM : AbstractDCMapperVM<CustomerDC>
	{
		#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_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_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_IsAttended                    = "IsAttended";
        public static string PropertyName_IsFemale                      = "IsFemale";
        public static string PropertyName_IsMale                        = "IsMale";
        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_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_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";
	   
		#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                                     _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 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                                       _IsAttended;
        private bool                                       _IsFemale;
        private bool                                       _IsMale;
		private CompactOrganisationDC                      _Jugendamt;
		private string                                     _Kindesmutter;
        private string                                     _Kindesvater;
        private string                                     _LastName;
		private StringBuilder                              _Log;
		private string                                     _Medication;
		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 bool                                       employeeRelationsSet;
        private DateTime?                                  _AssistanceBegin;
        private string                                     _AusstVersAmt;
        private DateTime?                                  _AusweisGueltigVon;
        private DateTime?                                  _AusweisGueltigBis;
        private bool                                       _AusweisUnbefristetGueltig;
        private DateTime?                                  _BeiblattGueltigBis;
        private string                                     _GradDerBehinderung;
        private ObservableCollection<Merkzeichen>          _MerkzeichenListe;
        private ObservableCollection<Behinderungsart>      _BehinderungsartenListe;
	    private string                                     _CustomerAlias;
        private Pflegegrad?                                _Pflegegrad;
        private byte[]                                     _CustomerImage;
	 

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

		    _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);

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

        //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 { return _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 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
			{
				employeeRelationsSet = true;
				_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 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 { return _IsArchived; }

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

		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, _EnvironmentOrganisations, _AbsenceTimes, CostBearers, _PlacementList, _VarFields, _IndividualAssessmentSheetCategories))
				{
					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;
			}
		}

		public bool IsFemale
		{
			get { return _IsFemale; }

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

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

					FirePropertyChanged(PropertyName_IsFemale);
					FirePropertyChanged(PropertyName_IsMale);
				}
			}
		}

		public bool IsMale
		{
			get { return _IsMale; }

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

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

					FirePropertyChanged(PropertyName_IsFemale);
					FirePropertyChanged(PropertyName_IsMale);
				}
			}
		}

		[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 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 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 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 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.CustomerImage, value), PropertyName_CustomerImage);
                    FirePropertyChanged(PropertyName_CustomerImage);
                }
            }
        }

      


        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;
		}
        
		#region Medikamentenverordnungslisten
		
		private MedikamentenverordnungslisteListVM _MedVerordnungslisten;

		public MedikamentenverordnungslisteListVM MedVerordnungslisten
		{
			get { return _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)
			{
				_DateOfBirth              = pDataContract.DateOfBirth;
				_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;
                _CustomerImage            = pDataContract.CustomerImage;
			    

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

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

				_IsArchived        = pDataContract.ActivationType == ActivationTypeId.Archived;
                _IsMale            = pDataContract.Sex == Sex.Male;
				_IsFemale          = pDataContract.Sex == Sex.Female;
                _IsAdvised         = pDataContract.IsAdvisedOrAttended == null || pDataContract.IsAdvisedOrAttended.Value;
                _IsAttended        = !IsAdvised;
                _DebitorNumber     = pDataContract.DebitorNumber;
				_CostCenter        = pDataContract.CostCenter;
			    _AssistanceBegin   = pDataContract.AssistanceBegin;
				_TerminationDate   = pDataContract.TerminationDate;
				_TerminationReason = pDataContract.TerminationReason;

                _AusstVersAmt              = pDataContract.AusstVersAmt;
                _AusweisGueltigVon         = pDataContract.AusweisGueltigVon;
                _AusweisGueltigBis         = pDataContract.AusweisGueltigBis;
			    _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>()));

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

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

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

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

		}

	    protected override CustomerDC MapToDataContract(CustomerDC pDataContract, bool doCommit)
		{
			pDataContract.DateOfBirth               = _DateOfBirth;
			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            = _IsArchived ? ActivationTypeId.Archived : ActivationTypeId.Active;
		    pDataContract.AusstVersAmt              = _AusstVersAmt;
		    pDataContract.AusweisGueltigVon         = _AusweisGueltigVon;
		    pDataContract.AusweisGueltigBis         = _AusweisGueltigBis;
		    pDataContract.AusweisUnbefristetGueltig = _AusweisUnbefristetGueltig;
		    pDataContract.BeiblattGueltigBis        = _BeiblattGueltigBis;
		    pDataContract.GradDerBehinderung        = _GradDerBehinderung;
		    if (_MerkzeichenListe != null)
		    {
			    pDataContract.MerkzeichenListe = _MerkzeichenListe.ToList();
		    }
		    if (_BehinderungsartenListe != null)
		    {
			    pDataContract.BehinderungsartenListe = _BehinderungsartenListe.ToList();
		    }
		    pDataContract.CustomerAlias             = _CustomerAlias;
            pDataContract.Pflegegrad                = _Pflegegrad;
            pDataContract.CustomerImage             = _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;
		    }

		    pDataContract.RelatedEmployees         = _EmployeeRelations.CopyToDCList(doCommit);
			pDataContract.RelatedTeams             = _TeamRelations.CopyToDCList(doCommit);
			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.DebitorNumber              = _DebitorNumber;
			pDataContract.CostCenter                 = _CostCenter;
			pDataContract.ICD10DiagnosisCodes        = ICD10Codes.ToList();
			pDataContract.Medication                 = _Medication;
			pDataContract.Environment                = _Environment;
			pDataContract.AssessmentSheetCategoryDCs = _AssessmentSheetCategories.Where(i => i.IsSelected).ToList();

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

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