BeWoPlaner/BeWo/View/Detail/SupportConceptView.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Threading;

using BeWo.Annotations;
using BeWo.Controls;
using BeWo.Core;
using BeWo.Core.Service;
using BeWo.MultiLanguage;
using BeWo.Scheduler.ViewModel;
using BeWo.ServiceProxy;
using BeWo.Validation;
using BeWo.ViewModel;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using BS.Shared.Translation;
using DevExpress.Mvvm.POCO;
using DevExpress.Utils;
using DevExpress.Xpf.Editors.Settings;
using DevExpress.Xpf.Grid;
using DevExpress.Xpf.Editors;
using System.Windows.Navigation;
using System.Windows.Documents;
using System.Collections.ObjectModel;
using BeWo.View.Windows;

namespace BeWo.View.Detail
{
    public partial class SupportConceptView : INotifyPropertyChanged
    {
        #region Constants and Fields

        private TreeViewItem _SelectedGoalTreeNode;

        private PersonView _PersonModalPopUp;

        private List<ServiceRecordDC> _ServiceRecords;

        private SupportConceptVM _ViewModel;

        private bool employeeEditFlag;

        private bool isChangingCostbearer;

        private SupportConceptCostBearerRelVM supportConceptCostBearerRel2Change;

        private readonly SchedulerAppointmentDC taskToEdit;

        #region Rechtebinding
        public static bool IsAllowedToChangeCostbeaerer
        {
            get { return BeWoApp.LoggedOnUser.HasRight(UserRightType.CostbearerAllowChange); }
        }

        public static bool IsAllowedToEditCostbearers
        {
            get { return BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConceptView_Edit); }
        }

