BeWoPlaner/BeWo/ViewModel/ServiceRecordVM.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using BeWo.Core;
using BeWo.Core.Service;
using BeWo.Validation;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.ClientPartials;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using Brush = System.Windows.Media.Brush;
using Brushes = System.Windows.Media.Brushes;
using Color = System.Windows.Media.Color;

namespace BeWo.ViewModel
{
    // Claude: ICustomerRelatedContext -> steuert die Dokumentationspflicht beim Bearbeiten
    public class ServiceRecordVM : AbstractDCMapperVM<ServiceRecordDC>, ICustomerRelatedContext
    {
        public String ATEST { get; set; }
        #region Constants and Fields

        public static string PropertyName_Category = "Category";

        public static string PropertyName_Category2Services = "Category2Services";

        public static string PropertyName_SortedCategories = "SortedCategories";

        public static string PropertyName_CostBearer = "CostBearer";

        public static string PropertyName_Customer = "Customer";

        public static string PropertyName_Duration = "Duration";

        public static string PropertyName_Employee = "Employee";

        public static string PropertyName_GoalTree = "GoalTree";

        public static string PropertyName_GroupEmployeeCount = "GroupEmployeeCount";

        public static string PropertyName_GroupPersonCount = "GroupPersonCount";

        public static string PropertyName_GroupRoundedDuration = "GroupRoundedDuration";

        public static string PropertyName_IsGoalTreeVisible = "IsGoalTreeVisible";

        public static string PropertyName_Notice = "Notice";

        public static string PropertyName_Notice2 = "Notice2";

        public static string PropertyName_Notice3 = "Notice3";

        public static string PropertyName_Notice4 = "Notice4";

        public static string PropertyName_Notice5 = "Notice5";

        public static string PropertyName_RTFNotice = "RTFNotice";

        public static string PropertyName_RTFNotice2 = "RTFNotice2";

        public static string PropertyName_RTFNotice3 = "RTFNotice3";

        public static string PropertyName_RTFNotice4 = "RTFNotice4";

        public static string PropertyName_RTFNotice5 = "RTFNotice5";

        public static string PropertyName_PossibleCostBearers = "PossibleCostBearers";

        public static string PropertyName_PossibleCustomers = "PossibleCustomers";

        public static string PropertyName_PossibleServiceDescriptions = "PossibleServiceDescriptions";

        public static string PropertyName_PossibleSupportConcepts = "PossibleSupportConcepts";

        public static string PropertyName_RoundedDuration = "RoundedDuration";

        public static string PropertyName_SelectedGoals = "SelectedGoals";

        public static string PropertyName_ServiceDescription = "ServiceDescription";

        public static string PropertyName_SupportConcept = "SupportConcept";

        public static string PropertyName_ServiceRecordType = "ServiceRecordType";

        public static string PropertyName_IsServiceRecordTypeDefaultActivity = "IsServiceRecordTypeDefaultActivity";

        public static string PropertyName_IsServiceRecordTypeContent = "IsServiceRecordTypeContent";

        public static string PropertyName_DistanceInMeter = "DistanceInMeter";

        public static string PropertyName_DauerEinheit = "DauerEinheit";

        public static string PropertyName_ServiceRecordFormat = "ServiceRecordFormat";

        public static string PropertyName_OnlyMonth = "OnlyMonth";

        public static string PropertyName_OnlyYear = "OnlyYear";

        public static string PropertyName_DurationMonthYearGes = "DurationMonthYearGes";

        public static string PropertyName_Betrag = "Betrag";

        public static string PropertyName_EditStartDate = "EditStartDate";

        public static string PropertyName_EditEndDate = "EditEndDate";

        public static string PropertyName_StartTimeString = "StartTimeString";

        public static string PropertyName_EndTimeString = "EndTimeString";

        private static readonly DateTime NULL_TIME = new DateTime(2000, 1, 1, 0, 0, 1);

        private static BitmapImage haekchenBitmapImage = null;

        private Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>> _Category2Services;

        //private readonly List<SupportConceptTreeNodeDC> _Tree;

        private List<ValueListEntryDC> _AllGoalCategories;

        private List<ValueListEntryDC> _AllGoals;

        private ServiceCategoryDC _Category;

        private FlatSupportConceptTreeNodeDC _ChoosenNode;

        private CompactOrganisationDC _CostBearer;

        private CompactCustomerDC _Customer;

        private bool _DeleteAllowed = true;

        private decimal _Duration;

        private bool _EditAllowed = true;

        private CompactEmployeeDC _Employee;

        private List<SupportConceptGoalDC> _GoalTree;

        private int? _GroupEmployeeCount;

        private long? _GroupOid;

        private long? _SignatureOid;

        private int? _GroupPersonCount;

        private decimal? _GroupRoundedDuration;

        private string _InsUser;

        private DateTime? _InsertedOn;

        private string _Notice;

        private string _Notice2;

        private string _Notice3;

        private string _Notice4;

        private string _Notice5;

        private string _RTFNotice;

        private string _RTFNotice2;

        private string _RTFNotice3;

        private string _RTFNotice4;

        private string _RTFNotice5;

        private decimal? _Betrag;

        private decimal _RoundedDuration;

        private ObservableSortCollection<ValueListEntryDC> _SelectedGoals;

        private ServiceDescriptionDC _ServiceDescription;

        private CompactSupportConceptDC _SupportConcept;

        private ServiceRecordTypeId _ServiceRecordType = ServiceRecordTypeId.DefaultActivity;

        public List<ServiceAccountingDC> _ServiceAccountings;

        private decimal? _DistanceInMeter;

        private ZeiterfassungsDauer _DauerEinheit = ZeiterfassungsDauer.Minuten;

        private ServiceRecordFormate _ServiceRecordFormat;

        private string _OnlyMonth;

        private string _OnlyYear;

        private decimal? _DurationMonthYearGes;

        private DateTime? _StartDate;

        private DateTime? _EndDate;

        private DateTime? _EditStartDate;

        private DateTime? _EditEndDate;

        private string _StartTimeString;

        private string _EndTimeString;

        private List<SupportConceptPeriodStatisticsVM> _Statistics;

        private string[] _MonateBinden =
        {
            "Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November",
            "Dezember"
        };

        #endregion

        #region Constructors and Destructors

        public ServiceRecordVM()
        {
            DataContract = new ServiceRecordDC { Notice = "" };
            _Duration = 0;
        }

        public ServiceRecordVM(
            ServiceRecordDC pDC,
            Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>> pCategory2Services,
            List<ValueListEntryDC> pAllGoalCategories,
            List<ValueListEntryDC> pAllGoals)
            : base(pDC, pDC.ServiceRecordOid == null)
        {
            EditAlwaysAllowed = false;

            _Category2Services = pCategory2Services;

            ChangeGoalTree(pAllGoalCategories, pAllGoals);
        }

        #endregion

        #region Properties

        public override bool IsDirty
        {
            get { return base.IsDirty || !SameRatingChecked(SelectedGoals, this.DataContract.Goals); }
        }

        public decimal? DistanceInMeter
        {
            get { return _DistanceInMeter; }

            set
            {
                if (AreDifferent(_DistanceInMeter, value))
                {
                    _DistanceInMeter = value;
                    StoreDirtyInformation(AreDifferent(DataContract.DistanceInMeterDecimal, value),
                        PropertyName_DistanceInMeter);
                    FirePropertyChanged(PropertyName_DistanceInMeter);
                }
            }
        }

        public decimal AssistanceDuration
        {
            get
            {
                if (GroupOid != null)
                {
                    return RoundedDuration;
                }

                //if (_Duration != null)
                //{
                    return Duration;
                //}

                //return 0;
            }
        }

        //ALT Das kann irgendwann weg
        public Brush BackgroundBrush
        {
            get
            {
                Brush brush = null;
                //if (_GroupOid != null)
                //{
                //    brush = Application.Current.FindResource("GroupBookingBackgroundBrush") as Brush;
                //}
                if (!String.IsNullOrEmpty(BackgroundColor))
                {
                    return new SolidColorBrush((Color)System.Windows.Media.ColorConverter.ConvertFromString(BackgroundColor));
                }
                return brush ?? Brushes.White;
            }
        }

        public String BackgroundColor
        {
            get; set;
        }

        public String CategoryString
        {
            get { return _Category != null ? _Category.ToString() : null; }
        }

        public String ServiceDescriptionString
        {
            get { return _ServiceDescription != null ? _ServiceDescription.ToString() : null; }
        }

        public List<ValueListEntryDC> AllGoalCategories
        {
            get { return _AllGoalCategories; }

            set { _AllGoalCategories = value; }
        }

        public List<ValueListEntryDC> AllGoals
        {
            get { return _AllGoals; }

            set { _AllGoals = value; }
        }

        public ServiceCategoryDC Category
        {
            get { return _Category; }

            set
            {
                if (AreDifferent(_Category, value))
                {
                    _Category = value;
                    ServiceDescription = null;
                    FirePropertyChanged(PropertyName_Category);
                    FirePropertyChanged(PropertyName_PossibleServiceDescriptions);
                }
            }
        }

        public Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>> Category2Services
        {
            get { return _Category2Services; }
            set
            {
                _Category2Services = value;
                FirePropertyChanged(PropertyName_Category2Services);
                FirePropertyChanged(PropertyName_SortedCategories);
                FirePropertyChanged(PropertyName_PossibleServiceDescriptions);
            }
        }

        public IList<ServiceCategoryDC> SortedCategories
        {
            get
            {
                return Category2Services != null ? Category2Services.Keys.OrderBy(cat => cat.Position).ToList() : null;
            }
        }

        public FlatSupportConceptTreeNodeDC ChoosenNode
        {
            get { return _ChoosenNode; }

            set
            {
                _ChoosenNode = value;

                if (value != null)
                {
                    if (value.SupportConceptTreeNodeDC != null)
                    {
                        if (Employee == null)
                        {
                            Employee = value.SupportConceptTreeNodeDC.Employee;
                        }

                        Customer = value.SupportConceptTreeNodeDC.Customer;
                        SupportConcept = value.SupportConceptTreeNodeDC.SupportConcept;
                        CostBearer = value.SupportConceptTreeNodeDC.CostBearer;
                    }
                }
                else
                {
                    Employee = null;
                    Customer = null;
                    SupportConcept = null;
                    CostBearer = null;
                }
            }
        }

        public CompactOrganisationDC CostBearer
        {
            get { return _CostBearer; }

            set
            {
                if (AreDifferent(_CostBearer, value))
                {
                    _CostBearer = value;
                    StoreDirtyInformation(!AreEqual(DataContract.CostBearer, value), PropertyName_CostBearer);
                    FirePropertyChanged(PropertyName_CostBearer);
                    FirePropertyChanged(PropertyName_RoundedDuration);
                }
            }
        }

        [Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
        public CompactCustomerDC Customer
        {
            get { return _Customer; }

            set
            {
                if (AreDifferent(_Customer, value))
                {
                    _Customer = value;
                    StoreDirtyInformation(!AreEqual(DataContract.Customer, value), PropertyName_Customer);
                    FirePropertyChanged(PropertyName_Customer);
                }
            }
        }

        public DateTime StartDate
        {
            get
            {
                var date = _EditStartDate ?? DateTime.Now.Date;

                if (!String.IsNullOrEmpty(_StartTimeString))
                {
                    String dtStr = String.Format("{0:dd.MM.yyyy} {1}", date, _StartTimeString);
                    DateTime dt;

                    if (DateTime.TryParse(dtStr, out dt))
                        _StartDate = dt;
                    else
                        _StartDate = date.Date.AddSeconds(1);
                }
                else
                {
                    _StartDate = date.Date.AddSeconds(1);
                }

                return _StartDate.Value;
            }
        }

        public DateTime EndDate
        {
            get
            {
                var date = _EditEndDate ?? DateTime.Now.Date;

                if (!String.IsNullOrEmpty(_EndTimeString))
                {
                    String dtStr = String.Format("{0:dd.MM.yyyy} {1}", date, _EndTimeString);
                    DateTime dt;

                    if (DateTime.TryParse(dtStr, out dt))
                        _EndDate = dt;
                    else
                        _EndDate = date.Date.Date.AddSeconds(1);
                }
                else
                {
                    if (date.Second == 0)
                    {
                        date = date.AddSeconds(1);
                    }
                    _EndDate = date;
                }

                return _EndDate.Value;
            }
        }

        public DateTime RoundedEndDate
        {
            get
            {
                var date = StartDate;
                if (this.GroupRoundedDuration.HasValue)
                {
                    return date.AddMinutes((double)GroupRoundedDuration);
                }
                return date.AddMinutes((double)RoundedDuration);
            }
        }

        public DateTime? StartMinutes
        {
            get
            {
                if (StartDate.Second == 0)
                {
                    return StartDate;
                }
                return null;
            }
        }

        public DateTime? RoundedEndMinutes
        {
            get
            {
                if (RoundedEndDate.Second == 0)
                {
                    return RoundedEndDate;
                }

                return null;
            }
        }

        public DateTime? EditStartDate
        {
            get { return _EditStartDate; }

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


                    if (_EditStartDate.HasValue)
                    {
                        var newEnddate = _EditStartDate.Value.Date;
                        
                        if (BeWoApp.AppSettings.IsEndDateVisible || ServiceRecordFormat == ServiceRecordFormate.ZeiterfassungMitEndDatum)
                        {
                            if (!EditEndDate.HasValue || value.Value.Date > EditEndDate.Value.Date)
                            {
                                _EditEndDate = new DateTime(value.Value.Year, value.Value.Month, value.Value.Day, newEnddate.Hour, newEnddate.Minute, newEnddate.Second);

                                FirePropertyChanged(PropertyName_EditEndDate);
                            }
                        }
                        else
                        {
                            _EditEndDate = _EditStartDate;
                            if (Duration > 0)
                            {
                                if (DauerEinheit == ZeiterfassungsDauer.Minuten)
                                    _EditEndDate = _EditStartDate.Value.Date.AddMinutes((double)Duration);
                                else
                                    _EditEndDate = _EditStartDate.Value.Date.AddHours((double)Duration);

                            }

                            if (String.IsNullOrEmpty(_EndTimeString) && _EditEndDate.Value.Second == 0)
                            {
                                _EditEndDate = _EditEndDate.Value.AddSeconds(1);
                            }
                            FirePropertyChanged(PropertyName_EditEndDate);
                        }

                    }



                    StoreDirtyInformation(!AreEqual(DataContract.Start, EditStartDate), PropertyName_EditStartDate);
                    FirePropertyChanged(PropertyName_EditStartDate);
                    UpdateDurationAfterDateChange();
                }
            }
        }

        public DateTime? EditEndDate
        {
            get { return _EditEndDate; }
            set
            {

                if (AreDifferent(_EditEndDate, value))
                {
                    _EditEndDate = value;

                    if (BeWoApp.AppSettings.IsEndDateVisible ||
                        ServiceRecordFormat == ServiceRecordFormate.ZeiterfassungMitEndDatum)
                    {
                        if (_EditEndDate.HasValue)
                        {
                            var newStartdate = _EditEndDate.Value.Date;
                            if (EditStartDate.HasValue)
                            {
                                newStartdate = EditStartDate.Value;
                            }

                            if (!EditStartDate.HasValue || value.Value.Date < EditStartDate.Value.Date)
                            {
                                _EditStartDate = new DateTime(value.Value.Year, value.Value.Month, value.Value.Day,
                                    newStartdate.Hour, newStartdate.Minute, newStartdate.Second);

                                FirePropertyChanged(PropertyName_EditStartDate);
                            }

                        }
                    }

                    StoreDirtyInformation(!AreEqual(DataContract.End, EditEndDate), PropertyName_EditEndDate);
                    FirePropertyChanged(PropertyName_EditEndDate);
                    UpdateDurationAfterDateChange();
                }

            }
        }

        public String StartTimeString
        {
            get { return _StartTimeString; }

            set
            {
                String newTime = value;

                //if (!String.IsNullOrEmpty(newTime) && String.IsNullOrEmpty(EndTimeString))
                //{
                //    _StartTimeString = newTime;
                //    FirePropertyChanged(PropertyName_StartTimeString);
                //    return;
                //}

                
                if (!String.IsNullOrEmpty(newTime))
                {
                    var dtStr = String.Format("{0:dd.MM.yyyy} {1}", DateTime.Now.Date, newTime);
                    DateTime dt;
                    if (DateTime.TryParse(dtStr, out dt))
                    {
                        newTime = String.Format("{0:HH:mm}", dt);
                    }
                }
                
                if (AreDifferent(_StartTimeString, newTime))
                {
                    _StartTimeString = newTime;

                    StoreDirtyInformation(!AreEqual(String.Format("{0:HH:mm}", DataContract.Start), value), PropertyName_StartTimeString);
                    FirePropertyChanged(PropertyName_StartTimeString);
                    CheckEndDateAfterStartDateChange();
                    UpdateDurationAfterDateChange();
                }

                
            }
        }

        private void CheckEndDateAfterStartDateChange()
        {
            if (!String.IsNullOrEmpty(StartTimeString) && String.IsNullOrEmpty(EndTimeString))
            {
                var endTimeString = StartTimeString;

                if (Duration > 0)
                {
                    UpdateEndTimeStringAfterDurationChange();
                    //var dtStr = String.Format("{0:dd.MM.yyyy} {1}", DateTime.Now.Date, endTimeString);
                    //DateTime dt;
                    //if (DateTime.TryParse(dtStr, out dt))
                    //{


                    //    endTimeString = String.Format("{0:HH:mm}", dt);
                    //}


                }
                else
                {
                    EndTimeString = endTimeString;
                }

            }
            else if (!String.IsNullOrEmpty(StartTimeString) && !String.IsNullOrEmpty(EndTimeString))
            {
                if (StartDate > EndDate)
                {
                    EndTimeString = StartTimeString;
                    EditEndDate = EditStartDate;
                }
            }
            else if (String.IsNullOrEmpty(StartTimeString) && !String.IsNullOrEmpty(EndTimeString))
            {
                _EndTimeString = "";
                if (DauerEinheit == ZeiterfassungsDauer.Minuten)
                    EditEndDate = StartDate.Date.AddMinutes((double) Duration).AddSeconds(1);
                else
                    EditEndDate = StartDate.Date.AddHours((double) Duration).AddSeconds(1);
                FirePropertyChanged(PropertyName_EndTimeString);
            }
            else if (String.IsNullOrEmpty(StartTimeString) && String.IsNullOrEmpty(EndTimeString))
            {
                if (DauerEinheit == ZeiterfassungsDauer.Minuten)
                    EditEndDate = StartDate.Date.AddMinutes((double)Duration).AddSeconds(1);
                else
                    EditEndDate = StartDate.Date.AddHours((double)Duration).AddSeconds(1);
            }
        }

        public String EndTimeString
        {
            get { return _EndTimeString; }

            set
            {
                String newTime = value;

                if (String.IsNullOrEmpty(newTime) && !String.IsNullOrEmpty(StartTimeString))
                {
                    _EndTimeString = newTime;
                    FirePropertyChanged(PropertyName_EndTimeString);
                    return;
                }
                if (!String.IsNullOrEmpty(newTime))
                {
                    var dtStr = String.Format("{0:dd.MM.yyyy} {1}", DateTime.Now.Date, newTime);
                    DateTime dt;
                    if (DateTime.TryParse(dtStr, out dt))
                    {
                        newTime = String.Format("{0:HH:mm}", dt);
                    }
                }
                
                if (AreDifferent(_EndTimeString, newTime))
                {
                    _EndTimeString = newTime;
                    StoreDirtyInformation(!AreEqual(String.Format("{0:HH:mm}", DataContract.End), value), PropertyName_EndTimeString);
                    FirePropertyChanged(PropertyName_EndTimeString);
                    CheckStartDateAfterEndDateChange();
                    UpdateDurationAfterDateChange();
                    UpdateEndDateWithDuration();
                }

                
            }
        }