        public static bool IsAllowedToEditGoals
        {
            get { return BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConcept_AllowEditGoals); }
        }
        #endregion

        #endregion

        #region Constructors and Destructors

        public SupportConceptView(SupportConceptVM pViewModel)
        {
            InitializeComponent();
            ViewModel = pViewModel;
            //tabitem_goalsNeu.Visibility = Visibility.Collapsed;

            if (!BeWoApp.AppSettings.ShowPersehImport || !BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConcept_ImportData))
            {
                ButtenImport.Visibility = Visibility.Collapsed;
            }
            
            if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConceptView_AllowArchiving))
            {
                lblArchiviert.Visibility = Visibility.Hidden;
                chkArchiviert.Visibility = Visibility.Hidden;
            }
            if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.DocumentsAllowViewAll) && !BeWoApp.LoggedOnUser.HasRight(UserRightType.DokumenteHilfeplaene))
            {
                tabitem_documents.Visibility = Visibility.Collapsed;
            }

            tabitem_grid_tasks.IsEnabled = false;

            if (BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConcept_AllowEditTasks))
            {
                tabitem_grid_tasks.IsEnabled = true;
            }

            if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConceptView_Edit))
            {
                grid_details.IsEnabled = false;

                button_addCostBearer.IsEnabled = false;

                //tabitem_documents.IsEnabled = false;

                grid_serviceaccountings.IsEnabled = false;

                if (BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConcept_AllowEditTasks))
                {
                    tabitem_tasks.IsSelected = true;
                }

                if (BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConcept_AllowEditGoals))
                {
                    tabitem_goals.IsSelected = true;
                }
            }

            

            if (pViewModel.VarFields == null || pViewModel.VarFields.VMList.Count == 0)
            {
                tabitem_varFields.Visibility = Visibility.Collapsed;
            }
            // HACK: Force the devexpress grid to end editing when the mouse is over savebutton
            // by setting the focus to another element. 
            this.MouseMove += (s, e) =>
                              {
                                  if (!this.gridViewTasks.IsVisible)
                                  {
                                      return;
                                  }

                                  Point p = e.GetPosition(this.btnSave);

                                  if (p.X >= 0 && p.X < this.btnSave.ActualWidth && p.Y >= 0 && p.Y < this.btnSave.ActualHeight)
                                  {
                                      bool b = this.gridViewTasks.Focus();
                                  }
                              };

            this.Loaded += OnLoaded;
        }

        private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
        {
            if (taskToEdit != null && ViewModel != null && ViewModel.Tasks != null)
            {
                tabitem_tasks.IsSelected = true;

                var item = ViewModel.Tasks.VMList.Single(vm => vm.DataContract.SchedulerAppointmentOid.Equals(taskToEdit.SchedulerAppointmentOid));
                var handle = grid_tasks.GetRowHandleByListIndex(ViewModel.Tasks.VMList.IndexOf(item));

                gridViewTasks.FocusedRowHandle = handle;

                grid_tasks.CurrentColumn = TaskGridColumnCompletedDate;

                Dispatcher.BeginInvoke(new Action(() => { gridViewTasks.ShowEditor(); }), DispatcherPriority.Background);
            }
        }

        public SupportConceptView(SupportConceptVM pViewModel, SchedulerAppointmentDC pTaskToEdit) : this(pViewModel)
        {
            taskToEdit = pTaskToEdit;
        }

        #endregion

        #region Properties

        private SupportConceptApprovalPeriodVM _SelectedApprovalPeriodVM;

        public SupportConceptApprovalPeriodVM SelectedApprovalPeriodVM
        {
            get => _SelectedApprovalPeriodVM;

            set
            {
                _SelectedApprovalPeriodVM = value;
                OnPropertyChanged(nameof(SelectedApprovalPeriodVM));
            }
        }

        public bool ShowHilfeplanBezeichnung => BeWoApp.AppSettings.ShowHilfeplanBezeichnung;

        public bool ShowDatevFields => BeWoApp.AppSettings.ShowDatevFields;

        public override bool IsDirty => ViewModel != null && ViewModel.IsDirty;

        public override string Title => Translator.Translate("Hilfepläne");

        internal override DependencyObject ValidationOnSaveRootElement => grid_details;

        internal SupportConceptVM ViewModel
        {
            get
            {
                return _ViewModel;
            }

            set
            {
                var i = 0;
                if (tabcontrol_costbearers != null)
                {
                    i = tabcontrol_costbearers.SelectedIndex;
                }

                _ViewModel = value;
                DataContext = value;
                if (ViewModel.Originator != null)
                {
                    popupedit_employee.Text = ViewModel.Originator.ToString();
                }

                if (ViewModel.Customer != null)
                {
                    popupedit_customer.Text = ViewModel.Customer.ToString();
                }

                //treeview_Goals.ItemsSource = value.CombinedGoalTree;

                if (tabcontrol_costbearers != null)
                {
                    tabcontrol_costbearers.SelectedIndex = i;
                }

                treeview_serviceAccountings.ItemsSource = value.GlobalServiceTree;
                //this.treeview_individualServiceAccountings.ItemsSource = value.IndividualServiceTree;
            }
        }

        #endregion

        #region Public Methods

        //private void InitSortCombo(ComboBox cb)
        //{
        //    var list = new List<String>();

        //    list.Add("aufsteigend");
        //    list.Add("absteigend");
            

        //    cb.ItemsSource = list;
        //    cb.SelectedIndex = BeWoApp.AppSettings.LastBewilligungSortOrder;


        //}

        public override void ModalPopUpCloseInvoked()
        {
            this.MainControl.CloseCurrentPopUp();
        }

        public override void ModalPopUpSaveInvoked()
        {
            // TODO nicht  schön, umbauen wenn an weiteren Stellen popup hierachien nötig werden
            if (this._PersonModalPopUp._OrganisationModalPopUp != null)
            {
                this._PersonModalPopUp._OrganisationModalPopUp.SaveData();
            }
            else
            {
                this._PersonModalPopUp.SaveData();
            }
        }

        #endregion

        #region Methods

        protected override UserRightType[] GetSaveDemands()
        {
            return ViewModel.IsNew
                       ? new[]
                         {
                             UserRightType.CreateAll, UserRightType.SupportConceptView_Create
                         }
                       : new[]
                         {
                             UserRightType.EditAll, UserRightType.SupportConceptView_Edit, UserRightType.SupportConcept_AllowEditGoals, UserRightType.SupportConcept_AllowEditTasks
                         };
        }

        protected override void Save()
        {
            if (ViewModel.CostBearerRelations.VMList.Exists(vm => vm.CostBearer == null))
            {
                MessageBox.Show(Translator.Translate("Bitte wählen Sie einen Kostenträger aus"), "Fehlende Eingabe", MessageBoxButton.OK);
                return;
            }

            foreach (var cbr in ViewModel.CostBearerRelations.VMList)
            {
                foreach (var ap in cbr.ApprovalPeriodList.VMList)
                {
                    var isAbsolute = false;
                    decimal summe = 0;
                    foreach (var ape in ap.SupportConceptApprovalEmployeeRelations.VMList)
                    {
                        summe += ape.Betreuungsschluessel;

                        isAbsolute = ape.IsAbsolut;
                    }

                    if (isAbsolute)
                    {
                        if (ap.ApprovedBEPerInterval.HasValue && summe > (ap.ApprovedBEPerInterval.Value * 60))
                        {
                            MessageBox.Show($"Die Summe der Anteile liegt bei über {(ap.ApprovedBEPerInterval.Value * 60):0} Minuten. Speichern nicht möglich.", "Fehler", MessageBoxButton.OK, MessageBoxImage.Warning);
                            return;
                        }
                    }
                    else if (summe > 100)
                    {
                        MessageBox.Show("Die Summe der Anteile liegt bei über 100%. Speichern nicht möglich.", "Fehler", MessageBoxButton.OK, MessageBoxImage.Warning);
                        return;
                    }
                }
            }


            var lDataContract = ViewModel.CommitToDataContract();

            var recordOutOfConcept = true;
            ServiceFacade.DoCustomerServiceSync(s => recordOutOfConcept = s.ServiceRecordOutOfSupportConcept(lDataContract));

            if (recordOutOfConcept)
            {

                if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.BookServiceRecordOutOfSupportConcept))
                {
                    MessageBox.Show(Translator.Translate("Es existiert mindestens eine Buchung außerhalb des Hilfeplanzeitraums."), "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Warning);
                    return;
                }
                else
                {
                    var mbResult = MessageBox.Show(Translator.Translate("Es existiert mindestens eine Buchung außerhalb des Hilfeplanzeitraums.\nMöchten Sie trotzdem speichern?"), "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Warning);

                    if (mbResult.Equals(MessageBoxResult.No))
                    {
                        return;
                    }
                }
            }

            if (!BeWoUtils.ValidateSupportConceptVM(ViewModel))
            {
                return;
            }
            try
            {
                //#region Neue Individuelle Ziele speichern
                var neueZM = ViewModel.CombinedGoals.VMList.Where(w => w.IsNew);
                
                ViewModel.TreeViewItemsList = new List<SupportConceptGoalTreeItem>();
                ViewModel.GetAllTreeViewItems();

                var obersteZiele = neueZM.Where(w => w.IsNew && (w.ParentEntry != null && w.ParentEntry.ValueListEntryOid != null) || w.ParentEntry == null).ToList();

                var alleNeuenZiele = new List<ValueListEntryDC>();
                foreach (var ziel in obersteZiele)
                {
                    var treeItem = ViewModel.TreeViewItemsList.FirstOrDefault(f => f.GoalEntryVM != null && f.GoalEntryVM.Equals(ziel));
                    if (treeItem != null)
                    {
                        alleNeuenZiele.AddRange(GoalService.SaveIndividualGoalsAndMassnahmenRecursively(treeItem));
                    }
                }

                lDataContract = ViewModel.CommitToDataContract();
                lDataContract.Goals.RemoveRange(lDataContract.Goals.Where(g => !g.ValueListEntryOid.HasValue));

                //ViewModel.CombinedGoals.VMList.RemoveRange(ViewModel.CombinedGoals.VMList.Where(w => w.IsNew));

                foreach (var zielDC in alleNeuenZiele)
                {
                    lDataContract.Goals.Add(zielDC);
                    //ViewModel.CombinedGoals.VMList.Add(new ValueListEntryVM(zielDC));
                }
                //#endregion

                if (ViewModel.IsNew)
                {
                    ServiceFacade.DoCustomerServiceAsync(s => s.InsertNewSupportConcept(lDataContract), ReloadViewModel);
                }
                else
                {
                    ServiceFacade.DoCustomerServiceAsync(s => s.UpdateSupportConcept(lDataContract), ReloadViewModel);
                }

                Cache.GetInstance().ClearSupportConceptTree();
                BeWoApp.MainControl.ResetView(UIContext.SupportConcept);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
        }

        private void Button_Loaded(object sender, RoutedEventArgs e)
        {
            var t = new DispatcherTimer(DispatcherPriority.Normal, Dispatcher) { Interval = TimeSpan.FromSeconds(.5) };
            t.Tick += delegate
                      {
                          ((Button)sender).Click += add_edit_employee_Click;
                          t.Stop();
                      };
            t.Start();
        }

        private void CostBearerSearchView_OrganisationSelected(object sender, EventArgs<CompactOrganisationDC> e)
        {
            popup_costbearer.IsOpen = false;

            if (ViewModel.CostBearerRelations.VMList.Exists(vm => vm.CostBearer != null && vm.CostBearer.CostBearerOid.Equals(e.Data.CostBearerOid)))
            {
                MessageBox.Show(Translator.Translate("Dieser Kostenträger wurde bereits hinzugefügt."), "Zufügen nicht möglich", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            if (!isChangingCostbearer)
            {
                var newVm = ViewModel.CostBearerRelations.NewVM;
                newVm.CostBearer = e.Data;

                if (ViewModel.Customer != null && string.IsNullOrEmpty(newVm.CustomerReferenceNumber) &&
                    ViewModel.Customer.CostBearerReferenceNumbers.ContainsKey(e.Data.CostBearerOid.Value))
                {
                    newVm.CustomerReferenceNumber = ViewModel.Customer.CostBearerReferenceNumbers[e.Data.CostBearerOid.Value];
                }

                ViewModel.CostBearerRelations.AddNewVMToList();
                tabcontrol_costbearers.SelectedIndex = tabcontrol_costbearers.Items.Count - 1;

                AddNewApprovalPeriod(newVm);
            }
            else
            {
                supportConceptCostBearerRel2Change.CostBearer = e.Data;

                if (ViewModel.Customer != null && ViewModel.Customer.CostBearerReferenceNumbers.ContainsKey(e.Data.CostBearerOid.Value))
                {
                    supportConceptCostBearerRel2Change.CustomerReferenceNumber = ViewModel.Customer.CostBearerReferenceNumbers[e.Data.CostBearerOid.Value];
                }
                else
                {
                    supportConceptCostBearerRel2Change.CustomerReferenceNumber = null;
                }

                supportConceptCostBearerRel2Change.CostBearerContactPerson = null;
            }

            isChangingCostbearer = false;
            supportConceptCostBearerRel2Change = null;
        }

        private void CustomerSearchView_CustomerSelected(object sender, EventArgs<CompactCustomerDC> e)
        {
            popup_customer.IsOpen = false;
            popupedit_customer.Focus();

            var newCustomer = e.Data;

            if (ViewModel.Customer != null && !ViewModel.Customer.Equals(newCustomer))
            {
                if (!ViewModel.IsNew)
                {
                    if (HasServiceRecords(ViewModel))
                    {
                        MessageBox.Show(Translator.Translate(
                                        "Für diesen Klienten wurden bereits Leistungen hinterlegt. Sie müssen diese Leistungen erst löschen bevor Sie den Klient wechseln können."),
                                        "Fehler",
                                        MessageBoxButton.OK,
                                        MessageBoxImage.Exclamation);
                        return;
                    }
                }
            }

            ViewModel.Customer = e.Data;
        }

        private void EmployeeSearchView_EmployeeSelected(object sender, EventArgs<CompactEmployeeDC> e)
        {
            popup_employee.IsOpen = false;

            if (!tabitem_tasks.IsSelected)
            {
                ViewModel.Originator = e.Data;
                popupedit_employee.Focus();
                popupedit_employee.Text = e.Data.ToString();
            }
            else
            {
                if (employeeEditFlag)
                {
                    var data = grid_tasks.View.FocusedRowData;

                    if (data?.RowHandle != null)
                    {
                        var vm = grid_tasks.GetRow(data.RowHandle.Value) as SchedulerAppointmentVM;

                        if (!vm.EmployeeList.Exists(i => i.Employee.EmployeeOid.Equals(e.Data.EmployeeOid)))
                        {
                            vm.EmployeeList.Add(new Employee2SchedulerAppointmentDC { Employee = e.Data });
                        }
                    }
                }
                else if (!ViewModel.Tasks.NewVM.EmployeeList.Exists(i => i.Employee.EmployeeOid.Equals(e.Data.EmployeeOid)))
                {
                    ViewModel.Tasks.NewVM.EmployeeList.Add(new Employee2SchedulerAppointmentDC { Employee = e.Data });
                }

                employeeEditFlag = false;
            }
        }

        private List<ServiceRecordDC> GetServiceRecords()
        {
            if (_ServiceRecords == null && ViewModel.Customer != null)
            {
                _ServiceRecords = ViewModel.IsArchived
                    ? ServiceFacade.DoOperationsServiceSync(s => s.GetCustomerServiceRecords(ViewModel.Customer.CustomerOid, true))
                    : ServiceFacade.DoOperationsServiceSync(s => s.GetCustomerServiceRecords(ViewModel.Customer.CustomerOid, false));
            }

            return _ServiceRecords;
        }

        private bool HasServiceRecords(SupportConceptCostBearerRelVM relVM)
        {
            var records = GetServiceRecords();

            if (records != null)
            {
                return records.Where(srDC => srDC.SupportConcept != null && srDC.CostBearer != null && relVM.CostBearer != null)
                    .Any(srDC => srDC.SupportConcept.SupportConceptOid == ViewModel.DataContract.SupportConceptOid && relVM.CostBearer.CostBearerOid == srDC.CostBearer.CostBearerOid);
            }

            return false;
        }

        private bool HasServiceRecords(SupportConceptVM vm)
        {
            var records = GetServiceRecords();

            if (records != null && records.Count > 0)
            {
                return records.Where(srDC => srDC.SupportConcept != null).Any(srDC => srDC.SupportConcept.SupportConceptOid == vm.DataContract.SupportConceptOid);
            }

            return false;
        }

        private void ReloadViewModel(long pOID)
        {
            var updatedTasks = ViewModel.Tasks.VMList.Where(w => !w.IsNew && w.IsDirty).ToList();
            var newTasks = ViewModel.Tasks.CopyToDCList(true).Where(w => !w.SchedulerAppointmentOid.HasValue).ToList();
            var updatedTaskDCs = new List<SchedulerAppointmentDC>();

            foreach (var t in updatedTasks)
            {
                t.CommitToDataContract();
                updatedTaskDCs.Add(t.DataContract);
            }

            ServiceFacade.DoResourceServiceAsync(s => s.DeleteSchedulerAppointments(_DeletedTasks.ToDictionary(d => d.SchedulerAppointmentOid.Value, d => d.NewSchedulerAppointmentVersion.Value)), () =>
            {
                ServiceFacade.DoResourceServiceAsync(s2 => s2.UpdateSchedulerAppointments(updatedTaskDCs), cb2 =>
                {
                    ServiceFacade.DoResourceServiceAsync(s => s.InsertSchedulerAppointments(newTasks), () =>
                    {
                        this.Dispatch(() =>
                        {
                            // reload to update version information and oid
                            VMFactory.CreateSupportConceptVMAsync(pOID, cb => this.Dispatch(delegate
                            {
                                ViewModel = cb;
                                _DeletedTasks.Clear();
                                FilterTreeItems();
                            }));
                        });
                    });
                });
            });
        }

        private void _PersonModalPopUp_PersonSavedOrUpdated(object sender, EventArgs<PersonVM> e)
        {
            ServiceFacade.DoCustomerServiceAsync(
                s => s.LoadPersonCompact(e.Data.DataContract.PersonOid.Value),
                p => this.Dispatch(
                    delegate
                    {
                        var cbRelVM = tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;
                        cbRelVM.CostBearerContactPerson = p;
                        MainControl.CloseCurrentPopUp();
                    }));
        }

        private void add_edit_employee_Click(object sender, RoutedEventArgs e)
        {
            employeeEditFlag = true;
            popup_employee.IsOpen = true;
        }

        private void btn_deleteApprovalPeriod_Click(object sender, RoutedEventArgs e)
        {
            var vm = ((Button)sender).Tag as SupportConceptApprovalPeriodVM;
            var cbRelVM = tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;

            if (cbRelVM.ApprovalPeriodList.VMList.Count == 1)
            {
                MessageBox.Show("Diese Bewilligungsperiode kann nicht gelöscht werden da mindestens eine vorhanden sein muss.");
                return;
            }

            cbRelVM.ApprovalPeriodList.VMList.Remove(vm);
        }

        private void btn_deleteCBRel_Click(object sender, RoutedEventArgs e)
        {
            var cbRelVM = tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;

            if (HasServiceRecords(cbRelVM))
            {
                MessageBox.Show(Translator.Translate(
                                "Für diesen Kostenträger wurden bereits Leistungen hinterlegt. Sie müssen diese Leistungen erst löschen bevor Sie den Kostenträger entfernen können."),
                                "Löschen",
                                MessageBoxButton.OK,
                                MessageBoxImage.Exclamation);
                return;
            }

            ViewModel.CostBearerRelations.VMList.Remove(cbRelVM);
        }

        private void button_addApprovalPeriod_Click(object sender, RoutedEventArgs e)
        {
            AddNewApprovalPeriod(((Button)sender).Tag as SupportConceptCostBearerRelVM);
        }

        private static void AddNewApprovalPeriod(SupportConceptCostBearerRelVM vm)
        {
            //var cbRelVM = this.tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;
            //var actual = cbRelVM.ApprovalPeriodList.VMList.OrderByDescending(i => i.StartDate).FirstOrDefault();

            //if (actual != null)
            //{
            //    vm.ApprovalPeriodList.NewVM.StartDate = vm.StartDate;
            //    vm.ApprovalPeriodList.NewVM.EndDate = vm.EndDate;
            //    vm.ApprovalPeriodList.NewVM.ApprovedBEInterval = actual.ApprovedBEInterval;
            //    vm.ApprovalPeriodList.NewVM.ApprovedBEPerInterval = actual.ApprovedBEPerInterval;
            //    vm.ApprovalPeriodList.NewVM.ApprovedBETotal = actual.ApprovedBETotal;
            //    vm.ApprovalPeriodList.NewVM.ApprovedFixedAmount = actual.ApprovedFixedAmount;
            //    vm.ApprovalPeriodList.NewVM.ApprovedFixedAmountInterval = actual.ApprovedFixedAmountInterval;
            //    vm.ApprovalPeriodList.NewVM.IsApprovedBEShifting = actual.IsApprovedBEShifting;
            //    vm.ApprovalPeriodList.NewVM.IsApprovedFixedAmountShifting = actual.IsApprovedFixedAmountShifting;
            //    vm.ApprovalPeriodList.NewVM.MonthlyPayment = actual.MonthlyPayment;
            //    vm.ApprovalPeriodList.NewVM.ServiceUnitName = actual.ServiceUnitName;

            //    //actual.StartDate = DateTime.Now.Date.AddDays(1);
            //    //actual.EndDate = vm.ApprovedEndDate;
            //}
            //else
            //{
            vm.ApprovalPeriodList.NewVM.StartDate = vm.StartDate;
            vm.ApprovalPeriodList.NewVM.EndDate = vm.EndDate;
            vm.ApprovalPeriodList.NewVM.ApprovedBEInterval = SupportConceptApprovalInterval.Weekly;
            vm.ApprovalPeriodList.NewVM.IsApprovedBEShifting = true;
            vm.ApprovalPeriodList.NewVM.IsApprovedFixedAmountShifting = true;

            if (vm.CostBearer != null)
            {
                vm.ApprovalPeriodList.NewVM.ServiceUnitName = vm.CostBearer.ServiceUnitName;
            }

            //}

            vm.ApprovalPeriodList.AddNewVMToList();
        }

        private void button_addCostBearer_Click(object sender, RoutedEventArgs e)
        {
            popup_costbearer.IsOpen = true;
        }

        private void Button_AddTask_Click(object sender, RoutedEventArgs e)
        {
            if (ValidationTrigger.Validate(groupbox_newTask) && ViewModel.DataContract.SupportConceptOid.HasValue)
            {
                //ServiceFacade.DoCustomerServiceAsync(s => s.LoadCompactSupportConceptDC(ViewModel.DataContract.SupportConceptOid.Value, null), sc =>
                //{
                //    this.Dispatch(() =>
                //    {
                var csc = new CompactSupportConceptDC();
                csc.SupportConceptOid = ViewModel.DataContract.SupportConceptOid.Value;
                ViewModel.Tasks.NewVM.SupportConceptList.Add(csc);
                ViewModel.Tasks.NewVM.IsTask = true;
                ViewModel.Tasks.NewVM.AllDay = true;

                if (ViewModel.Tasks.NewVM.DueDate == null)
                {
                    ViewModel.Tasks.NewVM.Start = DateTime.Today;
                    ViewModel.Tasks.NewVM.End = new DateTime(9999, 12, 31, 0, 0, 0);
                }
                else
                {
                    var end = ViewModel.Tasks.NewVM.DueDate.Value.AddDays(1);
                    ViewModel.Tasks.NewVM.Start = DateTime.Today;
                    ViewModel.Tasks.NewVM.End = end;
                }

                ViewModel.Tasks.AddNewVMToList();
                ViewModel.Tasks.NewVM.EmployeeList.Add(new Employee2SchedulerAppointmentDC { Employee = BeWoApp.CompactLoggedOnEmployee });
                //    });
                //});
            }
        }

        private void Button_AddEmployee_Click(object sender, RoutedEventArgs e)
        {
            popup_employee.IsOpen = true;
        }
        private void button_addAllEmployee_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("Wollen Sie die Aufgabe " + Translator.Translate("jedem Mitarbeiter") + " zuordnen?", "Achtung", MessageBoxButton.YesNo, MessageBoxImage.Exclamation) == MessageBoxResult.Yes)
            {
                var allEmployee = ServiceFacade.DoEmployeeServiceSync(s => s.GetAllActiveEmployeesCompact());
                //var relations = SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations;

                foreach (var emp in allEmployee)
                {
                    if (employeeEditFlag)
                    {
                        var data = grid_tasks.View.FocusedRowData;

                        if (data?.RowHandle != null)
                        {
                            var vm = grid_tasks.GetRow(data.RowHandle.Value) as SchedulerAppointmentVM;

                            if (!vm.EmployeeList.Exists(i => i.Employee.EmployeeOid.Equals(emp.EmployeeOid)))
                            {
                                vm.EmployeeList.Add(new Employee2SchedulerAppointmentDC { Employee = emp });
                            }
                        }
                    }
                    else if (!ViewModel.Tasks.NewVM.EmployeeList.Exists(i => i.Employee.EmployeeOid.Equals(emp.EmployeeOid)))
                    {
                        ViewModel.Tasks.NewVM.EmployeeList.Add(new Employee2SchedulerAppointmentDC { Employee = emp });
                    }
                }

                employeeEditFlag = false;
            }
        }

        private readonly List<SchedulerAppointmentDC> _DeletedTasks = new List<SchedulerAppointmentDC>();

        private void Button_RemoveTask_Click(object sender, RoutedEventArgs e)
        {
            var test = grid_tasks.GetCurrentValue<SchedulerAppointmentVM>();

            if (test.DataContract?.SchedulerAppointmentOid != null)
            {
                _DeletedTasks.AddIfNotIn(test.CommitToDataContract());
            }

            ViewModel.Tasks.VMList.Remove(test);
            BeWoWpfUtils.RefreshDXGrid(grid_tasks);
        }

        private void Button_Remove_Edit_Employee_Click(object sender, RoutedEventArgs e)
        {
            var data = grid_tasks.View.FocusedRowData;

            if (data?.RowHandle != null)
            {
                var vm = grid_tasks.GetRow(data.RowHandle.Value) as SchedulerAppointmentVM;

                vm?.EmployeeList.Remove((Employee2SchedulerAppointmentDC)((Button)sender).Tag);
            }
        }

        private void Button_Remove_Employee_Click(object sender, RoutedEventArgs e)
        {
            ViewModel.Tasks.NewVM.EmployeeList.Remove((Employee2SchedulerAppointmentDC)((Button)sender).Tag);
        }

        private void personsearchview_CostBearerContactPersonSelected(object sender, EventArgs<CompactPersonDC> e)
        {
            popup_person.IsOpen = false;
            personsearchview.ItemSelected -= personsearchview_CostBearerContactPersonSelected;

            var cbRelVM = tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;
            cbRelVM.CostBearerContactPerson = e.Data;
        }

        private long newPersonOid = 0;

        private void popupedit_costBearerContactPersonSearch_NewClick(object sender, RoutedEventArgs e)
        {
            if (ViewModel.IsNew)
            {
                MessageBox.Show("Bevor Sie eine neue Person anlegen können, muss dieser Datensatz zuerst gespeichert werden.", "Erst speichern bitte", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }
            else
            {
                newPersonOid = 0L;

                VMFactory.CreatePersonVMAsync(
                    cb => this.Dispatch(
                        () => BeWoUtils.OpenModalViewWindow<PersonVM, PersonDC, SupportConceptView>(cb, this, () => this.Dispatch(
                            delegate
                            {
                                if (newPersonOid > 0)
                                {
                                    var newPerson = new CompactPersonDC();


                                    //ServiceFacade.DoCustomerServiceSync(s => newPersonOid = s.InsertNewPerson(cb.CommitToDataContract()));

                                    ServiceFacade.DoCustomerServiceSync(s => newPerson = s.LoadPersonCompact(newPersonOid));

                                    ((SupportConceptCostBearerRelVM)tabcontrol_costbearers.SelectedItem).CostBearerContactPerson = null;
                                    ((SupportConceptCostBearerRelVM)tabcontrol_costbearers.SelectedItem).CostBearerContactPerson = newPerson;

                                    personsearchview.ObjectList.Add(newPerson);
                                }
                            }
                        ), personSavedOrUpdated: personModalPopUp_PersonSavedOrUpdated )));
            }
            
        }

        private void personModalPopUp_PersonSavedOrUpdated(object sender, EventArgs<PersonVM> e)
        {
            if (e.Data != null && e.Data.DataContract.PersonOid.HasValue)
            {
                newPersonOid = e.Data.DataContract.PersonOid.Value;
            }
        }

        private void popupedit_costBearerContactPersonSearch_PopUpClick(object sender, RoutedEventArgs e)
        {
            personsearchview.ItemSelected += personsearchview_CostBearerContactPersonSelected;
            popup_person.IsOpen = true;
        }

        private void popupedit_costBearer_PopUpClick(object sender, RoutedEventArgs e)
        {
            // sccbrvm = (SupportConceptCostBearerRelVM)((Control)sender).Tag;
            // popup_costbearer.IsOpen = true;
        }

        private void popupedit_customer_PopUpClick(object sender, RoutedEventArgs e)
        {
            popup_customer.IsOpen = true;
        }

        private void popupedit_employee_PopUpClick(object sender, RoutedEventArgs e)
        {
            popup_employee.IsOpen = true;
        }

        private void tabitem_documents_Selected(object sender, RoutedEventArgs e)
        {
            if (ViewModel.IsNew)
            {
                MessageBox.Show("Bevor zu einem Datensatz Dokumente hinterlegt werden können, muss dieser gespeichert werden.", "Erst speichern bitte", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            if (tabitem_documents.Content == null)
            {
                tabitem_documents.Content = new BeWoFileView(TableID.SupportConcept, ViewModel.DataContract.SupportConceptOid.Value);
            }
        }

        //private void tabitem_goalsNeu_selected(object sender, RoutedEventArgs e)
        //{
        //    //if (ViewModel.IsNew)
        //    //{
        //    //    MessageBox.Show("Bevor Sie Angaben zum Schulbegleitenden Dienst hinterlegen können, muss dieser Datensatz zuerst gespeichert werden.", "Erst speichern bitte", MessageBoxButton.OK, MessageBoxImage.Information);
        //    //    return;
        //    //}
        //    if (GridGoals.Children.Count == 0)
        //    {
        //        GridGoals.Children.Add(new SupportConceptGoalView(ViewModel));
        //    }
        //}

        // Kann das weg?
        private void ContextMenu_Click(object sender, RoutedEventArgs e)
        {
            //###IndServices
            //if (e.OriginalSource is MenuItem)
            //{
            //    var twi = e.OriginalSource as MenuItem;

            //    ServiceCategoryTreeItem selectedItem = this.treeview_individualServiceAccountings.SelectedItem as ServiceCategoryTreeItem;

            //    if (twi.Header.Equals("Neue Leistung"))
            //    {

            //        this.treeview_individualServiceAccountings.ItemContainerGenerator.StatusChanged +=
            //            this.ItemContainerGenerator_StatusChanged;

            //        ViewModel.AddIndividualService(selectedItem);

            //    }
            //    else if (twi.Header.Equals("Umbenennen"))
            //    {
            //        this.EditItem(this.treeview_individualServiceAccountings, null, selectedItem);
            //    }
            //    else if (twi.Header.Equals("Löschen"))
            //    {
            //        if (selectedItem != null && MessageBox.Show("ACHTUNG: Das Löschen von Leistungen kann nicht rückgängig gemacht werden.\n" +
            //                            "Alle verknüpften Eintragungen in der Zeiterfassung bleiben erhalten.\n\n" +
            //                            "Wollen Sie die Leistung '" + selectedItem.Name + "' wirklich löschen?", "Löschen bestätigen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
            //        {

            //            ViewModel.DeleteIndividualService(selectedItem);
            //        }
            //    }
            //}
        }

        private void ItemContainerGenerator_StatusChanged(object sender, EventArgs e)
        {
            //###IndServices
            //var ig = (ItemContainerGenerator)sender;
            //if (ig.Status != GeneratorStatus.ContainersGenerated)
            //{
            //    return;
            //}

            //var n = ig.ContainerFromIndex(this.treeview_individualServiceAccountings.Items.Count - 1) as TreeViewItem;
            //if (n != null)
            //{
            //    n.IsSelected = true;

            //    new DispatcherTimer(
            //        TimeSpan.FromMilliseconds(200),
            //        DispatcherPriority.Background,
            //        (s1, e1) =>
            //            {
            //                ServiceCategoryTreeItem item = ig.ItemFromContainer(n) as ServiceCategoryTreeItem;
            //                this.EditItem(this.treeview_individualServiceAccountings, null, item);
            //                ((DispatcherTimer)s1).Stop();
            //        },
            //        this.Dispatcher).Start();
            //}
            //this.treeview_individualServiceAccountings.ItemContainerGenerator.StatusChanged -= this.ItemContainerGenerator_StatusChanged;
        }

        private void ContextMenu_Opened(object sender, RoutedEventArgs e)
        {
            //if (e.OriginalSource is ContextMenu)
            //{
            //    ContextMenu menu = e.OriginalSource as ContextMenu;

            //    ServiceAccountingVM folder = this.treeview_individualServiceAccountings.SelectedItem as ServiceAccountingVM;

            //    foreach (var item in menu.Items)
            //    {
            //        if (item is MenuItem)
            //        {
            //            MenuItem menuitem = item as MenuItem;
            //            if (menuitem.Header.Equals("Umbenennen"))
            //                menuitem.IsEnabled = true;
            //        }
            //    }



            //}

        }

        private void TextBox_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Return)
            {
                UpdateSelectedTreeItemText((TextBox)sender);
            }
        }

        private void TextBox_LostFocus(object sender, RoutedEventArgs e)
        {
            UpdateSelectedTreeItemText((TextBox)sender);
        }

        private static void UpdateSelectedTreeItemText(TextBoxBase textBox)
        {
            if (!textBox.IsReadOnly)
            {
                textBox.Background = Brushes.Transparent;
                textBox.IsReadOnly = true;
                textBox.BorderThickness = new Thickness(0);
                textBox.Padding = new Thickness(1, 3, 1, 3);
            }
        }

        // scheint nicht mehr genutzt zu werden
        private void TreeViewItem_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
        {
            var source = e.OriginalSource as DependencyObject;
            while (source != null && !(source is TreeViewItem))
            {
                source = VisualTreeHelper.GetParent(source);
            }

            if (source != null)
            {
                ((TreeViewItem)source).IsSelected = true;
                //this._SelectedTreeNode = (TreeViewItem)source;
            }
            else
            {
                //this._SelectedTreeNode = null;
            }
        }

        private void GoalTreeViewItem_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
        {
            var source = e.OriginalSource as DependencyObject;
            while (source != null && !(source is TreeViewItem))
            {
                source = VisualTreeHelper.GetParent(source);
            }

            if (source != null)
            {
                ((TreeViewItem)source).IsSelected = true;
                _SelectedGoalTreeNode = (TreeViewItem)source;
            }
            else
            {
                _SelectedGoalTreeNode = null;
            }
        }

        private void ContextMenuGoals_Click(object sender, RoutedEventArgs e)
        {
            if (!(e.OriginalSource is MenuItem twi)) return;

            var selectedItem = treeview_Goals.SelectedItem as SupportConceptGoalTreeItem;

            switch (twi.Header)
            {
                case "Neues individuelles Ziel":
                    if (_SelectedGoalTreeNode != null)
                    {
                        ViewModel.AddTreeItemWithControl(selectedItem, ValueListEntryType.SupportConceptIndividualGoalCategoryType, "Ziel hinzufügen");
                    }
                    break;
                case "Neue individuelle Maßnahme":
                    if (_SelectedGoalTreeNode != null)
                    {
                        ViewModel.AddTreeItemWithControl(selectedItem, ValueListEntryType.SupportConceptIndividualGoalType, "Maßnahme hinzufügen");
                    }
                    break;
                case "Löschen":
                    if (selectedItem != null)
                    {
                        var zielOderMassnahme = selectedItem.GoalEntryVM.Type == ValueListEntryType.SupportConceptGoalCategoryType || selectedItem.GoalEntryVM.Type == ValueListEntryType.SupportConceptIndividualGoalCategoryType ? "das Ziel" : "die Maßnahme";
                        var pluralendung = zielOderMassnahme.Equals("das Ziel") ? "en" : "n";

                        if (MessageBox.Show("ACHTUNG: Das Löschen von " + zielOderMassnahme.Substring(4) + pluralendung + " kann nicht rückgängig gemacht werden.\n" +
                                            "Alle verknüpften Eintragungen in der Zeiterfassung bleiben erhalten.\n\n" +
                                            "Wollen Sie " + zielOderMassnahme + " '" + selectedItem.GoalEntryVM?.DisplayName + "' wirklich löschen?", "Löschen bestätigen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
                        {
                            ViewModel.DeleteIndividualGoal(selectedItem);
                        }
                    }
                    break;
                case "Bearbeiten":
                    if (selectedItem != null)
                        ViewModel.EditTreeItem(selectedItem.GoalEntryVM);
                    break;
            }
        }
        
        private void ContextMenuGoals_Opened(object sender, RoutedEventArgs e)
        {
            if (e.OriginalSource is ContextMenu)
            {
                var menu = e.OriginalSource as ContextMenu;
                var goal = treeview_Goals.SelectedItem as SupportConceptGoalTreeItem;

                foreach (var menuitem in menu.Items.OfType<MenuItem>().Select(item => item))
                {
                    if (menuitem.Header.Equals("Bearbeiten"))
                    {
                        menuitem.IsEnabled = goal != null && (goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalCategoryType) || goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalType));
                    }
                    else if (menuitem.Header.Equals("Neues individuelles Ziel") || menuitem.Header.Equals("Neue individuelle Maßnahme"))
                    {
                        menuitem.IsEnabled = goal != null && (goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalCategoryType) || goal.GoalType.Equals(ValueListEntryType.SupportConceptGoalCategoryType));
                    }
                    else if (menuitem.Header.Equals("Löschen"))
                    {
                        menuitem.IsEnabled = goal != null && (goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalCategoryType) || goal.GoalType.Equals(ValueListEntryType.SupportConceptIndividualGoalType));
                    }

                    if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.SupportConcept_AllowEditGoals))
                    {
                        menuitem.IsEnabled = false;
                    }
                }
            }
        }

        #endregion

        private void CboServiceCategory_OnInitialized(object sender, EventArgs e)
        {
            var cbo = sender as ComboBoxEdit;

            if (cbo != null)
            {
                Cache.GetInstance().GetServiceCategoryDescriptionDict(
                    cb => cbo.Dispatch(delegate
                    {
                        cbo.ItemsSource = cb.Keys.Where(cat => cat.ScopeType == ScopeTypeId.Global).ToList();
                    }));
            }
        }

        private void ButtonInfo_OnClick(object sender, RoutedEventArgs e)
        {
            var btn = sender as Button;
            var bc = btn.TemplatedParent as ButtonContainer;

            if (bc != null)
            {
                var bi = bc.Content as ButtonInfo;

                if (bi != null)
                {
                    var vm = bi.Tag as SupportConceptApprovalPeriodVM;

                    if (vm != null)
                    {
                        vm.ServiceCategory = null;
                    }
                }
            }
        }

        private void Popupedit_employee_OnPreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            // EmployeeView
            if (!BeWoUtils.CheckPopupEditClickableSpace((PopUpEdit)sender, e) || ViewModel.Originator == null || !BeWoApp.LoggedOnUser.HasRight(UserRightType.EmployeeView_View))
            {
                return;
            }

            VMFactory.CreateEmployeeVMAsync(ViewModel.Originator.EmployeeOid,
                cb => this.Dispatch(
                    () => BeWoUtils.OpenModalViewWindow<EmployeeVM, EmployeeDC, SupportConceptView>(cb, this,
                    () => this.Dispatch(() => BeWoUtils.UpdateAllViews(ViewModel.Originator)))));
        }

        private void Popupedit_customer_OnPreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            // CustomerView
            if (!BeWoUtils.CheckPopupEditClickableSpace((PopUpEdit)sender, e) || ViewModel.Customer == null || !BeWoApp.LoggedOnUser.HasRight(UserRightType.CustomerView_View))
            {
                return;
            }

            VMFactory.CreateCustomerVMAsync(ViewModel.Customer.CustomerOid,
                cb => this.Dispatch(
                    () => BeWoUtils.OpenModalViewWindow<CustomerVM, CustomerDC, SupportConceptView>(cb, this,
                    () => this.Dispatch(() => BeWoUtils.UpdateAllViews(ViewModel.Customer)))));
        }

        private void Popupedit_costBearerContactPersonSearch_OnPreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var contactPerson = ((SupportConceptCostBearerRelVM)tabcontrol_costbearers.SelectedItem).CostBearerContactPerson;

            if (!BeWoUtils.CheckPopupEditClickableSpace((PopUpEdit)sender, e) || contactPerson == null || !BeWoApp.LoggedOnUser.HasRight(UserRightType.PersonView_View))
            {
                return;
            }

            VMFactory.CreatePersonVMAsync(contactPerson.PersonOid,
                cb => this.Dispatch(
                    () => BeWoUtils.OpenModalViewWindow<PersonVM, PersonDC, SupportConceptView>(cb, this,
                    () => this.Dispatch(() => BeWoUtils.UpdateAllViews(contactPerson)), personSavedOrUpdated: _PersonModalPopUp_PersonSavedOrUpdated)));
        }

        private void DoubleClickHandler(object sender, MouseButtonEventArgs e)
        {
            var selectedEmployee = ((ListBoxItem)sender).Content as CompactEmployeeDC;

            if (selectedEmployee == null || !BeWoApp.LoggedOnUser.HasRight(UserRightType.EmployeeView_View))
            {
                return;
            }

            VMFactory.CreateEmployeeVMAsync(selectedEmployee.EmployeeOid,
                cb => this.Dispatch(
                    () => BeWoUtils.OpenModalViewWindow<EmployeeVM, EmployeeDC, SupportConceptView>(cb, this,
                    () => this.Dispatch(() => BeWoUtils.UpdateAllViews(selectedEmployee)))));
        }

        private void Control_OnPreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            var label = sender as Label;
            var labelparent = label.Parent as StackPanel;
            var btn = labelparent.Children[0] as Button;
            var Employee = btn.Tag as CompactEmployeeDC;

            VMFactory.CreateEmployeeVMAsync(Employee.EmployeeOid,
                cb => this.Dispatch(
                    () => BeWoUtils.OpenModalViewWindow<EmployeeVM, EmployeeDC, SupportConceptView>(cb, this,
                    () => this.Dispatch(() => BeWoUtils.UpdateAllViews(Employee)))));
        }

        private void ListItemGrid_OnLoaded(object sender, RoutedEventArgs e)
        {
            var grid = sender as Grid;

            var vm = grid.DataContext as SupportConceptApprovalPeriodVM;

            //if (vm != null && !SupportConceptApprovalPeriodVM.ShowContactCountFields)
            //{
            //    grid.Children[grid.Children.Count - 2].Visibility = Visibility.Collapsed;
            //    grid.Children[grid.Children.Count - 3].Visibility = Visibility.Collapsed;
            //    grid.Children[grid.Children.Count - 4].Visibility = Visibility.Collapsed;
            //    grid.Children[grid.Children.Count - 5].Visibility = Visibility.Collapsed;
            //}

            var gridControl = new GridControl();

            Grid.SetRow(gridControl, 10);
            Grid.SetColumn(gridControl, 0);
            Grid.SetColumnSpan(gridControl, 7);

            gridControl.Margin = new Thickness(3d);

            var itemsSourceBinding = new Binding("SupportConceptApprovalEmployeeRelations.VMList") { Source = grid.DataContext };
            gridControl.SetBinding(DataControlBase.ItemsSourceProperty, itemsSourceBinding);

            var gridControlVisibilityBinding = new Binding("SupportConceptApprovalEmployeeRelations.GridVisibility") { UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged, Source = grid.DataContext };
            gridControl.SetBinding(VisibilityProperty, gridControlVisibilityBinding);
            gridControl.IsVisibleChanged += GridControl_IsVisibleChanged;
            var deleteColumn = new GridColumn { Header = "", FixedWidth = true, Width = 24, ReadOnly = true, CellTemplate = (DataTemplate)Resources["DeleteBtnBetreuungsschluesselDataTemplate"] };

            gridControl.Columns.Add(deleteColumn);

            var employeeColumn = new GridColumn { Header = Translator.Translate("MitarbeiterSingular"), FieldName = "EmployeeString", AllowEditing = DefaultBoolean.False, Width = 250 };

            var allowEditingBetreuungsschluesselColumn = BeWoApp.HasLoggedOnUserRight(new[] { UserRightType.EditAll, UserRightType.Betreuungsschluessel_Edit }) ? DefaultBoolean.True : DefaultBoolean.False;
            var betreuungsschluesselColumn = new GridColumn { Name = "ColumnBSProzent", Header = "Anteil an der Betreuung", FieldName = "Betreuungsschluessel", AllowEditing = allowEditingBetreuungsschluesselColumn, Width = 170, EditSettings = new TextEditSettings { MaskUseAsDisplayFormat = true, MaskType = MaskType.Numeric, Mask = "########0.00" } };
            //var betreuungsschluesselColumnAbsolut = new GridColumn { Name = "ColumnBSAbsolut", Header = "Betreuung in Minuten", FieldName = "Betreuungsschluessel", AllowEditing = allowEditingBetreuungsschluesselColumn, Width = 170, EditSettings = new TextEditSettings { MaskUseAsDisplayFormat = true, MaskType = MaskType.Numeric, Mask = "########0" } };
            //betreuungsschluesselColumnAbsolut.Visible = false;

            gridControl.Columns.Add(employeeColumn);
            gridControl.Columns.Add(betreuungsschluesselColumn);
            //gridControl.Columns.Add(betreuungsschluesselColumnAbsolut);

            gridControl.View = new TableView { AutoWidth = false, ShowGroupPanel = false, ShowGroupedColumns = false, ShowTotalSummary = false, NavigationStyle = GridViewNavigationStyle.Cell };


            grid.Children.Add(gridControl);
        }

        private void GridControl_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            if ((bool)e.NewValue)
            {
                GridControl gc = sender as GridControl;

                var list = gc.ItemsSource as BindingList<SupportConceptApprovalPeriodEmployeeRelVM>;

                bool isAbsolute = false;
                if (list != null && list.Count > 0)
                {
                    isAbsolute = list[0].IsAbsolut;
                }
                if (isAbsolute)
                {
                    gc.Columns[2].Header = "Betreuung in Minuten";
                    ((TextEditSettings)gc.Columns[2].EditSettings).Mask = "########0";
                }
                else
                {
                    gc.Columns[2].Header = "Anteil an der Betreuung (%)";
                    ((TextEditSettings)gc.Columns[2].EditSettings).Mask = "########0.00";
                }
            }
        }

        private void ChangeCostbearerBtn_Click(object sender, RoutedEventArgs e)
        {
            supportConceptCostBearerRel2Change = (SupportConceptCostBearerRelVM)((Button)sender).Tag;
            isChangingCostbearer = true;

            popup_costbearer.IsOpen = true;
        }

        private void button_checkAllGoals_Click(object sender, RoutedEventArgs e)
        {
            CheckAllGoalTreeItems(true);
        }

        private void button_uncheckAllGoals_Click(object sender, RoutedEventArgs e)
        {
            CheckAllGoalTreeItems(false);
        }

        private void button_aufklappenAllGoals_Click(object sender, RoutedEventArgs e)
        {
            SwitchAllGoalTreeItems(true);
        }

        private void button_zuklappenAllGoals_Click(object sender, RoutedEventArgs e)
        {
            SwitchAllGoalTreeItems(false);
        }

        private void button_checkAllLeistungen_Click(object sender, RoutedEventArgs e)
        {
            CheckAllLeistungTreeItems(true);
        }

        private void button_uncheckAllLeistungen_Click(object sender, RoutedEventArgs e)
        {
            CheckAllLeistungTreeItems(false);
        }

        private void button_aufklappenAllLeistungen_Click(object sender, RoutedEventArgs e)
        {
            SwitchAllLeistungTreeItems(true);
        }

        private void button_zuklappenAllLeistungen_Click(object sender, RoutedEventArgs e)
        {
            SwitchAllLeistungTreeItems(false);
        }

        private void CheckAllLeistungTreeItems(bool check)
        {
            var allItems = treeview_serviceAccountings.ItemsSource as IList<ServiceCategoryTreeItem>;

            foreach (var item in allItems)
            {
                item.IsChecked = check;
            }
        }

        private void SwitchAllLeistungTreeItems(bool check)
        {
            Style stylee = new Style
            {
                TargetType = typeof(TreeViewItem)
            };

            stylee.Setters.Add(new Setter(TreeViewItem.IsExpandedProperty, check));
            treeview_serviceAccountings.ItemContainerStyle = stylee;
        }

        private void SwitchAllGoalTreeItems(bool check)
        {
            Style stylee = new Style
            {
                TargetType = typeof(TreeViewItem)
            };

            stylee.Setters.Add(new Setter(TreeViewItem.IsExpandedProperty, check));
            treeview_Goals.ItemContainerStyle = stylee;
        }

        private void CheckAllGoalTreeItems(bool check)
        {
            foreach (var item in treeview_Goals.ItemsSource)
            {
                
                ((SupportConceptGoalTreeItem)item).IsChecked = check;
            }
        }

        private void button_openAddBetreuungsschluessel_Click(object sender, RoutedEventArgs e)
        {
            popup_newBetreuungsschluessel.IsOpen = true;

            var btn = (Button)sender;
            var grid = (Grid)btn.Parent;
            var border = (Border)grid.Parent;
            var contentPresenter = (ContentPresenter)border.TemplatedParent;
            SelectedApprovalPeriodVM = (SupportConceptApprovalPeriodVM)contentPresenter.Content;

            if (SelectedApprovalPeriodVM != null)
            {
                bool isabsolute = false;

                if (SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.Count == 0)
                {
                    RadioAbsolPro.Visibility = Visibility.Visible;
                    RadioProzent.IsChecked = true;
                    SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Betreuungsschluessel = 100;

                }
                else
                {
                    RadioAbsolPro.Visibility = Visibility.Collapsed;

                    if (SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.Last().IsAbsolut)
                    {
                        isabsolute = true;


                        SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.IsAbsolut = true;

                        //var cbRelVM = this.tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;
                        //var actual = cbRelVM.ApprovalPeriodList.VMList.OrderByDescending(i => i.StartDate).FirstOrDefault();

                        decimal max = 0;
                        if (SelectedApprovalPeriodVM.ApprovedBEPerInterval.HasValue)
                        {
                            max = SelectedApprovalPeriodVM.ApprovedBEPerInterval.Value * 60;
                            editAbsolut.MaxValue = max;
                        }


                        var alt =
                            SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.Sum(
                                s => s.Betreuungsschluessel);

                        if (alt > max)
                            alt = max;

                        SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Betreuungsschluessel = (int)(max - alt);

                    }
                    else
                    {
                        SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.IsAbsolut = false;

                        var alt = SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.Sum(s => s.Betreuungsschluessel);

                        if (alt > 100)
                            alt = 100;
                        SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Betreuungsschluessel = 100 - alt;
                    }
                }
                if (isabsolute)
                {
                    LabelProzentual.Visibility = Visibility.Collapsed;
                    LabelAbsolut.Visibility = Visibility.Visible;

                    editProzentual.Visibility = Visibility.Collapsed;
                    editAbsolut.Visibility = Visibility.Visible;

                }
                else
                {
                    LabelProzentual.Visibility = Visibility.Visible;
                    LabelAbsolut.Visibility = Visibility.Collapsed;

                    editProzentual.Visibility = Visibility.Visible;
                    editAbsolut.Visibility = Visibility.Collapsed;
                }
            }
        }

        private void button_addBetreuungsschluessel_Click(object sender, RoutedEventArgs e)
        {
            if (SelectedApprovalPeriodVM != null && Validate(groupbox_newBetreuungsschluessel))
            {
                if (SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.IsAbsolut)
                {
                    var alt = SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.Sum(s => s.Betreuungsschluessel);

                    if (editAbsolut.MaxValue.HasValue)
                    {
                        if (alt +
                            SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Betreuungsschluessel >
                            editAbsolut.MaxValue)
                        {
                            MessageBox.Show(String.Format("Die Summe der Anteile liegt bei über {0:0} Minuten. Hinzufügen nicht möglich.", editAbsolut.MaxValue), "Fehler", MessageBoxButton.OK, MessageBoxImage.Warning);
                            return;
                        }
                    }
                }
                else
                {
                    var alt = SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.Sum(s => s.Betreuungsschluessel);

                    if (alt + SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Betreuungsschluessel > 100)
                    {
                        MessageBox.Show("Die Summe der Anteile liegt bei über 100%. Hinzufügen nicht möglich.", "Fehler", MessageBoxButton.OK, MessageBoxImage.Warning);
                        return;
                    }
                }


                SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.AddNewVMToList();
            }

            SelectedApprovalPeriodVM = null;

            popup_newBetreuungsschluessel.IsOpen = false;

        }

        private void button_cancelBetreuungsschluessel_Click(object sender, RoutedEventArgs e)
        {
            popup_newBetreuungsschluessel.IsOpen = false;
            SelectedApprovalPeriodVM = null;
        }

        private void popupedit_betreuungsschluessel_PopUpClick(object sender, RoutedEventArgs e)
        {
            popup_employee2.IsOpen = true;
        }

        private void Popupedit_betreuungsschluessel_OnPreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            if (!BeWoUtils.CheckPopupEditClickableSpace((PopUpEdit)sender, e) ||
                SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Employee == null ||
                !BeWoApp.LoggedOnUser.HasRight(UserRightType.EmployeeView_View))
            {
                return;
            }

            VMFactory.CreateEmployeeVMAsync(SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Employee.EmployeeOid,
                cb => this.Dispatch(
                    () => BeWoUtils.OpenModalViewWindow<EmployeeVM, EmployeeDC, SupportConceptView>(cb, this,
                    () => this.Dispatch(() => BeWoUtils.UpdateAllViews(SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Employee)))));
        }

        private void EmployeeSearchView_EmployeeSelected2(object sender, EventArgs<CompactEmployeeDC> e)
        {
            if (SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.Any(a => a.Employee.EmployeeOid.Equals(e.Data.EmployeeOid)))
            {
                MessageBox.Show("Sie können " + Translator.Translate("einen Betreuer") + " nicht mehrmals hinzufügen.", "Ungültige Auswahl", MessageBoxButton.OK, MessageBoxImage.Warning);

                return;
            }

            popup_employee2.IsOpen = false;
            SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Employee = e.Data;
            popup_newBetreuungsschluessel.Focus();
        }

        public event PropertyChangedEventHandler PropertyChanged;

        [NotifyPropertyChangedInvocator]
        protected virtual void OnPropertyChanged(string propertyName)
        {
            var handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }

        private void DeleteBetreuungsschluesselButton_Click(object sender, RoutedEventArgs e)
        {
            var btn = (Button)sender;
            var currentObject = (SupportConceptApprovalPeriodEmployeeRelVM)((EditGridCellData)btn.Tag).RowData.Row;

            var supportConceptCostBearerRel = ViewModel.CostBearerRelations.VMList.FirstOrDefault(f => f.ApprovalPeriodList.VMList.Any(a => a.SupportConceptApprovalEmployeeRelations.VMList.Contains(currentObject)));
            var approvalPeriod = supportConceptCostBearerRel.ApprovalPeriodList.VMList.FirstOrDefault(f => f.SupportConceptApprovalEmployeeRelations.VMList.Contains(currentObject));

            approvalPeriod.SupportConceptApprovalEmployeeRelations.VMList.Remove(currentObject);

            var abc = SelectedApprovalPeriodVM;
        }

        private void ToggledProz_OnChecked(object sender, RoutedEventArgs e)
        {
            LabelProzentual.Visibility = Visibility.Visible;
            LabelAbsolut.Visibility = Visibility.Collapsed;

            editProzentual.Visibility = Visibility.Visible;
            editAbsolut.Visibility = Visibility.Collapsed;
            SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.IsAbsolut = false;
            SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Betreuungsschluessel = 100;
        }

        private void ToggledAbsol_OnChecked(object sender, RoutedEventArgs e)
        {
            var cbRelVM = this.tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;

            var actual = SelectedApprovalPeriodVM ?? cbRelVM.ApprovalPeriodList.VMList.OrderByDescending(i => i.StartDate).FirstOrDefault();


            if (actual.ApprovedBEPerInterval.HasValue)
            {
                editAbsolut.MaxValue = actual.ApprovedBEPerInterval * 60;

            }

            SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Betreuungsschluessel = editAbsolut.MaxValue ?? 0;
            LabelProzentual.Visibility = Visibility.Collapsed;
            LabelAbsolut.Visibility = Visibility.Visible;

            editProzentual.Visibility = Visibility.Collapsed;
            editAbsolut.Visibility = Visibility.Visible;

            SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.IsAbsolut = true;
        }

        private void Tabitem_tasks_OnSelected(object sender, RoutedEventArgs e)
        {
            if (ViewModel.IsNew)
            {
                tabitem_grid_tasks.Visibility = Visibility.Collapsed;

                MessageBox.Show("Bevor zu einem Datensatz Aufgaben angelegt werden können, muss dieser gespeichert werden.", "Erst speichern bitte", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            tabitem_grid_tasks.Visibility = Visibility.Visible;
        }

        private void RadioButton_Checked(object sender, RoutedEventArgs e)
        {
            var check = (RadioButton)sender;
            var selected = (SupportConceptApprovalPeriodVM)check.Tag;

            switch (check.Name)
            {
                case "RadioButtonBudget":
                    selected.Bewilligungsart = Bewilligungsart.Budget;
                    break;
                case "RadioButtonDirekt":
                    selected.Bewilligungsart = Bewilligungsart.Direkt;
                    break;
            }
        }

        private void BtnEditRating_Click(object sender, RoutedEventArgs e)
        {
            var btn = sender as Button;
            if (btn != null)
            {
                var rating = btn.Tag as RatingVM;

                if (rating != null)
                {
                    var ratingCopy = CopyRatingVM(rating);

                    var changed = EditRating(ratingCopy);
                    if (changed != null)
                    {
                        rating.StartDate = changed.StartDate;
                        rating.DisplayName = changed.DisplayName;
                        rating.Notice = changed.Notice;
                        rating.RTFNotice = changed.RTFNotice;
                        rating.RatingId = changed.RatingId;

                        rating.GoalRatingList.VMList.Clear();
                        foreach (var goalRatingVm in changed.GoalRatingList.VMList)
                        {
                            rating.GoalRatingList.VMList.Add(goalRatingVm);
                        }


                    }
                }
            }
        }

        private RatingVM CopyRatingVM(RatingVM rating)
        {
            RatingDC dc = rating.DataContract;

            //if (rating.IsNew)
            //{
                dc = rating.CommitToDataContract();
            //}
            var newVm = new RatingVM(dc);
            return newVm;
        }


        private void BtnDeleteRating_Click(object sender, RoutedEventArgs e)
        {
            var btn = sender as Button;
            if (btn != null)
            {
                var rating = btn.Tag as RatingVM;

                ViewModel.Ratings.VMList.Remove(rating);
            }
            
        }

        private void BtnAddRating_Click(object sender, RoutedEventArgs e)
        {
            var rating = new RatingVM(new RatingDC());
            rating.StartDate = DateTime.Now;

            foreach (var goal in ViewModel.GetSelectedGoals())
            {
                if (goal.Type == ValueListEntryType.SupportConceptGoalCategoryType ||
                    goal.Type == ValueListEntryType.SupportConceptIndividualGoalCategoryType)
                {
                    AddIfNotExist(rating, goal);
                    
                }
                else
                {
                    //Find Parent Goal
                    if (goal.ParentOid.HasValue)
                    {

                        var p = ViewModel.CombinedGoals.VMList.FirstOrDefault(vm => vm.DataContract.ValueListEntryOid == goal.ParentOid);
                        
                        if (p != null)
                        {
                            AddIfNotExist(rating, p.DataContract);
                        }
                    }
                }

            }

            var savedRating = EditRating(rating);
            if (savedRating != null)
            {
                ViewModel.Ratings.VMList.Add(savedRating);
            }
        }

        private void AddIfNotExist(RatingVM rating, ValueListEntryDC goal)
        {
            if (!rating.GoalRatingList.VMList.Any(vm => vm.GoalEntry.Equals(goal)))
            {
                var gr = rating.GoalRatingList.VMList.AddNew();
                gr.GoalEntry = goal;
            }
        }

        private RatingVM EditRating(RatingVM vm)
        {
            var control = new RatingEditView();
            control.InitView(vm);
            var height = this.ActualHeight - 50;
            if (height < 600)
            {
                height = 600;
            }
            var beWoWindow = new BeWoWindow
            {
                rootGroupBox = { Header = "Bewertung bearbeiten" },
                Height = height,
                Width = 1000,
                MinWidth = 550,
                WindowStartupLocation = WindowStartupLocation.CenterOwner,
                GroupBoxContent = control,
                Owner = BeWoApp.CurrentBeWo.MainWindow
            };

            bool saved = false;

            control.ButtonSavedClicked += () =>
            {
                saved = true;   
                beWoWindow.Close();
            };

            control.ButtonCancelClicked += () =>
            {
                beWoWindow.Close();
            };

            beWoWindow.ShowDialog();

            if (!saved)
            {
                return null;
            }
            return control.ViewModel;
        }

        
        public void AnimateOpacity(double pOpacitiy, double pDuration)
        {
            // System.Windows.Media.TransformGroup group = this.DetailFrame.RenderTransform as System.Windows.Media.TransformGroup;
            // System.Windows.Media.ScaleTransform scale = group.Children[0] as System.Windows.Media.ScaleTransform;
            var lAnimation = new DoubleAnimation
            {
                From = root.Opacity,
                To = pOpacitiy,
                Duration = TimeSpan.FromMilliseconds(pDuration)
            };

            // lAnimation.From = scale.ScaleX;
            // lAnimation.To = pOpacitiy;
            root.BeginAnimation(OpacityProperty, lAnimation);

            // scale.BeginAnimation(System.Windows.Media.ScaleTransform.ScaleXProperty, lAnimation);
            // scale.BeginAnimation(System.Windows.Media.ScaleTransform.ScaleYProperty, lAnimation);
        }

        private void AuswertungTab_OnSelected(object sender, RoutedEventArgs e)
        {
            //RatingView.UpdateControl();
        }

        private void TxtSearchGoals_OnEditValueChanged(object sender, EditValueChangedEventArgs e)
        {
            FilterTreeItems();
        }

        private void FilterTreeItems()
        {
            String searchtext = TxtSearchGoals.Text;
            bool onlyChecked = chkShowSelectedGoals.IsChecked.HasValue && chkShowSelectedGoals.IsChecked.Value;
            
            foreach (var goal in treeview_Goals.Items)
            {
                SetTreeItemVisibility(treeview_Goals.ItemContainerGenerator, goal as SupportConceptGoalTreeItem, searchtext, onlyChecked);
                
                
                //if (ig.Status != GeneratorStatus.ContainersGenerated)
                //{
                //    return;
                //}

                //var n = ig.ContainerFromIndex(this.treeview_individualServiceAccountings.Items.Count - 1) as TreeViewItem;
                //if (n != null)
                //{
                //    n.IsSelected = true;

                //    new DispatcherTimer(
                //        TimeSpan.FromMilliseconds(200),
                //        DispatcherPriority.Background,
                //        (s1, e1) =>
                //            {
                //                ServiceCategoryTreeItem item = ig.ItemFromContainer(n) as ServiceCategoryTreeItem;
                //                this.EditItem(this.treeview_individualServiceAccountings, null, item);
                //                ((DispatcherTimer)s1).Stop();
                //        },
                //        this.Dispatcher).Start();
                //}
                //this.treeview_individualServiceAccountings.ItemContainerGenerator.StatusChanged -= this.ItemContainerGenerator_StatusChanged;
            }
        }

        private void SetTreeItemVisibility(ItemContainerGenerator ig, SupportConceptGoalTreeItem goal, string searchtext, bool onlyChecked)
        {
            
            var item = ig.ContainerFromItem(goal) as TreeViewItem;

            if (item == null)
            {
                treeview_Goals.UpdateLayout();
                item = ig.ContainerFromItem(goal) as TreeViewItem;
            }

            if (item == null)
                return;
            if (item.ToString().ToLower().Contains("fussball"))
            {
                int test = 0;
            }
            if (goal.Items == null || goal.Items.Count == 0)
            {
                if (IsTreeItemVisible(goal, searchtext, onlyChecked))
                {
                    item.Visibility = Visibility.Visible;
                }
                else
                {
                    item.Visibility = Visibility.Collapsed;
                }
                
            }
            else
            {
                foreach (var child in goal.Items)
                {
                    SetTreeItemVisibility(item.ItemContainerGenerator, child, searchtext, onlyChecked);   
                }


                if (IsAtLeastOneChildVisible(goal.Items, searchtext, onlyChecked))
                {
                    item.Visibility = Visibility.Visible;
                }
                else
                {
                    if (IsTreeItemVisible(goal, searchtext, onlyChecked))
                    {
                        item.Visibility = Visibility.Visible;
                    }
                    else
                    {
                        item.Visibility = Visibility.Collapsed;
                    }
                }
            }
            
        }

        private bool IsTreeItemVisible(SupportConceptGoalTreeItem goal, string searchtext, bool onlyChecked)
        {
            
            if (onlyChecked && !goal.IsChecked && goal.GoalType != ValueListEntryType.SupportConceptIndividualGoalType && goal.GoalType != ValueListEntryType.SupportConceptIndividualGoalCategoryType)
            {
                return false;
            }
            if (!String.IsNullOrEmpty(searchtext) && (String.IsNullOrEmpty(goal.DetailDescription) || !goal.DetailDescription.ToLower().Contains(searchtext.ToLower())))
            {
                return false;
            }

            return true;
        }

        private bool IsAtLeastOneChildVisible(BindingList<SupportConceptGoalTreeItem> children, string searchtext, bool onlyChecked)
        {
            
            foreach (var child in children)
            {
                bool visible = IsTreeItemVisible(child, searchtext, onlyChecked) || IsAtLeastOneChildVisible(child.Items, searchtext, onlyChecked);
                if (visible)
                {
                    return true;
                }
                
            }

            return false;
        }

        private void ChkShowSelectedGoals_OnChecked(object sender, RoutedEventArgs e)
        {
            FilterTreeItems();
        }

        private void ChkShowSelectedGoals_OnUnchecked(object sender, RoutedEventArgs e)
        {
            FilterTreeItems();
        }

        private void popupedit_costBearerContactPersonSearch_DeleteClick(object sender, RoutedEventArgs e)
        {
            var vm = tabcontrol_costbearers.SelectedItem as SupportConceptCostBearerRelVM;
            if (vm != null)
            {
                vm.CostBearerContactPerson = null;
            }
            
            
        }


        private void linkPdfExport_Click(object sender, RoutedEventArgs e)
        {
            var link = sender as Hyperlink;
            if (link != null)
            {
                var rating = link.Tag as RatingVM;

                e.Handled = true;

                if (rating.IsNew)
                {
                    MessageBox.Show("Dieser Datensatz muss zuerst gespeichert werden, bevor Sie ihn drucken können.", "Erst speichern bitte", MessageBoxButton.OK, MessageBoxImage.Information);
                    return;
                }
                if (rating != null && rating.DataContract.RatingOid.HasValue)
                {
                    var url = BeWoApp.SiteOfOrigin + "/ReportView.aspx"
                     + "?scOid=" + (this.ViewModel.DataContract.SupportConceptOid ?? 0)
                     + "&rOid=" + (rating.DataContract.RatingOid ?? 0)
                     + "&type=" + Utils.EnumName(ReportTypes.RatingReport);
                    url = BeWoWpfUtils.GetHTMLEncodedURL(url);

                    link.NavigateUri = new Uri(url);
                    BeWoUtils.NavigateToReportUri((sender as System.Windows.Documents.Hyperlink).NavigateUri.ToString(), Translator.Translate("Bewertung"));
                }
            }

        }

        private void ButtenImport_Click(object sender, RoutedEventArgs e)
        {
            var ctrl = new HilfeplanImportView(this.ViewModel.DataContract.SupportConceptOid);

            var beWoWindow = BeWoWindowBuilder.GetBeWoWindow(Translator.Translate("Importiere Hilfeplan"), ctrl, this.Height, this.Width);

            ctrl.CloseButtonClicked += () => beWoWindow.Close();

            beWoWindow.ShowDialog();

            if (ctrl.ImportedSupportConcept != null)
            {
                AddMissingGoals(ctrl.ImportedSupportConcept.Goals);
                FilterTreeItems();
            }

        }

        private void AddMissingGoals(List<ValueListEntryDC> goals)
        {
            foreach (var g in goals)
            {
                if (!g.ValueListEntryOid.HasValue)
                {
                    if (g.Parent != null)
                    {
                        //Prüfen, ob bereits vorhanden
                        var existingItem = FindGoalTreeItem(ViewModel.CombinedGoalTree, g.TypeDescription);
                        if (existingItem == null)
                        {
                            var parent = FindGoalTreeItem(ViewModel.CombinedGoalTree, g.Parent.TypeDescription);
                            if (parent == null && g.Parent.ValueListEntryOid.HasValue)
                            {
                                //Bereich ist noch nicht vorhanden wurde aber serverseitig schon angelegt. Also hinzufügen
                                parent = ViewModel.AddTreeItem(null, g.Parent.Type, g.Parent.TypeDescription, g.Parent.Abbreviation, "", null);
                                parent.GoalEntryVM.DataContract.ValueListEntryOid = g.Parent.ValueListEntryOid;
                                parent.GoalEntryVM.IsNew = false; // Sonst wird das Ziel noch mal gespeichert
                                //parent = FindGoalTreeItem(ViewModel.CombinedGoalTree, g.Parent.TypeDescription);
                            }
                            if (parent != null)
                            {
                                ViewModel.AddTreeItem(parent, g.Type, g.TypeDescription, g.Abbreviation, "", null);
                            }
                        }
                    }
                    
                }
            }
        }

        private SupportConceptGoalTreeItem FindGoalTreeItem(IList<SupportConceptGoalTreeItem> treeItems, String ziel)
        {
            if (treeItems != null)
            {
                foreach (var item in treeItems)
                {
                    if (item.GoalEntryVM.Description == ziel)
                    {
                        return item;
                    }

                    var p = FindGoalTreeItem(item.Items, ziel);
                    if (p != null)
                    {
                        return p;
                    }
                }
            }
            return null;
        }

        private void SortComboBox_Loaded(object sender, RoutedEventArgs e)
        {
            var cb = sender as ComboBox;

            if (cb != null)
            {
                //InitSortCombo(cb);
            }
        }

        private void SortComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var cb = sender as ComboBox;

            //if (cb != null)
            //{

                var cb2 = e.OriginalSource as DependencyObject;
                var sp2 = VisualTreeHelper.GetParent(cb2);
                
                
                //Finde ListView

                var sp = cb.Parent as StackPanel;

            if (sp2 == sp)
            {
                int test = 0;
            }
                var g = sp.Parent as Grid;
                var gb = g.Parent as GroupBox;
                var lv = gb.Content as ListView;

                //lv.ItemsSource = null;
                var c2s = cb.Tag as SupportConceptCostBearerRelVM;

                //var list = lv.ItemsSource as BindingList<SupportConceptApprovalPeriodVM>;
                //lv.ItemsSource = null;
                
                //if (cb.SelectedIndex == 0)
                //{
                 //   list.Sort((a, b) => a.StartDate.HasValue ? a.StartDate.Value.CompareTo(b.StartDate) : 0);
                //}
                //else
                //{
                //    list.Sort((a, b) => b.StartDate.HasValue ? b.StartDate.Value.CompareTo(a.StartDate) : 0);
                //}

            //list.Sort((a, b) => b.StartDate.HasValue ? b.StartDate.Value.CompareTo(a.StartDate) : 0);
            //lv.Items.SortDescriptions.Add(new SortDescription { PropertyName = "StartDate", Direction = ListSortDirection.Descending });
            //lv.ItemsSource = c2s.ApprovalPeriodList.VMList;
            //lv.ItemsSource.RaisePropertyChanged
                //BeWoApp.AppSettings.LastBewilligungSortOrder = cb.SelectedIndex;
                BeWoApp.SaveAppSettings();
            //}
        }
    }

    public class ValueListEntryTypeToColorConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            var type = (ValueListEntryType)value;

            if (type.Equals(ValueListEntryType.SupportConceptIndividualGoalCategoryType) || type.Equals(ValueListEntryType.SupportConceptIndividualGoalType))
            {
                return new SolidColorBrush(Colors.SteelBlue);
            }

            return new SolidColorBrush(Colors.Black);
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

    
}