        private void CheckStartDateAfterEndDateChange()
        {
            if (!String.IsNullOrEmpty(EndTimeString) && String.IsNullOrEmpty(StartTimeString))
            {
                StartTimeString = EndTimeString;
            }
            else if (!String.IsNullOrEmpty(StartTimeString) && !String.IsNullOrEmpty(EndTimeString))
            {
                if (StartDate > EndDate)
                {
                    StartTimeString = EndTimeString;
                    EditEndDate = EditStartDate;
                }
            }
            else if (!String.IsNullOrEmpty(StartTimeString) && String.IsNullOrEmpty(EndTimeString))
            {
                
                //_StartTimeString = "";
                UpdateEndDateWithDuration();
                FirePropertyChanged(PropertyName_StartTimeString);
            }
        }

        private void UpdateEndDateWithDuration()
        {
            DateTime newEndDate = DateTime.MinValue;
            if (Duration > 0)
            {
                if (String.IsNullOrEmpty(StartTimeString))
                {
                    newEndDate = StartDate.Date;
                }
                else
                {
                    newEndDate = StartDate;
                }

                if (DauerEinheit == ZeiterfassungsDauer.Minuten)
                    newEndDate = newEndDate.AddMinutes((double)Duration);
                else
                    newEndDate = newEndDate.AddHours((double)Duration);

                if (String.IsNullOrEmpty(_EndTimeString) && newEndDate.Second == 0)
                {
                    newEndDate = newEndDate.AddSeconds(1);
                }

                EditEndDate = newEndDate;

            }
            else
            {
                EditEndDate = EditStartDate;
            }
        }

        private void UpdateDurationAfterDateChange()
        {
            var x = EndDate.Subtract(StartDate);
            decimal newDuration = 0;
            if (DauerEinheit == ZeiterfassungsDauer.Minuten)
            {
                newDuration = (decimal) x.TotalMinutes;
            }
            else
            {
                newDuration = (decimal) x.TotalHours;
            }

            if (_Duration != newDuration)
            {
                _Duration = newDuration;
                FirePropertyChanged(PropertyName_Duration);
            }
        }

        private void UpdateEndTimeStringAfterDurationChange()
        {
            var date = StartDate;
            
            if (DauerEinheit == ZeiterfassungsDauer.Minuten)
                _EditEndDate = date.AddMinutes((double)_Duration);
            else
                _EditEndDate = date.AddHours((double)_Duration);

            FirePropertyChanged(PropertyName_EditEndDate);

            if (!String.IsNullOrEmpty(EndTimeString) || StartDate.Second == 0)
            {
                _EndTimeString = String.Format("{0:HH:mm}", _EditEndDate);
                FirePropertyChanged(PropertyName_EndTimeString);
            }
            
        }

        public String Id
        {
            get { return String.Format("{0}", DataContract.ServiceRecordOid); }
        }

        [Validation(ValidationRule = ValidationRules.GreaterThanOrEqualZero)]
        public decimal Duration
        {
            get
            {
                return _Duration;
            }

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

                    UpdateEndTimeStringAfterDurationChange();
                    StoreDirtyInformation(!AreEqual(String.Format("{0:HH:mm}", DataContract.End), EndTimeString), PropertyName_EndTimeString);
                    FirePropertyChanged(PropertyName_Duration);
                    FirePropertyChanged(PropertyName_RoundedDuration);

                }
            }
        }


        public string DurationAndRoundedDuration
        {
            get
            {
                var rd = BeWoWpfUtils.GetDecimalValueWithMaxDecimal(RoundedDuration, 2);

                if (Category != null && Category.Percentage > 0 && Category.Percentage < 100)
                {
                    rd = rd * Category.Percentage / 100;
                }

                //if(_ServiceRecordFormat == ServiceRecordFormate.ZeiterfassungMitEndDatum) { 

                //    var strResult = _GroupOid != null ? string.Format("{0} ({0})", rd) : $"{DurationSTD} ({rd})";

                //    return strResult;
                //}

                if (_ServiceRecordFormat == ServiceRecordFormate.ZeiterfassungMitMonatJahr)
                {
                    var strResult = _GroupOid != null
                        ? string.Format("{0:0.##} ({0:0.##})", rd)
                        : $"{DurationMonthYearGes} ({rd})";

                    return strResult;
                }

                if (DauerEinheit == ZeiterfassungsDauer.Stunden)
                {
                    return _GroupOid != null
                        ? string.Format("{0:0.##} ({0:0.##})", rd / 60)
                        : $"{Duration:0.##} ({rd / 60:0.##})";
                }

                return _GroupOid != null ? $"{rd} ({rd})" : $"{Duration} ({rd})";
            }
        }

        public bool EditAlwaysAllowed { get; set; }

        public bool EditAllowed
        {
            get
            {
                if (EditAlwaysAllowed)
                {
                    return true;
                }

                var allowed = false;

                if (BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecordView_Edit))
                {
                    allowed = true;
                }
                else if (BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowChangeWithin24Hours))
                {
                    if (_InsertedOn != null)
                    {
                        if (DateTime.Now < _InsertedOn.Value.AddHours(BeWoApp.AppSettings.ServiceRecordAllowChangeHours))
                        {
                            allowed = true;
                        }
                    }
                }

                if (allowed && BeWoApp.AppSettings.MaxDaysEditServiceRecordsAllowed > 0)
                {
                    if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowEditAfterMaxDaysInNextMonth))
                    {
                        var dt = new DateTime(StartDate.Year, StartDate.Month, 1);
                        dt = dt.AddMonths(1);
                        dt = dt.AddDays(BeWoApp.AppSettings.MaxDaysEditServiceRecordsAllowed);
                        if (DateTime.Now >= dt)
                        {
                            allowed = false;
                        }
                    }
                }

                if (allowed && !BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowEditForOtherEmployees))
                {
                    if (BeWoApp.LoggedOnEmployee.EmployeeOid != Employee.EmployeeOid)
                        allowed = false;
                }

                if (allowed && GroupOid.HasValue)
                {
                    if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowCreatingGroupBooking))
                    {
                        allowed = false;
                    }
                }

                if (allowed && BeWoApp.AppSettings.AnzTageZeiterfassErfolgt > 0 && this.SupportConcept != null)
                {
                    if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecordAllowEditAfterMindays))
                    {
                        
                        var dt = new DateTime(StartDate.Year, StartDate.Month, StartDate.Day);
                        dt = dt.AddDays(BeWoApp.AppSettings.AnzTageZeiterfassErfolgt + 1);
                        if (DateTime.Now >= dt)
                        {
                            allowed = false;
                        }
                    }
                }

                return _EditAllowed && allowed;
            }

            set { _EditAllowed = value; }
        }

        public bool DeleteAllowed
        {
            get
            {
                var allowed = false;
                if (BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecordView_Delete))
                {
                    allowed = true;
                }
                else if (BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowChangeWithin24Hours))
                {
                    if (_InsertedOn != null)
                    {
                        if (DateTime.Now < _InsertedOn.Value.AddHours(BeWoApp.AppSettings.ServiceRecordAllowChangeHours))
                        {
                            allowed = true;
                        }
                    }
                }

                if (allowed && BeWoApp.AppSettings.MaxDaysEditServiceRecordsAllowed > 0)
                {
                    if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowEditAfterMaxDaysInNextMonth))
                    {
                        if (StartDate != null)
                        {
                            var dt = new DateTime(StartDate.Year, StartDate.Month, 1);
                            dt = dt.AddMonths(1);
                            dt = dt.AddDays(BeWoApp.AppSettings.MaxDaysEditServiceRecordsAllowed);
                            if (DateTime.Now >= dt)
                            {
                                allowed = false;
                            }
                        }
                    }
                }

                if (allowed && BeWoApp.AppSettings.AnzTageZeiterfassErfolgt > 0)
                {
                    if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecordAllowEditAfterMindays))
                    {
                        if (StartDate != null)
                        {
                            var dt = new DateTime(StartDate.Year, StartDate.Month, StartDate.Day);
                            dt = dt.AddDays(BeWoApp.AppSettings.AnzTageZeiterfassErfolgt + 1);
                            if (DateTime.Now >= dt)
                            {
                                allowed = false;
                            }
                        }
                    }
                }

                if (allowed && !BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowEditForOtherEmployees))
                {
                    if (BeWoApp.LoggedOnEmployee.EmployeeOid != Employee.EmployeeOid)
                        allowed = false;
                }

                if (allowed && GroupOid.HasValue)
                {
                    if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowCreatingGroupBooking))
                    {
                        allowed = false;
                    }
                }

                return _DeleteAllowed && allowed;
            }

            set { _DeleteAllowed = value; }
        }

        public static bool IsHistoryAllowed
        {
            get { return BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_ShowHistory); }
        }

        [Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
        public CompactEmployeeDC Employee
        {
            get { return _Employee; }

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

                    StoreDirtyInformation(!AreEqual(DataContract.Employee, value), PropertyName_Employee);
                    FirePropertyChanged(PropertyName_Employee);
                }
            }
        }

        public string EmployeeName
        {
            get
            {
                if (_Employee != null)
                {
                    return _Employee.FirstName + " " + _Employee.LastName;
                }

                return string.Empty;
            }
        }
    

        public List<SupportConceptGoalDC> GoalTree
        {
            get { return _GoalTree; }

            set
            {
                _GoalTree = value;
                FirePropertyChanged(PropertyName_GoalTree);
                FirePropertyChanged(PropertyName_IsGoalTreeVisible);
            }
        }

        public int? GroupEmployeeCount
        {
            get { return _GroupEmployeeCount; }

            set
            {
                if (AreDifferent(_GroupEmployeeCount, value))
                {
                    _GroupEmployeeCount = value;
                    StoreDirtyInformation(AreDifferent(DataContract.GroupEmployeeCount, value), PropertyName_GroupEmployeeCount);
                    FirePropertyChanged(PropertyName_GroupEmployeeCount);
                }
            }
        }

        public long? GroupOid
        {
            get { return _GroupOid; }

            set { _GroupOid = value; }
        }

        public long? SignatureOid
        {
            get { return _SignatureOid; }

            set { _SignatureOid = value; }
        }

        public ImageSource HatUnterschriftImage
        {
            get
            {
                if(_SignatureOid != null) { 
                  
                    if (haekchenBitmapImage == null)
                    {
                        haekchenBitmapImage = CreateImage("pack://application:,,,/BeWoPlaner;component/Ressources/Icons/Haeckchen.png");
                    }
                    return haekchenBitmapImage;
                }
                else
                {
                    return null;
                }
            }
        }

        private BitmapImage CreateImage(String path)
        {
            BitmapImage bix = new BitmapImage();
            bix.BeginInit();
            bix.CreateOptions = BitmapCreateOptions.PreservePixelFormat;
            bix.CacheOption = BitmapCacheOption.OnLoad;
            bix.UriSource = new Uri(path);
            bix.EndInit();
            
            return bix;
        }

        public int? GroupPersonCount
        {
            get { return _GroupPersonCount; }

            set
            {
                if (AreDifferent(_GroupPersonCount, value))
                {
                    _GroupPersonCount = value;
                    StoreDirtyInformation(AreDifferent(DataContract.GroupPersonCount, value), PropertyName_GroupPersonCount);
                    FirePropertyChanged(PropertyName_GroupPersonCount);
                }
            }
        }

        public decimal? GroupRoundedDuration
        {
            get { return _GroupRoundedDuration; }

            set
            {
                if (AreDifferent(_GroupRoundedDuration, value))
                {
                    _GroupRoundedDuration = value;
                    StoreDirtyInformation(AreDifferent(DataContract.GroupRoundedDuration, value), PropertyName_GroupRoundedDuration);
                    FirePropertyChanged(PropertyName_GroupRoundedDuration);
                }
            }
        }

        public int Index { get; set; }

        public string InsUser
        {
            get { return _InsUser; }

            set { _InsUser = value; }
        }

        public string InsertedOn
        {
            get
            {
                if (_InsertedOn != null)
                {
                    return _InsertedOn.Value.ToShortDateString() + " " + _InsertedOn.Value.ToShortTimeString();
                }

                return null;
            }
        }

        public DateTime? InsertedOnDateTime
        {
            get { return _InsertedOn; }
        }

        public bool IsGoalTreeVisible
        {
            get { return _GoalTree != null && _GoalTree.Count > 0; }
        }

        public string LongDateString
        {
            get
            {
                var date = string.Empty;
            
                string time = string.Empty;

                string endtime = string.Empty;

                var timeDt = StartDate;

                if (timeDt.Second == 0)
                {
                    time = timeDt.ToShortTimeString();


                    if (DauerEinheit == ZeiterfassungsDauer.Stunden)
                    {
                        if (GroupOid != null && GroupRoundedDuration != null)
                        {
                            timeDt = timeDt.AddMinutes((double)GroupRoundedDuration);
                        }
                        else
                        {
                            timeDt = timeDt.AddMinutes((double)RoundedDuration);
                        }
                    }
                    else
                    {
                        if (GroupOid != null && GroupRoundedDuration != null)
                        {
                            timeDt = timeDt.AddMinutes((double)GroupRoundedDuration);
                        }
                        else
                        {
                            timeDt = timeDt.AddMinutes((double)RoundedDuration);
                        }
                    }
                        
                    endtime = timeDt.ToShortTimeString();

                    //time = time + " - " + timeDt.ToShortTimeString();
                }
                
                
                if (endtime.Equals("") && time.Equals(""))
                {
                    date = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedDayName(StartDate.DayOfWeek) + ", " + StartDate.ToShortDateString(); 
                }
                else {
                    
                    if (EndDate.Date != StartDate.Date)
                    {
                        time = StartDate.TimeOfDay.ToString();
                        endtime = EndDate.TimeOfDay.ToString();

                        date = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedDayName(StartDate.DayOfWeek) + ", " + StartDate.ToShortDateString() + "  " + time + "  -  " + EndDate.ToShortDateString() + "  " + endtime;
                    }
                    else
                    {
                        time = time + "  -  " + endtime;
                        date = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedDayName(StartDate.DayOfWeek) + ", " + StartDate.ToShortDateString() + "  " + time;
                    }

                }
                  

                //date += " " + time;

                if (GroupOid != null && GroupPersonCount != null && GroupRoundedDuration != null)
                {
                    if (DauerEinheit == ZeiterfassungsDauer.Stunden)
                    {
                        date += "   Gruppe (" + GroupPersonCount.Value + " Teilnehmer, " + GroupEmployeeCount.Value +
                                " Betreuer). Dauer: " +
                                BeWoWpfUtils.GetDecimalValueWithMaxDecimal(GroupRoundedDuration.Value / 60, 2) + " Stunden.";
                    }
                    else
                    {
                        date += "   Gruppe (" + GroupPersonCount.Value + " Teilnehmer, " + GroupEmployeeCount.Value +
                                " Betreuer). Dauer: " +
                                BeWoWpfUtils.GetDecimalValueWithMaxDecimal(GroupRoundedDuration.Value, 2) + " Minuten.";
                    }
                }

                return date;
            }
        }

        public Brush MouseOverBackgroundBrush
        {
            get
            {
                Brush brush = null;
                if (_GroupOid != null)
                {
                    brush = Application.Current.FindResource("GroupBookingMouseOverBackgroundBrush") as Brush;
                }

                return brush ?? new SolidColorBrush(Color.FromArgb(0xFF, 0xCC, 0xE0, 0xFF));
            }
        }

        // Claude: Klientenbezug fuer die Dokumentationspflicht beim Bearbeiten eines bestehenden
        // Eintrags (ServiceRecordEditView / ServiceRecordGroupEditView binden direkt an dieses VM).
        // Beim Laden aus dem DataContract ist Customer gesetzt, wenn der Eintrag zu einem
        // Klienten gehoert - kundenlose Eintraege haben Customer == null.
        // Achtung: Am PrototypeVM der Neuerfassung ist Customer immer null; dort liefert
        // ServiceRecordListVM.IsCustomerRelated den Kontext (DataItem hat im AttributeValidator
        // Vorrang), weil der Kunde erst nach der Validierung an den Klon geschrieben wird.
        public bool IsCustomerRelated
        {
            get { return Customer != null; }
        }

        [Validation(ValidationRule = ValidationRules.EmptyNoticeInNewServiceRecordsAllowed)]
        public string Notice
        {
            get { return _Notice; }

            set
            {
                if (AreDifferent(_Notice, value))
                {
                    _Notice = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Notice, value), PropertyName_Notice);
                    FirePropertyChanged(PropertyName_Notice);
                }
            }
        }

        public string Notice2
        {
            get { return _Notice2; }

            set
            {
                if (AreDifferent(_Notice2, value))
                {
                    _Notice2 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Notice2, value), PropertyName_Notice2);
                    FirePropertyChanged(PropertyName_Notice2);
                }
            }
        }
  
        public string Notice3
        {
            get { return _Notice3; }

            set
            {
                if (AreDifferent(_Notice3, value))
                {
                    _Notice3 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Notice3, value), PropertyName_Notice3);
                    FirePropertyChanged(PropertyName_Notice3);
                }
            }
        }

        public string Notice4
        {
            get { return _Notice4; }

            set
            {
                if (AreDifferent(_Notice4, value))
                {
                    _Notice4 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Notice4, value), PropertyName_Notice4);
                    FirePropertyChanged(PropertyName_Notice4);
                }
            }
        }

        public string Notice5
        {
            get { return _Notice5; }

            set
            {
                if (AreDifferent(_Notice5, value))
                {
                    _Notice5 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Notice5, value), PropertyName_Notice5);
                    FirePropertyChanged(PropertyName_Notice5);
                }
            }
        }

        public string DocField1 { get; set; }
        public string DocField2 { get; set; }
        public string DocField3 { get; set; }
        public string DocField4 { get; set; }
        public string DocField5 { get; set; }

        public string AllNotices
        {
            get 
            {
                
                if (String.IsNullOrEmpty(DocField2)) // Nur ein Dokufeld vorhanden
                {
                    return Notice;
                }
                String all = "";
                if (!String.IsNullOrEmpty(Notice))
                {
                    all = String.Format("{0}:\n{1}", DocField1, Notice);
                }
                
                if (!String.IsNullOrEmpty(Notice2))
                {
                    if (all.Length > 0)
                    {
                        all += "\n\n";
                    }
                    all += String.Format("{0}:\n{1}", DocField2, Notice2);
                }

                if (!String.IsNullOrEmpty(Notice3))
                {
                    if (all.Length > 0)
                    {
                        all += "\n\n";
                    }
                    all += String.Format("{0}:\n{1}", DocField3, Notice3);
                }
                if (!String.IsNullOrEmpty(Notice4))
                {
                    if (all.Length > 0)
                    {
                        all += "\n\n";
                    }
                    all += String.Format("{0}:\n{1}", DocField4, Notice4);
                }
                if (!String.IsNullOrEmpty(Notice5))
                {
                    if (all.Length > 0)
                    {
                        all += "\n\n";
                    }
                    all += String.Format("{0}:\n{1}", DocField5, Notice5);
                }
                return all;
            }
            set { }
        }


        public string RTFNotice
        {
            get { return _RTFNotice; }

            set
            {
                if (AreDifferent(_RTFNotice, value))
                {
                    _RTFNotice = value;
                    StoreDirtyInformation(AreDifferent(DataContract.RTFNotice1, value), PropertyName_RTFNotice);
                    FirePropertyChanged(PropertyName_RTFNotice);
                }
            }
        }

        public string RTFNotice2
        {
            get { return _RTFNotice2; }

            set
            {
                if (AreDifferent(_RTFNotice2, value))
                {
                    _RTFNotice2 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.RTFNotice2, value), PropertyName_RTFNotice2);
                    FirePropertyChanged(PropertyName_RTFNotice2);
                }
            }
        }

        public string RTFNotice3
        {
            get { return _RTFNotice3; }

            set
            {
                if (AreDifferent(_RTFNotice3, value))
                {
                    _RTFNotice3 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.RTFNotice3, value), PropertyName_RTFNotice3);
                    FirePropertyChanged(PropertyName_RTFNotice3);
                }
            }
        }

        public string RTFNotice4
        {
            get { return _RTFNotice4; }

            set
            {
                if (AreDifferent(_RTFNotice4, value))
                {
                    _RTFNotice4 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.RTFNotice4, value), PropertyName_RTFNotice4);
                    FirePropertyChanged(PropertyName_RTFNotice4);
                }
            }
        }

        public string RTFNotice5
        {
            get { return _RTFNotice5; }

            set
            {
                if (AreDifferent(_RTFNotice5, value))
                {
                    _RTFNotice5 = value;
                    StoreDirtyInformation(AreDifferent(DataContract.RTFNotice5, value), PropertyName_RTFNotice5);
                    FirePropertyChanged(PropertyName_RTFNotice5);
                }
            }
        }

        public List<ServiceDescriptionDC> PossibleServiceDescriptions
        {
            get
            {
                if (_Category == null)
                {
                    return null;
                }

                return _Category2Services.ContainsKey(_Category) ? _Category2Services[_Category] : null;
            }
        }

        public decimal RoundedDurationAnzeige
        {
            get
            {
                if (_ServiceRecordFormat == ServiceRecordFormate.ZeiterfassungMitMonatJahr || DauerEinheit == ZeiterfassungsDauer.Stunden)
                {
                    return _RoundedDuration/60;
                }
                else
                {
                    return _RoundedDuration;
                }
            }
        }
        
        public decimal RoundedDuration
        {
            get { return _RoundedDuration; }

            set { _RoundedDuration = value; }
        }

        public decimal? Betrag
        {
            get { return _Betrag; }

            set
            {
                if (AreDifferent(_Betrag, value))
                {
                    _Betrag = value;
                    StoreDirtyInformation(AreDifferent(DataContract.Betrag, value), PropertyName_Betrag);
                    FirePropertyChanged(PropertyName_Betrag);
                }
            }
        }

        public Brush SelectedBackgroundBrush
        {
            get
            {
                Brush brush = null;
                if (_GroupOid != null)
                {
                    brush = Application.Current.FindResource("GroupBookingSelectedBackgroundBrush") as Brush;
                }

                return brush ?? new SolidColorBrush(Color.FromArgb(0xFF, 0x93, 0xBC, 0xFF));
                }
            }

        public bool HasGoals
        {
            get { return SelectedGoals.Count > 0; }
        }

        public String GoalString
        {
            get
            {
                var goals = "";

                foreach (var goal in SelectedGoals)
                {
                    if (goals.Length > 0)
                        goals += ", ";
                    goals += CreateGoalString(goal);
                }

                return goals;
            }
        }

        public String OnlyGoalString
        {
            get
            {
                
                //CB: Ich muss das hier so kompliziert machen, weil ich eine unsortierte Liste von Zielen und Maßnahmen in ein sortierte Liste innerhalb der Ziele/Maßnahmen Baumstruktur überführen muss
                var goals = new List<ValueListEntryDC>();
                var firstLevelGoals = new List<ValueListEntryDC>();
                Dictionary<long, ValueListEntryDC> oid2Entry = new Dictionary<long, ValueListEntryDC>();
                Dictionary<long, List<ValueListEntryDC>> oid2ChildList = new Dictionary<long, List<ValueListEntryDC>>();

                foreach (var goal in SelectedGoals)
                {
                    if (goal.Type == ValueListEntryType.SupportConceptGoalCategoryType || goal.Type == ValueListEntryType.SupportConceptIndividualGoalCategoryType)
                    {
                        if (!goals.Contains(goal))
                        {
                            goals.Add(goal);
                        }

                        
                    }
                    else if (goal.ParentOid.HasValue)
                    {
                        var parent = Cache.GetInstance().GetGoalEntry(goal.ParentOid.Value);
                        if (parent != null && !goals.Contains(parent))
                        {
                            goals.Add(parent);
                        }

                    }
                }

                foreach (var item in goals)
                {
                    if (item.ValueListEntryOid.HasValue && !oid2Entry.ContainsKey(item.ValueListEntryOid.Value))
                    {
                        oid2Entry.Add(item.ValueListEntryOid.Value, item);
                    }
                }
                foreach (var item in goals)
                {
                    if (!item.ParentOid.HasValue || !oid2Entry.ContainsKey(item.ParentOid.Value))
                    {
                        firstLevelGoals.Add(item);
                    }

                    if (item.ParentOid.HasValue)
                    {
                        if (!oid2ChildList.ContainsKey(item.ParentOid.Value))
                        {
                            oid2ChildList.Add(item.ParentOid.Value, new List<ValueListEntryDC>());
                        }
                        oid2ChildList[item.ParentOid.Value].Add(item);
                    }
                }
                var sortedGoals = new List<ValueListEntryDC>();
                foreach (var item in firstLevelGoals.OrderBy(g => g.DisplayName))
                {
                    AddGoalWithChildren(item, oid2ChildList, sortedGoals);
                }
                var goalString = "";
                foreach (var goal in sortedGoals)
                {
                    
                    if (goalString.Length > 0)
                        goalString += ", ";
                    goalString += CreateGoalString(goal);
                }
                
                return goalString;
            }
        }

        private void AddGoalWithChildren(ValueListEntryDC item, Dictionary<long, List<ValueListEntryDC>> oid2ChildList, List<ValueListEntryDC> sortedGoals)
        {
            sortedGoals.Add(item);
            if (oid2ChildList.ContainsKey(item.ValueListEntryOid.Value))
            {
                foreach (var child in oid2ChildList[item.ValueListEntryOid.Value].OrderBy(g => g.DisplayName))
                {
                    AddGoalWithChildren(child, oid2ChildList, sortedGoals);
                }
            }
        }

        public String MassnahmenString
        {
            get
            {
                var goals = "";

                foreach (var goal in SelectedGoals)
                {
                    if (goal.Type == ValueListEntryType.SupportConceptGoalType || goal.Type == ValueListEntryType.SupportConceptIndividualGoalType)
                    {
                        if (goals.Length > 0)
                            goals += ", ";
                        goals += CreateGoalString(goal);
                    }
                }

                return goals;
            }
        }

        private string CreateGoalString(ValueListEntryDC goal)
        {
            String name = goal.TypeDescription;
            if (goal.CatalogOid.HasValue)
            {
                if (goal.CatalogItem == null)
                {
                    goal.CatalogItem = Cache.GetInstance().GetValueListEntry(ValueListEntryType.MassnahmenKatalog, goal.CatalogOid.Value);
                }
                if (goal.CatalogItem != null)
                {
                    name = goal.CatalogItem.TypeDescription;
                }
            }

            if (!String.IsNullOrWhiteSpace(goal.Abbreviation))
            {
                String code = goal.Abbreviation;

                if (goal.RatingTypeOid.HasValue)
                {
                    var rdc = Cache.GetInstance().GetAllRatingTypeList().FirstOrDefault(r => r.RatingTypeOid == goal.RatingTypeOid);
                    if (rdc != null && rdc.RatingId.HasValue)
                    {
                        code = String.Format("{0}.{1}", code, rdc.RatingId.Value);
                    }

                    
                }
                name = String.Format("{0}: {1}", code, name);
            }
            return name;
        }


        public ObservableSortCollection<ValueListEntryDC> SelectedGoals
        {
            get
            {
                return _SelectedGoals ?? (_SelectedGoals = new ObservableSortCollection<ValueListEntryDC>(Comparer.ValueListEntryDCComparer));
            }
        }

        [Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
        public ServiceDescriptionDC ServiceDescription
        {
            get { return _ServiceDescription; }

            set
            {
                if (AreDifferent(_ServiceDescription, value))
                {
                    _ServiceDescription = value;
                    StoreDirtyInformation(!AreEqual(DataContract.ServiceDescription, value), PropertyName_ServiceDescription);
                    FirePropertyChanged(PropertyName_ServiceDescription);
                }
            }
        }


        public string ShortNotice
        {
            get
            {
                var desc = Notice;

                if (desc.IndexOf("\r\n") > 0)
                {
                    desc = desc.Substring(0, desc.IndexOf("\r\n"));
                }

                return desc;
            }
        }

        

        //public DateTime? StartTime
        //{
        //    get
        //    {
        //        if(_StartTime != null)
        //            return _StartTime.Value.Second != 0 ? null : _StartTime;
        //        else
        //        {
        //            return new DateTime();
        //        }
        //    }

        //    set
        //    {            
        //        DateTime? newStartTime = value ?? NULL_TIME;

        //        Console.WriteLine("Change StartTime " + newStartTime.Value.ToShortTimeString());
        //        if ((_StartTime == null && newStartTime != NULL_TIME) ||
        //            (_StartTime != null && _StartTime.Value.TimeOfDay != newStartTime.Value.TimeOfDay))
        //        {
        //            _StartTime = newStartTime;

        //            if (_StartTime.Value.Second == 0)
        //            {
        //                if (_EndTime == null && Duration.HasValue)
        //                {
        //                    if (_DurationInStunden == ZeiterfassungsDauer.Stunden)
        //                    {
        //                        _EndTime = _StartTime.Value.AddHours((int)Duration.Value);
        //                    }
        //                    else
        //                    {
        //                        _EndTime = _StartTime.Value.AddMinutes((int)Duration.Value);
        //                    }

        //                }

        //                if (_EndTime != null)
        //                {
        //                    var end = new DateTime(_StartTime.Value.Year, _StartTime.Value.Month, _StartTime.Value.Day,
        //                        _EndTime.Value.Hour, _EndTime.Value.Minute, 0);

        //                    if (_EndTime.Value.Second > 0 && Duration.HasValue)
        //                    {
        //                        end = new DateTime(_StartTime.Value.Year, _StartTime.Value.Month, _StartTime.Value.Day,
        //                            _StartTime.Value.Hour, _StartTime.Value.Minute, 0);

        //                        if (_DurationInStunden == ZeiterfassungsDauer.Stunden)
        //                        {
        //                            end = end.AddHours((int)Duration.Value);
        //                        }
        //                        else
        //                        {
        //                            end = end.AddMinutes((int)Duration.Value);
        //                        }
        //                    }


        //                    var diff = end.Subtract(_StartTime.Value);

        //                    if (diff.TotalSeconds < 0)
        //                    {
        //                        EndTime = _StartTime;
        //                        end = EndTime.Value;
        //                    }

        //                    diff = end.Subtract(_StartTime.Value);


        //                    if (BeWoApp.AppSettings.IsEndDateVisible && ServiceRecordFormat == null || ServiceRecordFormat == ServiceRecordFormate.ZeiterfassungMitEndDatum)
        //                    {
        //                        EditableEndDate = end;
        //                    }

        //                    if (_DurationInStunden == ZeiterfassungsDauer.Stunden)
        //                    {
        //                        Duration = (decimal) diff.TotalHours;
        //                    }
        //                    else
        //                    {
        //                        Duration = (decimal)diff.TotalMinutes;
        //                    }
        //                    FirePropertyChanged(PropertyName_Duration);
        //                    TimeCheck();
        //                }

        //                //else 
        //                //{
        //                //    if (BeWoApp.AppSettings.IsEndDateVisible)
        //                //    {
        //                //        if (_DurationInStunden == ZeiterfassungsDauer.Stunden)
        //                //        {
        //                //            EndTime = _StartTime.Value.AddHours(DurationSTD.Value);
        //                //        }else{
        //                //            EndTime = _StartTime.Value.AddMinutes(DurationSTD.Value);
        //                //        }
        //                //    }else{
        //                //        if (_DurationInStunden == ZeiterfassungsDauer.Stunden)
        //                //        {
        //                //            EndTime = _StartTime.Value.AddHours(Duration.Value);
        //                //        }else{
        //                //            EndTime = _StartTime.Value.AddMinutes(Duration.Value);
        //                //        }
        //                //    }
        //                //}
        //            }
        //            else
        //            {
        //                TimeCheck();
        //            }
        //            StoreDirtyInformation(true, PropertyName_SupportConcept);

        //            FirePropertyChanged(PropertyName_StartTime);
        //            var test = this.IsDirty;
        //        }
        //    }
        //}

        public CompactSupportConceptDC SupportConcept
        {
            get { return _SupportConcept; }

            set
            {
                if (AreDifferent(_SupportConcept, value))
                {
                    _SupportConcept = value;
                    CostBearer = null;
                    StoreDirtyInformation(!AreEqual(DataContract.SupportConcept, value), PropertyName_SupportConcept);
                    FirePropertyChanged(PropertyName_SupportConcept);
                    FirePropertyChanged(PropertyName_PossibleCostBearers);
                }
            }
        }

        public ServiceRecordTypeId ServiceRecordType
        {
            get { return _ServiceRecordType; }

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

                    StoreDirtyInformation(!AreEqual(DataContract.ServiceRecordType, value), PropertyName_ServiceRecordType);
                    FirePropertyChanged(PropertyName_ServiceRecordType);
                    FirePropertyChanged(PropertyName_IsServiceRecordTypeContent);
                    FirePropertyChanged(PropertyName_IsServiceRecordTypeDefaultActivity);
                }
            }
        }

        public bool IsServiceRecordTypeContent
        {
            get { return ServiceRecordType == ServiceRecordTypeId.Content; }

            set { ServiceRecordType = value ? ServiceRecordTypeId.Content : ServiceRecordTypeId.DefaultActivity; }
            }

        public bool IsServiceRecordTypeDefaultActivity
        {
            get { return ServiceRecordType == ServiceRecordTypeId.DefaultActivity; }

            set { ServiceRecordType = value ? ServiceRecordTypeId.DefaultActivity : ServiceRecordTypeId.Content; }
        }

        public ZeiterfassungsDauer DauerEinheit
        {
            get { return _DauerEinheit; }

            set
            {
                if (AreDifferent(_DauerEinheit, value))
                {
                    if (value == ZeiterfassungsDauer.Minuten && _DauerEinheit == ZeiterfassungsDauer.Stunden)
                    {
                        _Duration *= 60;
                        
                    }
                    else if (value == ZeiterfassungsDauer.Stunden && _DauerEinheit == ZeiterfassungsDauer.Minuten)
                    {
                        _Duration /= 60;
                    }


                    _DauerEinheit = value;

                    
                    StoreDirtyInformation(AreDifferent(DataContract.DurationInStunden, value), PropertyName_DauerEinheit);
                    
                    FirePropertyChanged(PropertyName_DauerEinheit);
                    FirePropertyChanged(PropertyName_Duration);
                }
            }
        }

        public ServiceRecordFormate ServiceRecordFormat 
        { 
            get{ return _ServiceRecordFormat; }
            set
            {
                if (AreDifferent(_ServiceRecordFormat, value))
                {
                    _ServiceRecordFormat = value;
                    StoreDirtyInformation(AreDifferent(DataContract.ServiceRecordFormat, value), PropertyName_ServiceRecordFormat);

                    FirePropertyChanged(PropertyName_ServiceRecordFormat);                
                }
            }
        }

        public string OnlyMonth
        {
            get
            {
                if (_OnlyMonth.IsNullOrEmpty())
                {
                    _OnlyMonth = DateTime.Now.ToString("MMMM");
                }

                return _OnlyMonth;
            }
            set
            {
                if (AreDifferent(_OnlyMonth, value))
                {
                    _OnlyMonth = value;

                    FirePropertyChanged(PropertyName_OnlyMonth);
                }

            }
        }


        public string[] MonateBinden
        {
            get { return _MonateBinden; }

        }

        public string[] JahreBind()
        {
            string[] s = new string[11];

            int x = -5;
            for (int i = 0; i < 11; i++)
            {
                var a = DateTime.Now.Year + x; 
                s[i] = a.ToString();
                x++;
            }

            return s;
        }

        public string[] JahreBinden
        {
            get { return JahreBind(); }
            
        }


        
        public string OnlyYear
        {
            get
            {
                if (_OnlyYear.IsNullOrEmpty())
                {
                    _OnlyYear = DateTime.Now.Year.ToString();
                }

                return _OnlyYear;
            }
            set
            {
                if (AreDifferent(_OnlyYear, value))
                {
                    _OnlyYear = value;
              
                    FirePropertyChanged(PropertyName_OnlyYear);
                }
            }
        }
      

        [Validation(ValidationRule = ValidationRules.GreaterThanOrEqualZero)]
        public decimal? DurationMonthYearGes
        {
            get
            {
                if (_DurationMonthYearGes == null)
                {
                    return 0;
                }
                else
                {
                    return _DurationMonthYearGes;
                }
            }

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

                    StoreDirtyInformation(AreDifferent(DataContract.RoundedDuration, value),
                        PropertyName_DurationMonthYearGes);

                   
                    FirePropertyChanged(PropertyName_DurationMonthYearGes);
                    FirePropertyChanged(PropertyName_RoundedDuration); 
                    TimeCheckMonatJahr();
                    
                }           
            }
        }

        #endregion

        public List<SupportConceptPeriodStatisticsVM> Statistics
        {
            get { return _Statistics; }
            set
            {
                _Statistics = value;
                FirePropertyChanged("Statistics");
                FirePropertyChanged("HasStatistics");
            }
        }

        public bool HasStatistics
        {
            get { return _Statistics != null && _Statistics.Count > 0; }
        }

        #region Public Methods

        public void ChangeGoalTree(List<ValueListEntryDC> goalCats, List<ValueListEntryDC> goals) //, List<ValueListEntryDC> goalsAndCats)
        {
            //if (!MussGoalTreeAktualisieren(goalCats, goals))
            //{
            //ValueListEntryDC kopieren?
                _AllGoalCategories = goalCats;
                _AllGoals = goals;

                var newList = new List<ValueListEntryDC>();

                if (_AllGoalCategories != null)
                {
                    newList.AddRange(_AllGoalCategories);
                }

                if (_AllGoals != null)
                {
                    newList.AddRange(_AllGoals);
                }


                GoalTree = SupportConceptService.CreateGoalTree(newList, SelectedGoals);

            AddPropertyChangedHandler(GoalTree);
            

        }

        private void AddPropertyChangedHandler(List<SupportConceptGoalDC> goalTree)
        {
            if (goalTree != null)
            {
                foreach (var goal in goalTree)
                {
                    goal.PropertyChanged += (s, e) =>
                    {
                        var selectedGoal = s as SupportConceptGoalDC;
                        if (selectedGoal != null)
                        {
                            if (selectedGoal.IsChecked)
                            {
                                if (!SelectedGoals.Contains(selectedGoal.GoalEntryDC))
                                {
                                    SelectedGoals.Add(selectedGoal.GoalEntryDC);
                                }

                            }
                            else
                            {
                                SelectedGoals.Remove(selectedGoal.GoalEntryDC);
                            }
                        }
                    };

                    AddPropertyChangedHandler(goal.Children);
                }
            }
            
        }

        //private bool MussGoalTreeAktualisieren(List<ValueListEntryDC> goalCats, List<ValueListEntryDC> goals)
        //{
        //    if (IstGleich(goalCats, _AllGoalCategories) && IstGleich(_AllGoals, goals))
        //    {

        //    }

        //    return false;
        //}

        public void UpdateServiceAccountings(List<ServiceAccountingDC> serviceAccountings, Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>> allDict, bool hilfeplanAusgewaehlt)
        {
            _ServiceAccountings = serviceAccountings;
            var newCategoryDict = new Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>>();

			foreach (var cat in allDict.Keys)
			{
				bool add = true;
				if (hilfeplanAusgewaehlt && cat.OhneHilfeplan.HasValue && cat.OhneHilfeplan.Value == AccountingvisibilityType.NichtKlientenbezogen)
				{
					add = false;
				}
				else if (!hilfeplanAusgewaehlt && cat.OhneHilfeplan.HasValue && cat.OhneHilfeplan.Value == AccountingvisibilityType.NurKlientenbezogen)
				{
					add = false;
				}
                else if (cat.OhneHilfeplan.HasValue && cat.OhneHilfeplan.Value == AccountingvisibilityType.Never)
                {
                    add = false;
                }
				if (add)
				{
					newCategoryDict.Add(cat, allDict[cat]);
				}
			}
			
            ServiceCategoryDC firstCat = null;
            if (_ServiceAccountings != null && allDict != null)
            {
                var globalServices     = _ServiceAccountings.FindAll(sa => sa.ServiceDescription.ScopeType == ScopeTypeId.Global && (!sa.ServiceDescription.Category.OhneHilfeplan.HasValue || sa.ServiceDescription.Category.OhneHilfeplan.Value != AccountingvisibilityType.Never));
                var individualServices = _ServiceAccountings.FindAll(sa => sa.ServiceDescription.ScopeType == ScopeTypeId.Individual && (!sa.ServiceDescription.Category.OhneHilfeplan.HasValue || sa.ServiceDescription.Category.OhneHilfeplan.Value != AccountingvisibilityType.Never));

                if (globalServices.Count > 0)
                {
                    newCategoryDict = new Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>>();
                    foreach (var cat in allDict.Keys)
                    {
                        var sdList    = allDict[cat];
                        var newSdList = sdList.Where(sd => globalServices.Exists(sa => sa.ServiceDescription.Equals(sd))).ToList();

                        if (newSdList.Count > 0)
                        {
							if (firstCat == null || cat.Position < firstCat.Position)
								firstCat = cat;

							newCategoryDict.Add(cat, newSdList);
                        }
                    }
                }
                if (individualServices.Count > 0)
                {
                    newCategoryDict.Add(individualServices[0].ServiceDescription.Category,
                                        individualServices.Select(sa => sa.ServiceDescription).ToList());
                }
            }
            Category2Services = newCategoryDict;

            if (Category == null)
            {
                if (firstCat == null)
                {
                    firstCat = SortedCategories.FirstOrDefault();
                }
                Category = firstCat;
            }
        }

        public ServiceRecordVM Clone()
        {
            var dc = new ServiceRecordDC();

            return new ServiceRecordVM(CopyToDataContract(dc), _Category2Services, _AllGoalCategories, _AllGoals);
        }

        public void CopyTo(ServiceRecordVM copy)
        {
            copy.Notice               = Notice;
            copy.Notice2              = Notice2;
            copy.Notice3              = Notice3;
            copy.Notice4              = Notice4;
            copy.Notice5              = Notice5;
            copy.RTFNotice            = RTFNotice;
            copy.RTFNotice2           = RTFNotice2;
            copy.RTFNotice3           = RTFNotice3;
            copy.RTFNotice4           = RTFNotice4;
            copy.RTFNotice5           = RTFNotice5;
            copy.EditStartDate        = EditStartDate;
            copy.StartTimeString      = StartTimeString;
            copy.EditEndDate          = EditEndDate;
            copy.EndTimeString        = EndTimeString;
            copy.Duration             = Duration;
            copy.RoundedDuration      = RoundedDuration;
            copy.ServiceRecordType    = ServiceRecordType;
            copy.DistanceInMeter      = DistanceInMeter;
            copy.Employee             = Employee;
            copy.Customer             = Customer;
            copy.SupportConcept       = SupportConcept;
            copy.CostBearer           = CostBearer;
            copy.Category             = Category;
            copy.ServiceDescription   = ServiceDescription;
            copy.GroupEmployeeCount   = GroupEmployeeCount;
            copy.GroupPersonCount     = GroupPersonCount;
            copy.GroupOid             = GroupOid;
            copy.GroupRoundedDuration = GroupRoundedDuration;
            copy.SignatureOid         = SignatureOid;
            copy.DauerEinheit         = DauerEinheit;
            copy.ServiceRecordFormat  = ServiceRecordFormat;
            copy.Betrag = Betrag;
            copy.BackgroundColor = BackgroundColor;

            copy.SelectedGoals.Clear();
            foreach (var item in SelectedGoals)
            {
                copy.SelectedGoals.Add(item);
            }

            copy.GoalTree = GoalTree;
        }

        public void SetInsertedOn(DateTime dt)
        {
            _InsertedOn = dt;
        }

        public override string ToString()
        {
            return _Customer + ": " + StartDate.ToLongDateString() + string.Format("-  Dauer: {0:0.00} min", RoundedDuration);
        }

        #endregion

        #region Methods
        
        protected override void InitByDataContract(ServiceRecordDC pDataContract)
        {
            _DauerEinheit = pDataContract.DurationInStunden ?? ZeiterfassungsDauer.Minuten;
            _EditStartDate = pDataContract.Start ?? DateTime.Now.Date.AddSeconds(1);
            _EditEndDate = pDataContract.End ?? DateTime.Now.Date.AddSeconds(1);
            if (pDataContract.Start.HasValue && pDataContract.Start.Value.Second == 0)
            {
                _StartTimeString = String.Format("{0:HH:mm}", pDataContract.Start);
            }
            if (pDataContract.End.HasValue && pDataContract.End.Value.Second == 0)
            {
                _EndTimeString = String.Format("{0:HH:mm}", pDataContract.End);
            }
            if (_DauerEinheit == ZeiterfassungsDauer.Stunden)
            {
                _Duration = (decimal)(_EditEndDate.Value - _EditStartDate.Value).TotalHours;
            }
            else
            {
                _Duration = (_EditEndDate.Value - _EditStartDate.Value).GetTotalMinutes();
            }
            
            _Notice = pDataContract.Notice;
            _Notice2 = pDataContract.Notice2;
            _Notice3 = pDataContract.Notice3;
            _Notice4 = pDataContract.Notice4;
            _Notice5 = pDataContract.Notice5;
            _RTFNotice = pDataContract.RTFNotice1;
            _RTFNotice2 = pDataContract.RTFNotice2;
            _RTFNotice3 = pDataContract.RTFNotice3;
            _RTFNotice4 = pDataContract.RTFNotice4;
            _RTFNotice5 = pDataContract.RTFNotice5;
            _ServiceDescription = pDataContract.ServiceDescription;
            _Employee = pDataContract.Employee;
            _Customer = pDataContract.Customer;
            _SupportConcept = pDataContract.SupportConcept;
            _CostBearer = pDataContract.CostBearer;
            _ServiceDescription = pDataContract.ServiceDescription;

            if (pDataContract.ServiceDescription != null)
            {
                _Category = pDataContract.ServiceDescription.Category;
            }

            _RoundedDuration = pDataContract.RoundedDuration;             
            _InsertedOn = pDataContract.InsertedOn;
            _InsUser = pDataContract.InsUser;
            _GroupEmployeeCount = pDataContract.GroupEmployeeCount;
            _GroupPersonCount = pDataContract.GroupPersonCount;
            _GroupRoundedDuration = pDataContract.GroupRoundedDuration;
            _GroupOid = pDataContract.GroupOid;
            _ServiceRecordType = pDataContract.ServiceRecordType;
            _DistanceInMeter = pDataContract.DistanceInMeterDecimal;
            _Betrag = pDataContract.Betrag;
            _ServiceRecordFormat = pDataContract.ServiceRecordFormat ?? ServiceRecordFormate.OriginaleZeiterfassung;
            _SignatureOid = pDataContract.SignatureOid;
            BackgroundColor = pDataContract.BackgroundColor;

            if (pDataContract.Goals != null)
            {
                _SelectedGoals = new ObservableSortCollection<ValueListEntryDC>(GoalService.CopyGoals(pDataContract.Goals, true), Comparer.ValueListEntryDCComparer);
            }

            SelectedGoals.CollectionChanged += (s, e) =>
            {
                StoreDirtyInformation(!SelectedGoals.ContainsSameItemsAs(pDataContract.Goals),
                    PropertyName_SelectedGoals);
            };


            if (pDataContract.ServiceRecordType == ServiceRecordTypeId.Wohnheimbuchung)
            {
                _EditAllowed = _DeleteAllowed = false;
            }
        }

        private bool SameRatingChecked(ObservableSortCollection<ValueListEntryDC> selectedGoals, List<ValueListEntryDC> goals)
        {
            if (goals != null)
            {
                foreach (var selectedGoal in selectedGoals)
                {
                    foreach (var goalDc in goals)
                    {
                        if (selectedGoal.Equals(goalDc))
                        {
                            bool equalRating = true;
                            if (selectedGoal.RatingTypeOid == null && goalDc.RatingTypeOid == null)
                            {
                                equalRating = true;
                            }
                            else if (selectedGoal.RatingTypeOid == null && goalDc.RatingTypeOid != null)
                            {
                                equalRating = false;
                            }
                            else if (selectedGoal.RatingTypeOid != null && goalDc.RatingTypeOid == null)
                            {
                                equalRating = false;
                            }
                            else if (selectedGoal.RatingTypeOid != null && goalDc.RatingTypeOid != null &&
                                     selectedGoal.RatingTypeOid != goalDc.RatingTypeOid)
                            {
                                equalRating = false;
                            }

                            if (!equalRating)
                            {
                                StoreDirtyInformation(true, "Rating");
                                return false;
                            }
                        }
                    }
                }
            }

            StoreDirtyInformation(false, "Rating");
            return true;
        }

        protected override ServiceRecordDC MapToDataContract(ServiceRecordDC pDataContract, bool doCommit)
        {
            return CopyToDataContract(pDataContract);
        }

        private ServiceRecordDC CopyToDataContract(ServiceRecordDC pDataContract)
        {

            pDataContract.ServiceRecordFormat = ServiceRecordFormate.OriginaleZeiterfassung;
            if (!String.IsNullOrEmpty(StartTimeString) && String.IsNullOrEmpty(EndTimeString))
            {
                DateTime newEndDate = StartDate;
                if (DauerEinheit == ZeiterfassungsDauer.Minuten)
                    newEndDate = newEndDate.AddMinutes((double)Duration);
                else
                    newEndDate = newEndDate.AddHours((double)Duration);
                EndTimeString = String.Format("{0:HH:mm}", newEndDate);
            }
            else if (String.IsNullOrEmpty(StartTimeString) && !String.IsNullOrEmpty(EndTimeString))
            {
                //_EndTimeString = "";
            }
            if (BeWoApp.AppSettings.IsEndDateVisible)
            {
                pDataContract.ServiceRecordFormat = ServiceRecordFormate.ZeiterfassungMitEndDatum;
            }

            pDataContract.Start = StartDate;
            pDataContract.End = EndDate;
            var d = Duration;
            if (DauerEinheit == ZeiterfassungsDauer.Stunden)
            {
                d *= 60;
            }

            pDataContract.RoundedDuration = d;
            
            pDataContract.Notice = _Notice;
            pDataContract.Notice2 = _Notice2;
            pDataContract.Notice3 = _Notice3;
            pDataContract.Notice4 = _Notice4;
            pDataContract.Notice5 = _Notice5;

            pDataContract.RTFNotice1 = _RTFNotice;
            pDataContract.RTFNotice2 = _RTFNotice2;
            pDataContract.RTFNotice3 = _RTFNotice3;
            pDataContract.RTFNotice4 = _RTFNotice4;
            pDataContract.RTFNotice5 = _RTFNotice5;

            pDataContract.ServiceRecordType = _ServiceRecordType;
            pDataContract.DistanceInMeter = null; // Die Eigenschaft muss leider drin bleiben um die Abwärtskompatibilität zu gewährleistung
            pDataContract.DistanceInMeterDecimal = _DistanceInMeter;
            pDataContract.DurationInStunden = DauerEinheit;
            pDataContract.Employee = _Employee;
            pDataContract.Customer = _Customer;
            pDataContract.SupportConcept = _SupportConcept;
            pDataContract.CostBearer = _CostBearer;
            pDataContract.RoundedDuration = RoundedDuration;
            pDataContract.ServiceDescription = _ServiceDescription;
            pDataContract.Betrag = _Betrag;
            //Hack Story dirty information
            SameRatingChecked(SelectedGoals, this.DataContract.Goals);

            pDataContract.Goals = GetSelectedGoals();

#if DEBUG
            if (pDataContract.Goals.Count == 0)
            {
                int test = 0;
            }
#endif
            pDataContract.GroupEmployeeCount = GroupEmployeeCount;
            pDataContract.GroupPersonCount = GroupPersonCount;
            pDataContract.GroupRoundedDuration = GroupRoundedDuration;
            pDataContract.GroupOid = GroupOid;
            pDataContract.BackgroundColor = BackgroundColor;
            pDataContract.SignatureOid = _SignatureOid;

            return pDataContract;
        }

        private List<ValueListEntryDC> GetSelectedGoals()
        {
            var goals = new List<ValueListEntryDC>();

            AddCheckedGoals(GoalTree, goals);
            

            return goals;
        }

        private static void AddCheckedGoals(IEnumerable<SupportConceptGoalDC> goals, ICollection<ValueListEntryDC> selectedGoals)
        {
            foreach (var item in goals)
            {
                if (item.IsChecked)
                {
                    selectedGoals.Add(item.GoalEntryDC);
                }

                if (item.Children == null || item.Children.Count == 0)
                {
                    //if (item.IsChecked)
                    //{
                    //    selectedGoals.Add(item.GoalEntryDC);
                    //}
                }
                else
                {
                    
                    AddCheckedGoals(item.Children, selectedGoals);
                }
            }
        }

        

        private void TimeCheckMonatJahr()
        {
            //var duration = 0;
            
            decimal duration = 0;
            if (_DurationMonthYearGes.HasValue)
            {
                duration = _DurationMonthYearGes.Value;
            }

            var dates = DateTime.Parse("1." + _OnlyMonth + _OnlyYear);
            var StartDatetime = new DateTime(dates.Year, dates.Month, 1, 0, 0, 1);
                
            StoreDirtyInformation(
               AreDifferent(DataContract.End, StartDatetime.AddHours((double)duration).AddSeconds(1)) ||
               AreDifferent(DataContract.Start, StartDatetime), "TIME");
        }

        //private void TimeCheckForDurationSTD()
        //{        
        //    double duration = 0;

        //    if (_DurationSTD.HasValue) { 
        //        duration = (double)_DurationSTD.Value;
        //    }

        //    //####################### ich glaub das wars ########################## 
        //    if (_DurationInStunden == ZeiterfassungsDauer.Minuten) 
        //    {
        //        if (_StartTime != null && _EndTime != null)
        //        {
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day,
        //                _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second);

        //            _EndTime = _StartTime.Value.AddMinutes(duration);

        //            if (_EndTime.Value.Second > 1)
        //            {
        //                _EndTime = new DateTime(_EndTime.Value.Year, _EndTime.Value.Month, _EndTime.Value.Day, _EndTime.Value.Hour , _EndTime.Value.Minute, 0);
        //            }

        //        }



        //        if (_StartTime == null && _EndTime != null && duration == 0)
        //        {
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, _EndTime.Value.Hour, _EndTime.Value.Minute, _EndTime.Value.Second);
        //        }
        //        else if (_StartTime == null && _EndTime != null)
        //        {
        //            _StartTime = _EndTime.Value.AddMinutes(duration * -1);
        //        }


        //        if (_StartTime != null && _EndTime == null && duration == 0)
        //        {
        //            _EndTime = new DateTime(_EditableEndDate.Value.Year, _EditableEndDate.Value.Month, _EditableEndDate.Value.Day, _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second);
        //        }
        //        else if (_StartTime != null && _EndTime == null)
        //        {                   
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day,
        //                _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second);

        //            _EndTime = _StartTime.Value.AddMinutes(duration);

        //            if (_EndTime.Value.Second > 1)
        //            {
        //                _EndTime = new DateTime(_EndTime.Value.Year, _EndTime.Value.Month, _EndTime.Value.Day, _EndTime.Value.Hour, _EndTime.Value.Minute, 0);
        //            }
        //        }



        //        if (_StartTime == null && _EndTime == null && duration == 0)
        //        {
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, 0, 0, 1);
        //            _EndTime = new DateTime(_EditableEndDate.Value.Year, _EditableEndDate.Value.Month, _EditableEndDate.Value.Day, 0, 0, 1);
        //        }
        //        else if (_StartTime == null && _EndTime == null)
        //        {
        //            //start 1 sek und end duration + 1 sek
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, 0, 0, 1);

        //            _EndTime = new DateTime(_EditableEndDate.Value.Year, _EditableEndDate.Value.Month, _EditableEndDate.Value.Day, 0, 0, 1);
        //            _EndTime = _EndTime.Value.AddMinutes(duration);
        //        }

        //        _Date = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second); 
        //        _EditableEndDate = new DateTime(_EndTime.Value.Year, _EndTime.Value.Month, _EndTime.Value.Day, _EndTime.Value.Hour, _EndTime.Value.Minute, _EndTime.Value.Second);
                
               
        //        var diff = _EditableEndDate.Value.Subtract(_Date.Value);
        //        duration = (double)diff.TotalMinutes;


        //        _DurationSTD = (decimal)duration;

        //        //StoreDirtyInformation(AreDifferent(DataContract.End, (_Date.Value + _StartTime.Value.TimeOfDay).AddMinutes((double)duration)) || AreDifferent(DataContract.Start, _Date.Value + _StartTime.Value.TimeOfDay), "TIME");
        //        StoreDirtyInformation(AreDifferent(DataContract.End, _EndTime) || AreDifferent(DataContract.Start, _StartTime), "TIME");
        //    }
        //    else if (_DurationInStunden == ZeiterfassungsDauer.Stunden) 
        //    {
        //        if (_StartTime != null && _EndTime != null)
        //        {              
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day,
        //                _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second);

        //            _EndTime = _StartTime.Value.AddHours(duration);

        //            if (_EndTime.Value.Second > 1)
        //            {
        //                _EndTime = new DateTime(_EndTime.Value.Year, _EndTime.Value.Month, _EndTime.Value.Day, _EndTime.Value.Hour, _EndTime.Value.Minute, 0);
        //            }
        //        }



        //        if (_StartTime == null && _EndTime != null && duration == 0)
        //        {
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, _EndTime.Value.Hour, _EndTime.Value.Minute, _EndTime.Value.Second);
        //        }
        //        else if (_StartTime == null && _EndTime != null)
        //        {
        //            _StartTime = _EndTime.Value.AddHours(duration * -1);
        //        }



        //        if (_StartTime != null && _EndTime == null && duration == 0)
        //        {
        //            _EndTime = new DateTime(_EditableEndDate.Value.Year, _EditableEndDate.Value.Month, _EditableEndDate.Value.Day, _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second);
        //        }
        //        else if (_StartTime != null && _EndTime == null)
        //        {
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day,
        //               _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second);

        //            _EndTime = _StartTime.Value.AddHours(duration);

        //            if (_EndTime.Value.Second > 1)
        //            {
        //                _EndTime = new DateTime(_EndTime.Value.Year, _EndTime.Value.Month, _EndTime.Value.Day, _EndTime.Value.Hour, _EndTime.Value.Minute, 0);
        //            }
        //        }



        //        if (_StartTime == null && _EndTime == null && duration == 0)
        //        {
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, 0, 0, 1);
        //            _EndTime = new DateTime(_EditableEndDate.Value.Year, _EditableEndDate.Value.Month, _EditableEndDate.Value.Day, 0, 0, 1);
        //        }
        //        else if (_StartTime == null && _EndTime == null)
        //        {
        //            //start 1 sek und end duration + 1 sek
        //            _StartTime = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, 0, 0, 1);

        //            _EndTime = new DateTime(_EditableEndDate.Value.Year, _EditableEndDate.Value.Month, _EditableEndDate.Value.Day, 0, 0, 1);
        //            _EndTime = _EndTime.Value.AddHours(duration);
        //        }

        //        _Date = new DateTime(_Date.Value.Year, _Date.Value.Month, _Date.Value.Day, _StartTime.Value.Hour, _StartTime.Value.Minute, _StartTime.Value.Second);
        //        _EditableEndDate = new DateTime(_EndTime.Value.Year, _EndTime.Value.Month, _EndTime.Value.Day, _EndTime.Value.Hour, _EndTime.Value.Minute, _EndTime.Value.Second);

        //        var diff = _EditableEndDate.Value.Subtract(_Date.Value);
        //        duration = (double)diff.TotalHours;

        //        _DurationSTD = (decimal)Math.Round(duration,2);

        //        StoreDirtyInformation(AreDifferent(DataContract.End, _EndTime) || AreDifferent(DataContract.Start, _StartTime), "TIME");
        //    }

        //    FirePropertyChanged(PropertyName_DurationSTD);
        //    FirePropertyChanged(PropertyName_StartTime);
        //    FirePropertyChanged(PropertyName_EndTime);
        //    FirePropertyChanged(PropertyName_Date);
        //    FirePropertyChanged(PropertyName_EditableEndDate);
           
        //    }     
        #endregion
    }
}