using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Media.Imaging;

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

using BeWo.Controls;
using BeWo.ServiceProxy;
using BeWo.View;
using BeWo.View.Controls;
using BeWo.View.Detail;
using BeWo.View.Detail.Accounting;
using BeWo.View.Detail.Report;
using BeWo.View.Master;
using BeWo.View.Navigation;
using BeWo.View.Report.Auslastung;
using BeWo.View.Report.FLSReport;
using BeWo.View.Search;
using BeWo.ViewModel;

using DevExpress.Xpf.Core;
using DevExpress.Xpf.Core.Native;
using DevExpress.Xpf.Grid;
using DevExpress.XtraReports.UI;
using DevExpress.Xpf.Printing;
using Brushes = System.Windows.Media.Brushes;
using Image = System.Windows.Controls.Image;
using MessageBox = System.Windows.MessageBox;
using Panel = System.Windows.Controls.Panel;
using System.Windows.Media;
using System.Windows.Threading;
using BeWo.Core.Service;
using BeWo.ownChat;
using BeWo.PasswortSecurity;
using BeWo.Scheduler.Utils;
using BeWo.ViewModel.ListViewModel;
using DevExpress.Xpf.Bars;
using DevExpress.Xpf.DocumentViewer;
using DevExpress.Xpf.Printing.PreviewControl.Bars;
using DevExpress.XtraScheduler;
using RestSharp;
using Control = System.Windows.Controls.Control;
using Utils = BS.Shared.Core.Utils;
using Brush = System.Windows.Media.Brush;
using BeWo.View.Detail.Zeiterfassung;
using DevExpress.Xpf.Scheduling;
using CommandBarStyle = DevExpress.Xpf.DocumentViewer.CommandBarStyle;
using ImageSource = System.Windows.Media.ImageSource;
using BS.Shared.Translation;
using BeWo.View.Windows;

namespace BeWo.Core
{
    public static class BeWoUtils
    {
        public static ModalViewWindow CurrentModalViewWindow { get; set; }

        private static readonly List<ModalViewWindow> _ModalViewWindowsToUpdate = new List<ModalViewWindow>();

        public static Dictionary<string, string> ParseQuery(string query)
        {
            try
            {
                if (query.IndexOf('?') >= 0)
                {
                    query = query.Split('?')[1];

                    var valueArray = Regex.Split(query, @"[\&]{0,1}[A-Za-z0-9]+[\=]{1}");
                    var paramArray = Regex.Split(query, @"[\=][A-Za-z0-9;]+");

                    valueArray = valueArray.Where(t => !string.IsNullOrWhiteSpace(t)).ToArray();
                    paramArray = paramArray.Where(t => !string.IsNullOrWhiteSpace(t)).ToArray();

                    var queryDictionary = new Dictionary<string, string>();

                    int ixg = 0;
                    foreach (var item in paramArray)
                    {
                        queryDictionary.Add(item.Contains("&") ? Regex.Split(item, @"[\?]|[\&]")[1] : item,
                                            valueArray[ixg]);
                        ixg++;
                        if (ixg >= valueArray.Length)
                            break;
                    }

                    return queryDictionary;
                }
                return new Dictionary<string, string>();
            }
            catch (Exception ex)
            {
                throw new Exception(String.Format("Error while parsing query '{0}'\n{1}", query, ex.Message), ex);
            }
        }

		public static void NavigateToReportUri(string navigateUriString, string title)
		{
            NavigateToReportUri(navigateUriString, title, null);
		}

        public static void NavigateToReportUri(string navigateUriString, string title, Action callback)
        {
            NavigateToReportUriWithDocumentPreviewControl(navigateUriString, title, null, callback);
        }

        public static void NavigateToReportUriWithDocumentPreviewControl(string navigateUriString, string title, DocumentPreviewControl dp, Action callback)
        {
            List<ReportTemplateDC> reportTemplates = null;
            if (!navigateUriString.Contains("&template="))
            {
                reportTemplates = ServiceFacade.DoOperationsServiceSync(x => x.GetReportTemplates(navigateUriString));
            }
            

            if (reportTemplates?.Count > 1)
            {
                var control = new ListboxSelectControl(reportTemplates.Cast<object>().ToList());

                var beWoWindow = new BeWoWindow
                {
                    Height = 200,
                    Width = 500,
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                    GroupBoxContent = control,
                    Owner = BeWoApp.CurrentBeWo.MainWindow,
                    rootGroupBox = { Header = "Bericht auswählen" }
                };

                control.CancelButtonClicked += () => beWoWindow.Close();
                control.SelectButtonClicked += () =>
                {
                    if (control.SelectedItem == null) return;

                    beWoWindow.Close();

                    var selectedTemplate = (ReportTemplateDC)control.SelectedItem;

                    var newUri = navigateUriString + "&template=" + (selectedTemplate.Oid.HasValue ? selectedTemplate.Oid.Value.ToString() : "-1");

                    //var start = navigateUriString.IndexOf("type=");
                    //var end = navigateUriString.IndexOf('&', start);

                    //if (end == -1) end = navigateUriString.Length - 1;

                    //var typeString = navigateUriString.Substring(start, end - start + 1);


                    //var newUri = navigateUriString.Replace(typeString, "template=" + (selectedTemplate.Oid.HasValue ? selectedTemplate.Oid.Value.ToString() : "-1"));

                    BeWoApp.MainControl.StartWaiting();

                    StartGetReportStreamAsync(GetReportStreamForWPFControl, newUri, ms => BeWoApp.MainControl.Dispatch(delegate
                    {
                        if (callback != null)
                        {
                            callback();
                        }
                        ShowReportWindow(ms, title, dp);
                    }));
                };

                beWoWindow.ShowDialog();
            }
            else
            {
                BeWoApp.MainControl.StartWaiting();

                StartGetReportStreamAsync(GetReportStreamForWPFControl, navigateUriString, ms => BeWoApp.MainControl.Dispatch(delegate
                {
                    if (callback != null)
                    {
                        callback();
                    }
                    ShowReportWindow(ms, title, dp);
                }));
            }
        }

	    public static void CustomizeReportPreviewToolBar(object s, RoutedEventArgs e)
	    {
			var cont = LayoutHelper.FindElementByType(s as FrameworkElement, typeof(BarContainerControl)) as BarContainerControl;

		    if(cont != null)
		    {
			    var toolbar = cont.Bars.First() as ToolBarControl;

			    foreach(var item in toolbar.Items)
			    {
				    if(item.GetType() == typeof(OpenDocumentBarItem) ||
				       item.GetType() == typeof(DocumentMapBarCheckItem) ||
				       item.GetType() == typeof(WatermarkBarItem) ||
				       item.GetType() == typeof(ScaleBarItem) ||
				       item.GetType() == typeof(PrintDirectBarItem) ||
				       item.GetType() == typeof(PageSetupBarItem) ||
				       item.GetType() == typeof(SaveBarItem) ||
				       item.GetType() == typeof(SendSplitItem) ||
				       item.GetType() == typeof(ParametersBarCheckItem) ||
				       item.GetType() == typeof(ThumbnailsBarCheckItem) ||
				       item.GetType() == typeof(EditingFieldsBarCheckItem))
				    {
					    item.SetPropertyValue("IsVisible", false);
				    }

				    if(item.GetType() == typeof(ExportSplitItem))
				    {
					    var exportSplitItem = item as ExportSplitItem;
					    var popupMenu = (PopupMenu) exportSplitItem.PopupControl;
					    foreach(var link in popupMenu.Items)
					    {
						    var bbi = (BarButtonItem) link;

						    switch(bbi.BarItemName)
						    {
							    case "bExportMht":
								    bbi.IsVisible = false;
								    break;
							    case "bExportCsv":
								    bbi.IsVisible = false;
								    break;
							    case "bExportTxt":
								    bbi.IsVisible = false;
								    break;
						    }
					    }
				    }
			    }
		    }
		}

		public static void StartGetReportStreamAsync(Func<string, MemoryStream> func, string param, Action<MemoryStream> callback)
		{
			func.BeginInvoke(param,
				cb =>
					{
						try
						{
							var result = func.EndInvoke(cb);
							if (callback != null)
							{
								callback(result);
							}
						}
						catch (Exception e)
						{
							BeWoApp.ShowErrorMessage(e);
							BeWoApp.MainControl.EndWaiting();
						}
					},
				null);
		}

	    public static MemoryStream GetReportStreamForWPFControl(string navigateUriString)
        {
			var webClient = new BeWoWebClient();
		    
            var refreshedUriString = RefreshNavigateUriString(navigateUriString);
            var data = webClient.DownloadData(refreshedUriString);

            return new MemoryStream(data);
        }

        public static string RemoveAuthenticationInfoFromUri(string navigateUri)
        {
            var regex = new Regex(@"[\&|\?]?token\=[A-Za-z0-9]+|[\&|\?]?tenant\=[A-Za-z0-9]+|[\&|\?]?username\=[A-Za-z0-9.]+");
            var splittedUri = regex.Split(navigateUri.Split('?')[1]);
            var cleanedSplittedUri = splittedUri.Where(t => !string.IsNullOrWhiteSpace(t)).ToArray();
            var uriValues = cleanedSplittedUri.Aggregate(string.Empty, (current, item) => current + item);

            return navigateUri.Split('?')[0] + "?" + uriValues;
        }

        public static string RefreshNavigateUriString(string navigateUri)
        {
            if (navigateUri.Contains("tenant"))
                navigateUri = RemoveAuthenticationInfoFromUri(navigateUri);

            var tempToken = string.Empty;

            ServiceFacade.DoDownloadServiceSync(s => tempToken = s.CreateTemporaryToken(navigateUri, false));

            var addChar = (navigateUri.Contains("?")) ? "&" : "?";

            var finalUri = string.Format("{0}{1}token={2}", navigateUri, addChar, tempToken);

            return finalUri;
        }

        public static bool CheckPopupEditClickableSpace(PopUpEdit popupedit, MouseButtonEventArgs e)
        {
            var buttonWidth = 22d;
            var pos = e.GetPosition(popupedit);

            if (popupedit.NewButtonVisibility == Visibility.Visible)
                buttonWidth += 22;

            if (popupedit.DeleteButtonVisibility == Visibility.Visible)
                buttonWidth += 22;

            return !(pos.X > popupedit.ActualWidth - buttonWidth);
        }

        public static void UpdateSearchViewObjectList<T, U>(T searchView, U updatedDC)
            where T : GenericSearchView<U>
            where U : class, IDataContract, IFilterableDC
        {
            var newSearchObjectList = new List<U>();

            if (typeof (U) == typeof (CompactSupportConceptDC))
            {
                var uSC = updatedDC as CompactSupportConceptDC;

                newSearchObjectList = searchView.ObjectList;

                if (newSearchObjectList.Contains(updatedDC))
                {
                    newSearchObjectList[newSearchObjectList.IndexOf(updatedDC)] = updatedDC;
                }

                foreach (var oldDC in newSearchObjectList.Select(item => item as CompactSupportConceptDC).Where(oldDC => oldDC.Customer.Equals(uSC.Customer)))
                {
                    oldDC.Customer = uSC.Customer;
                }
            }
            else
            {
                foreach (var oldDC in searchView.ObjectList.Where(oldDC => !newSearchObjectList.Contains(oldDC)))
                {
                    newSearchObjectList.Add(updatedDC.Equals(oldDC) ? updatedDC : oldDC);
                }
            }

            searchView.ObjectList = null;
            searchView.ObjectList = newSearchObjectList;
        }

        public static void OpenModalViewWindow<T, U, V>(
            T viewModel, 
            V ownerView,
            Action applyChanges, 
            EventHandler<EventArgs<OrganisationVM>> organisationSavedOrUpdated = null, 
            EventHandler<EventArgs<PersonVM>> personSavedOrUpdated = null, bool allowSaveIfParentDirty = false)
            where T : AbstractDCMapperVM<U>
            where U : IDataContract, new()
            where V : BeWoView
        {
            var tType = typeof(T);
            var view = new BeWoView();

            if (tType == typeof(EmployeeVM))
            {
                view = new EmployeeView(viewModel as EmployeeVM) { ParentView = ownerView, MinWidth = 800, IsInWindow = true };
            }
            else if (tType == typeof(WohnheimVM))
            {
                view = new WohnheimView(viewModel as WohnheimVM) { ParentView = ownerView, MinWidth = 800, IsInWindow = true };
            }
            else if (tType == typeof (OrganisationVM))
            {
                view = new OrganisationView(viewModel as OrganisationVM) { ParentView = ownerView, MinWidth = 800, IsInWindow = true };
                ((OrganisationView) view).OrganisationSavedOrUpdated += organisationSavedOrUpdated;
            }
            else if (tType == typeof (PersonVM))
            {
                view = new PersonView(viewModel as PersonVM) {ParentView = ownerView, MinWidth = 800, IsInWindow = true};
                ((PersonView) view).PersonSavedOrUpdated += personSavedOrUpdated;
            }
            else if (tType == typeof (TeamVM))
            {
                view = new TeamView(viewModel as TeamVM) {ParentView = ownerView, MinWidth = 800, IsInWindow = true};
            }
            else if(tType==typeof(CustomerVM))
            {
                view = new CustomerView(viewModel as CustomerVM) { ParentView = ownerView, MinWidth = 800, IsInWindow = true };
            }
            else if(tType==typeof(SupportConceptVM))
            {
                view = new SupportConceptView(viewModel as SupportConceptVM) { ParentView = ownerView, MinWidth = 800, IsInWindow = true };
            }
            else
            {
                return;
            }

            view.ModalEditViewUpdateCallback = applyChanges;

            CurrentModalViewWindow = new ModalViewWindow(view, ownerView, allowSaveIfParentDirty)
            {
                Title = viewModel.ToString()
            };

            BeWoApp.MainControl.OpenedModalViewWindows.Add(CurrentModalViewWindow);
            _ModalViewWindowsToUpdate.Add(CurrentModalViewWindow);

            foreach (var window in BeWoApp.MainControl.OpenedModalViewWindows.Where(window => !BeWoApp.MainControl.OpenedModalViewWindows.Last().Equals(window)))
            {
                ShowModalBackground(window.RootGrid);
            }

            CurrentModalViewWindow.Show();
        }

        public static void RemoveModalViewWindow()
        {
            if(BeWoApp.MainControl.OpenedModalViewWindows.Count > 1 && CurrentModalViewWindow != null)
            {
                var nextToLastWindowWithModalBackground = BeWoApp.MainControl.OpenedModalViewWindows.ElementAt(BeWoApp.MainControl.OpenedModalViewWindows.Count - 2);
                nextToLastWindowWithModalBackground.RootGrid.Children.RemoveAt(1);
            }

            BeWoApp.MainControl.OpenedModalViewWindows.Remove(CurrentModalViewWindow);

            CurrentModalViewWindow = BeWoApp.MainControl.OpenedModalViewWindows.Count > 0 ? BeWoApp.MainControl.OpenedModalViewWindows.ElementAt(BeWoApp.MainControl.OpenedModalViewWindows.Count - 1) : null;
        }

        public static bool CheckViewIsCalledFromWindow(BeWoView view)
        {
            return ((Grid) view.Parent).Parent.GetType() == typeof (Window);
        }

        private static void ShowModalBackground(Panel gridToBlock)
        {
            var detailViewBackGround = new Grid
            {
                IsHitTestVisible = true,
                Background = Brushes.White,
                Opacity = .5,
                Name = "DetailViewBackGround"
            };

            if (gridToBlock.Children.OfType<Grid>().Any(obj => obj.Name.Equals("DetailViewBackGround")))
            {
                return;
            }

            Grid.SetColumnSpan(detailViewBackGround, 3);
            Grid.SetRowSpan(detailViewBackGround, 3);

            gridToBlock.Children.Add(detailViewBackGround);

            Panel.SetZIndex(detailViewBackGround, int.MaxValue - 1);
        }

        public static void UpdateAllViews<T>(T updatedObject) where T : IFilterableDC
        {
            var activeView = BeWoApp.MainControl.ActiveView;
            UpdateView(activeView, updatedObject);

            if(BeWoApp.MainControl.OpenedModalViewWindows.Count <= 0)
            {
                return;
            }

            for(var i = _ModalViewWindowsToUpdate.Count - 1; i >= 0; i--)
            {
                UpdateView(_ModalViewWindowsToUpdate.ElementAt(i).DetailView, updatedObject);
                _ModalViewWindowsToUpdate.RemoveAt(i);
            }
        }

        private static void UpdateView<T>(BeWoView view, T updatedObject) where T : IFilterableDC
        {
            if(view.GetType() == typeof(EmployeeView))
            {
                var employeeView = view as EmployeeView;
                UpdateEmployeeView(employeeView, updatedObject);
            }
            else if(view.GetType() == typeof(WohnheimView))
            {
                var wohnheimView = view as WohnheimView;
                UpdateWohnheimView(wohnheimView, updatedObject);
            }
            else if(view.GetType() == typeof(CustomerView))
            {
                var customerView = view as CustomerView;
                UpdateCustomerView(customerView, updatedObject);
            }
            else if(view.GetType() == typeof(OrganisationView))
            {
                var organisationView = view as OrganisationView;
                UpdateOrganisationView(organisationView, updatedObject);
            }
            else if(view.GetType() == typeof(BookingView))
            {
                var bookingView = view as BookingView;
                UpdateBookingView(bookingView, updatedObject);
            }
            else if(view.GetType() == typeof(FinanceView))
            {
                var financeView = view as FinanceView;
                UpdateFinanceView(financeView, updatedObject);
            }
            else if(view.GetType() == typeof(SupportConceptView))
            {
                var supportConceptView = view as SupportConceptView;
                UpdateSupportConceptView(supportConceptView, updatedObject);
            }
            else if(view.GetType() == typeof(ServiceRecordView2))
            {
                var serviceRecordView = (ServiceRecordView2) view;
                UpdateServiceRecordView(serviceRecordView, updatedObject);
            }
            else if(view.GetType() == typeof(TeamView))
            {
                var teamView = (TeamView) view;
                UpdateTeamView(teamView, updatedObject);
            }
            else if(view.GetType() == typeof(UserView))
            {
                var userView = (UserView)view;
                UpdateUserView(userView);
            }
            else if(view.GetType() == typeof(ReportView))
            {
                var reportView = (ReportView) view;
                UpdateReportView(reportView, updatedObject);
            }
            else if(view.GetType() == typeof(PersonView))
            {
                var personView = view as PersonView;
                UpdatePersonView(personView, updatedObject);
            }
            else if(view.GetType() == typeof(AdditionalServiceView))
            {
                var additionalServiceView = view as AdditionalServiceView;
                UpdateAdditionalServiceView(additionalServiceView, updatedObject);
            }
        }
        
        private static void UpdateEmployeeView<T>(EmployeeView pEmployeeView, T pUpdatedObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactCustomerDC))
            {
                var updatedCustomer = new CompactCustomerDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedCustomer = s.GetCompactCustomerDC((pUpdatedObject as CompactCustomerDC).CustomerOid));

                foreach(var item in pEmployeeView.ViewModel.CustomerRelations.VMList.Where(item => item.Customer.Equals(updatedCustomer)))
                {
                    item.Customer = updatedCustomer;
                }

                var grid = pEmployeeView.rootGrid.FindResource("grid_CustomerRelation") as GridControl;

                foreach(var item in ((BindingList<CustomerEmployeeRelationVM>)grid.ItemsSource).Where(item => item.Customer.Equals(updatedCustomer)))
                {
                    item.Customer = null;
                    item.Customer = updatedCustomer;
                }

                grid.RefreshData();
            }

            if(typeof(T) == typeof(CompactEmployeeDC))
            {
                UpdateLoggedInEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid);
                pEmployeeView.ReloadViewModel();
            }
        }

        private static void UpdateWohnheimView<T>(WohnheimView pWohnheimView, T pUpdateObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactCustomerDC))
            {
                var updatedCustomer = new CompactCustomerDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedCustomer = s.GetCompactCustomerDC((pUpdateObject as CompactCustomerDC).CustomerOid));

                var grid = pWohnheimView.grid_CustomerRelation;

                foreach(var item in ((BindingList<WohnheimCustomerRelationVM>)grid.ItemsSource).Where(item => item.Customer.Equals(updatedCustomer)))
                {
                    item.Customer = null;
                    item.Customer = updatedCustomer;
                }

                grid.RefreshData();
            }

            if(typeof(T) == typeof(CompactEmployeeDC))
            {
                var updatedEmployee = new CompactEmployeeDC();

                ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdateObject as CompactEmployeeDC).EmployeeOid));

                var employeeRelationsGrid = pWohnheimView.grid_EmployeeRelation;

                foreach(var item in ((BindingList<WohnheimEmployeeRelationVM>)employeeRelationsGrid.ItemsSource).Where(item => item.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid)))
                {
                    item.Employee = null;
                    item.Employee = updatedEmployee;
                }

                UpdateLoggedInEmployee((pUpdateObject as CompactEmployeeDC).EmployeeOid);
            }
        }

        private static void UpdateCustomerView<T>(CustomerView pCustomerView, T pUpdateObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactEmployeeDC))
            {
                var updatedEmployee = new CompactEmployeeDC();

                if(!string.IsNullOrWhiteSpace(pCustomerView.popupedit_employeeRelations.Text))
                {
                    ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdateObject as CompactEmployeeDC).EmployeeOid));
                    pCustomerView.ViewModel.EmployeeRelations.NewVM.Employee = null;
                    pCustomerView.ViewModel.EmployeeRelations.NewVM.Employee = updatedEmployee;
                }
                else
                {
                    ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdateObject as CompactEmployeeDC).EmployeeOid));
                }

                var grid = (GridControl)pCustomerView.root.Resources["datagrid_EmployeeRelation"];

                if(grid.ItemsSource != null)
                {
                    foreach(var item in ((BindingList<CustomerEmployeeRelationVM>)grid.ItemsSource).Where(item => item.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid)))
                    {
                        item.Employee = null;
                        item.Employee = updatedEmployee;
                    }

                    grid.RefreshData();
                }

                UpdateSearchViewObjectList(pCustomerView.employeesearchview, updatedEmployee);
                UpdateLoggedInEmployee(updatedEmployee.EmployeeOid);
            }
            else if(typeof(T) == typeof(CompactPersonDC))
            {
                var updatedPerson = new CompactPersonDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedPerson = s.LoadPersonCompact((pUpdateObject as CompactPersonDC).PersonOid));

                if(!string.IsNullOrWhiteSpace(pCustomerView.popupedit_environmentPersonSearch.Text) && pCustomerView.popupedit_environmentPersonSearch.Text.Equals((pUpdateObject as CompactPersonDC).ToString()))
                {
                    pCustomerView.ViewModel.EnvironmentPersons.NewVM.Person = null;
                    pCustomerView.ViewModel.EnvironmentPersons.NewVM.Person = updatedPerson;
                }

                var grid = (GridControl) pCustomerView.root.Resources["grid_PersonRelations"];

                var vmList = pCustomerView.ViewModel.EnvironmentPersons.VMList;
                var relVMs = vmList.Where(w => w.Person.PersonOid.Equals(updatedPerson.PersonOid)).Where(w => !w.IsNew);
                var relPersonOids = relVMs.Select(s => s.CommitToDataContract().Customer2PersonOid.Value).ToList();

                var dataContracts = new List<CustomerPersonRelationDC>();
                ServiceFacade.DoCustomerServiceSync(s => dataContracts = s.LoadCustomerPersonRelationsByOid(relPersonOids));

                var test = new List<CustomerPersonRelationVM>();

                dataContracts.DoForEach(dfe => test.Add(new CustomerPersonRelationVM(dfe)));

                var vmMap = vmList.Where(w => relVMs.Contains(w)).ToDictionary(vmList.IndexOf, v => v.DataContract.Customer2PersonOid.Value);
                foreach(var item in vmMap)
                {
                    vmList[item.Key] = test.First(f => f.DataContract.Customer2PersonOid.Value.Equals(item.Value));
                }

                grid.RefreshData();

                UpdateSearchViewObjectList(pCustomerView.personsearchview, updatedPerson);
            }
            else if(typeof(T) == typeof(CompactOrganisationDC))
            {
                var organisationToUpdate = pUpdateObject as CompactOrganisationDC;
                var updatedOrganisation = new CompactOrganisationDC();
                var organisationRelationGrid = new GridControl();
                var costBearerRelationGrid = new GridControl();

                if(!(pUpdateObject is CompactOrganisationDC))
                {
                    return;
                }

                organisationRelationGrid = (GridControl) pCustomerView.root.Resources["grid_OrganisationRelations"];
                costBearerRelationGrid = (GridControl) pCustomerView.root.Resources["grid_costBearer"];

                ServiceFacade.DoCustomerServiceSync(s => updatedOrganisation = s.LoadOrganisationCompact(organisationToUpdate.OrganisationOid));

                if(!string.IsNullOrWhiteSpace(pCustomerView.popupedit_costBearer.Text) && pCustomerView.popupedit_costBearer.Text.Equals(organisationToUpdate.ToString()))
                {
                    pCustomerView.ViewModel.CostBearers.NewVM.CostBearer = null;
                    pCustomerView.ViewModel.CostBearers.NewVM.CostBearer = updatedOrganisation;
                    pCustomerView.popupedit_costBearer.Text = updatedOrganisation.ToString();
                }

                foreach(var item in pCustomerView.ViewModel.CostBearers.VMList.Where(item => item.CostBearer.Equals(updatedOrganisation)))
                {
                    item.CostBearer = null;
                    item.CostBearer = updatedOrganisation;
                }

                if(!string.IsNullOrWhiteSpace(pCustomerView.popupedit_environmentOrganisationSearch.Text) && pCustomerView.popupedit_environmentOrganisationSearch.Text.Equals(organisationToUpdate.ToString()))
                {
                    pCustomerView.ViewModel.EnvironmentOrganisations.NewVM.Organisation = null;
                    pCustomerView.ViewModel.EnvironmentOrganisations.NewVM.Organisation = updatedOrganisation;
                    pCustomerView.popupedit_environmentOrganisationSearch.Text = updatedOrganisation.ToString();
                }

                var vmList = pCustomerView.ViewModel.EnvironmentOrganisations.VMList;
                var relVMs = vmList.Where(w => w.Organisation.OrganisationOid.Equals(updatedOrganisation.OrganisationOid)).Where(w => !w.IsNew);
                var relOrganisationOids = relVMs.Select(s => s.CommitToDataContract().Customer2OrganisationOid.Value).ToList();
                var dataContracts = new List<CustomerOrganisationRelationDC>();
                var test = new List<CustomerOrganisationRelationVM>();

                ServiceFacade.DoCustomerServiceSync(s => dataContracts = s.LoadCustomerOrganisationRelationsByOid(relOrganisationOids));

                dataContracts.DoForEach(dfe => test.Add(new CustomerOrganisationRelationVM(dfe)));

                var vmMap = vmList.Where(w => relVMs.Contains(w)).ToDictionary(vmList.IndexOf, v => v.DataContract.Customer2OrganisationOid.Value);

                foreach(var item in vmMap)
                {
                    vmList[item.Key] = test.First(f => f.DataContract.Customer2OrganisationOid.Value.Equals(item.Value));
                }

                organisationRelationGrid.RefreshData();
                costBearerRelationGrid.RefreshData();

                UpdateSearchViewObjectList(pCustomerView.costbearersearchview, updatedOrganisation);
                UpdateSearchViewObjectList(pCustomerView.organisationsearchview, updatedOrganisation);
            }
            else if(typeof(T) == typeof(CompactTeamDC))
            {
                var teamToUpdate = pUpdateObject as CompactTeamDC;
                var updatedTeam = new CompactTeamDC();
                var grid = (GridControl) pCustomerView.root.Resources["datagrid_TeamRelation"];

                ServiceFacade.DoEmployeeServiceSync(s => updatedTeam = s.LoadCompactTeam(teamToUpdate.TeamOid));

                if(!string.IsNullOrWhiteSpace(pCustomerView.popupedit_teamRelations.Text) && pCustomerView.popupedit_teamRelations.Text.Equals(teamToUpdate.ToString()))
                {
                    ServiceFacade.DoEmployeeServiceSync(s => updatedTeam = s.LoadCompactTeam(teamToUpdate.TeamOid));
                    pCustomerView.ViewModel.TeamRelations.NewVM.Team = null;
                    pCustomerView.ViewModel.TeamRelations.NewVM.Team = updatedTeam;
                }

                foreach(var item in ((BindingList<CustomerTeamRelationVM>)grid.ItemsSource).Where(item => item.Team.Equals(updatedTeam)))
                {
                    item.Team = null;
                    item.Team = updatedTeam;
                }

                grid.RefreshData();
                UpdateSearchViewObjectList(pCustomerView.teamsearchview, updatedTeam);
            }
            else if(typeof(T) == typeof(CompactCustomerDC))
            {
                pCustomerView.ReloadViewModel();
            }
        }
        
        private static void UpdateOrganisationView<T>(OrganisationView pOrganisationView, T pUpdateObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactPersonDC))
            {
                var updatedPerson = new CompactPersonDC();
                var grid = (GridControl) pOrganisationView.gridroot.Resources["datagrid_PersonRelation"];

                ServiceFacade.DoCustomerServiceSync(s => updatedPerson = s.LoadPersonCompact((pUpdateObject as CompactPersonDC).PersonOid));

                var vmList = pOrganisationView.ViewModel.PersonRelations.VMList;
                var relVMs = vmList.Where(w => w.Person.PersonOid.Equals(updatedPerson.PersonOid)).Where(w => !w.IsNew);
                var relPersonOids = relVMs.Select(s => s.CommitToDataContract().Organisation2PersonOid.Value).ToList();
                var dataContracts = new List<OrganisationPersonRelationDC>();
                var organisationPersonRelationVMs = new List<OrganisationPersonRelationVM>();

                ServiceFacade.DoOperationsServiceSync(s => dataContracts = s.LoadOrganisationPersonRelationsByOid(relPersonOids));

                dataContracts.DoForEach(dfe => organisationPersonRelationVMs.Add(new OrganisationPersonRelationVM(dfe)));

                var vmMap = vmList.Where(w => relVMs.Contains(w)).ToDictionary(vmList.IndexOf, v => v.DataContract.Organisation2PersonOid.Value);
                foreach(var item in vmMap)
                {
                    vmList[item.Key] = organisationPersonRelationVMs.First(f => f.DataContract.Organisation2PersonOid.Value.Equals(item.Value));
                }

                grid.RefreshData();
            }
            else if(typeof(T) == typeof(CompactOrganisationDC))
            {
                pOrganisationView.ReloadViewModel();
            }
        }

        private static void UpdateBookingView<T>(BookingView pBookingView, T pUpdateObject) where T : IFilterableDC
        {
            if(typeof(T) != typeof(CompactEmployeeDC))
            {
                return;
            }

            var updatedEmployee = new CompactEmployeeDC();

            ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdateObject as CompactEmployeeDC).EmployeeOid));

            var sourceNew = pBookingView.combobox_newEmployee.ItemsSource as ObservableCollection<CompactEmployeeDC>;
            var sourceEdit = pBookingView.combobox_editEmployee.ItemsSource as ObservableCollection<CompactEmployeeDC>;

            var selectedNewIndex = pBookingView.combobox_newEmployee.SelectedIndex;
            var selectedEditIndex = pBookingView.combobox_editEmployee.SelectedIndex;

            foreach(var item in pBookingView.ViewModel.VMList.Where(item => item.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid)))
            {
                item.Employee = new CompactEmployeeDC();
                item.Employee = updatedEmployee;
            }

            for(var i = 0; i < sourceNew.Count; i++)
            {
                if(!sourceNew[i].EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                {
                    continue;
                }

                sourceNew[i] = new CompactEmployeeDC();
                sourceNew[i] = updatedEmployee;
            }

            for(var i = 0; i < sourceNew.Count; i++)
            {
                if(!sourceEdit[i].EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                {
                    continue;
                }

                sourceEdit[i] = new CompactEmployeeDC();
                sourceEdit[i] = updatedEmployee;
            }

            pBookingView.combobox_newEmployee.ItemsSource = sourceNew;
            pBookingView.combobox_editEmployee.ItemsSource = sourceEdit;

            pBookingView.combobox_newEmployee.SelectedIndex = selectedNewIndex;
            pBookingView.combobox_editEmployee.SelectedIndex = selectedEditIndex;

            UpdateLoggedInEmployee(updatedEmployee.EmployeeOid);
        }

        private static void UpdateFinanceView<T>(FinanceView pFinanceView, T pUpdateObject) where T : IFilterableDC
        {
            var settlementInvoiceView = pFinanceView.tabitem_settlementinvoice.Content as SettlementInvoiceView;
            var equityInvoiceView = pFinanceView.tabitem_equityinvoice.Content as EquityInvoiceView;
            var generalInvoiceView = pFinanceView.tabitem_otherinvoice.Content as GeneralInvoiceView;
            var serviceInvoiceView = pFinanceView.tabitem_collectiveinvoice.Content as ServiceInvoiceView;
            var accountingTransactionBookingView = pFinanceView.tabitem_financeBooking.Content as AccountingTransactionBookingView;

            if(typeof(T) == typeof(CompactCustomerDC))
            {
                var updatedCustomer = new CompactCustomerDC();
                ServiceFacade.DoCustomerServiceSync(s => updatedCustomer = s.GetCompactCustomerDC((pUpdateObject as CompactCustomerDC).CustomerOid));

                if(accountingTransactionBookingView != null)
                {
                    foreach(var item in accountingTransactionBookingView.ViewModel.AccountingTransactionVMList.Where(item => item.SupportConcept.Customer.Equals(updatedCustomer)))
                    {
                        item.SupportConcept.Customer = new CompactCustomerDC();
                        item.SupportConcept.Customer = updatedCustomer;
                    }

                    foreach(var item in accountingTransactionBookingView.FlatSupportConceptItems.Where(item => item.SupportConceptTreeNodeDC != null).Where(item => item.SupportConceptTreeNodeDC.Customer.Equals(updatedCustomer)))
                    {
                        item.SupportConceptTreeNodeDC.Customer = new CompactCustomerDC();
                        item.SupportConceptTreeNodeDC.Customer = updatedCustomer;
                    }

                    UpdateSingleSupportConceptSelectionControl(accountingTransactionBookingView.supportConceptSelectionControl, updatedCustomer);
                }

                if(settlementInvoiceView != null)
                {
                    if(settlementInvoiceView.SelectedSupportConcept != null)
                    {
                        if(settlementInvoiceView.SelectedSupportConcept.Customer.Equals((pUpdateObject as CompactCustomerDC)))
                        {
                            settlementInvoiceView.SelectedSupportConcept.Customer = new CompactCustomerDC();
                            settlementInvoiceView.SelectedSupportConcept.Customer = updatedCustomer;

                            settlementInvoiceView.popupedit_CostBeaerer.Text = $"{settlementInvoiceView.SelectedSupportConcept.Customer.LastName}, {settlementInvoiceView.SelectedSupportConcept.Customer.FirstName} {settlementInvoiceView.SelectedSupportConcept.Customer.DateOfBirthString}";
                        }

                        UpdateSearchViewObjectList(settlementInvoiceView.supportconceptsearchview, settlementInvoiceView.SelectedSupportConcept);
                    }
                    else
                    {
                        UpdateSearchViewObjectList(settlementInvoiceView.supportconceptsearchview, new CompactSupportConceptDC { Customer = updatedCustomer });
                    }
                }

                if(equityInvoiceView != null)
                {
                    if(equityInvoiceView.SelectedSupportConcept != null)
                    {
                        equityInvoiceView.SelectedSupportConcept.Customer = new CompactCustomerDC();
                        equityInvoiceView.SelectedSupportConcept.Customer = updatedCustomer;

                        equityInvoiceView.popupedit_CostBeaerer.Text = $"{equityInvoiceView.SelectedSupportConcept.Customer.LastName}, {equityInvoiceView.SelectedSupportConcept.Customer.FirstName} {equityInvoiceView.SelectedSupportConcept.Customer.DateOfBirthString}";

                        UpdateSearchViewObjectList(equityInvoiceView.supportconceptsearchview, equityInvoiceView.SelectedSupportConcept);
                    }
                    else
                    {
                        UpdateSearchViewObjectList(equityInvoiceView.supportconceptsearchview, new CompactSupportConceptDC { Customer = updatedCustomer });
                    }
                }

                if(serviceInvoiceView != null)
                {
                    if(serviceInvoiceView.ViewModel.SelectedSupportConcept != null)
                    {
                        if(serviceInvoiceView.ViewModel.SelectedSupportConcept.Customer.Equals((pUpdateObject as CompactCustomerDC)))
                        {
                            serviceInvoiceView.ViewModel.SelectedSupportConcept.Customer = new CompactCustomerDC();
                            serviceInvoiceView.ViewModel.SelectedSupportConcept.Customer = updatedCustomer;

                            serviceInvoiceView.popupedit_supportConcept.Text = $"{serviceInvoiceView.ViewModel.SelectedSupportConcept.Customer.LastName}, {serviceInvoiceView.ViewModel.SelectedSupportConcept.Customer.FirstName} {serviceInvoiceView.ViewModel.SelectedSupportConcept.Customer.DateOfBirthString}";

                            UpdateSearchViewObjectList(serviceInvoiceView.supportConcept_search, serviceInvoiceView.ViewModel.SelectedSupportConcept);
                        }
                    }
                    else
                    {
                        UpdateSearchViewObjectList(serviceInvoiceView.supportConcept_search, new CompactSupportConceptDC { Customer = updatedCustomer });
                    }
                }
            }
            else if(typeof(T) == typeof(CompactSupportConceptDC))
            {
                var updatedSupportConcept = new CompactSupportConceptDC();
                ServiceFacade.DoCustomerServiceSync(s => updatedSupportConcept = s.LoadCompactSupportConceptDC((pUpdateObject as CompactSupportConceptDC).SupportConceptOid, BeWoApp.LoggedOnEmployee.EmployeeOid));

                if(equityInvoiceView?.SelectedSupportConcept != null)
                {
                    equityInvoiceView.ReloadViewModel();
                    equityInvoiceView.popupedit_CostBeaerer.Text = $"{updatedSupportConcept.Customer.LastName}, {updatedSupportConcept.Customer.FirstName} {updatedSupportConcept.Customer.DateOfBirthString}";

                    UpdateSearchViewObjectList(equityInvoiceView.supportconceptsearchview, equityInvoiceView.SelectedSupportConcept);
                }

                if(settlementInvoiceView?.SelectedSupportConcept != null)
                {
                    settlementInvoiceView.ReloadViewModel();
                    settlementInvoiceView.popupedit_CostBeaerer.Text = $"{updatedSupportConcept.Customer.LastName}, {updatedSupportConcept.Customer.FirstName} {updatedSupportConcept.Customer.DateOfBirthString}";

                    UpdateSearchViewObjectList(settlementInvoiceView.supportconceptsearchview, settlementInvoiceView.SelectedSupportConcept);
                }

                if(serviceInvoiceView?.ViewModel.SelectedSupportConcept != null)
                {
                    if(serviceInvoiceView.ViewModel.SelectedSupportConcept.Equals(updatedSupportConcept))
                    {
                        serviceInvoiceView.ViewModel.SelectedSupportConcept = updatedSupportConcept;
                    }

                    UpdateSearchViewObjectList(serviceInvoiceView.supportConcept_search, updatedSupportConcept);
                }
            }
            else if(typeof(T) == typeof(CompactOrganisationDC))
            {
                var updatedOrganisation = new CompactOrganisationDC();
                ServiceFacade.DoCustomerServiceSync(s => updatedOrganisation = s.LoadOrganisationCompact((pUpdateObject as CompactOrganisationDC).OrganisationOid));

                if(generalInvoiceView != null)
                {
                    if(generalInvoiceView.SelectedOrganisation != null)
                    {
                        if(generalInvoiceView.SelectedOrganisation.Equals(updatedOrganisation))
                        {
                            generalInvoiceView.SelectedOrganisation = null;
                            generalInvoiceView.SelectedOrganisation = updatedOrganisation;
                        }

                        generalInvoiceView.popupedit_Recipient.Text = updatedOrganisation.ToString();
                    }

                    UpdateSearchViewObjectList(generalInvoiceView.recipientsearchview, updatedOrganisation);
                }

                if(serviceInvoiceView != null)
                {
                    if(serviceInvoiceView.ViewModel.SelectedCostBearer != null)
                    {
                        if(serviceInvoiceView.ViewModel.SelectedCostBearer.Equals(updatedOrganisation))
                        {
                            serviceInvoiceView.ViewModel.SelectedCostBearer = updatedOrganisation;
                        }
                    }

                    UpdateSearchViewObjectList(serviceInvoiceView.organisationSearchView, updatedOrganisation);
                }
            }
        }

        private static void UpdateSupportConceptView<T>(SupportConceptView pSupportConceptView, T pUpdatedObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactEmployeeDC))
            {
                var updatedEmployee = new CompactEmployeeDC();

                ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid));

                // TODO: an SchedulerAppointments anpassen! (angepasst)
                //for(var i = 0; i < pSupportConceptView.ViewModel.Tasks.NewVM.Employees.Count; i++)
                //{
                //    if(!pSupportConceptView.ViewModel.Tasks.NewVM.Employees[i].EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                //    {
                //        continue;
                //    }

                //    pSupportConceptView.ViewModel.Tasks.NewVM.Employees[i] = null;
                //    pSupportConceptView.ViewModel.Tasks.NewVM.Employees[i] = updatedEmployee;
                //}
                for(var i = 0; i < pSupportConceptView.ViewModel.Tasks.NewVM.EmployeeList.Count; i++)
                {
                    if(!pSupportConceptView.ViewModel.Tasks.NewVM.EmployeeList.ElementAt(i).Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                    {
                        continue;
                    }

                    pSupportConceptView.ViewModel.Tasks.NewVM.EmployeeList.ElementAt(i).Employee = null;
                    pSupportConceptView.ViewModel.Tasks.NewVM.EmployeeList.ElementAt(i).Employee = updatedEmployee;
                }

                foreach(var currentSC in pSupportConceptView.ViewModel.CostBearerRelations.VMList)
                {
                    foreach(var currentApprovalPeriodList in currentSC.ApprovalPeriodList.VMList)
                    {
                        if(currentApprovalPeriodList.SupportConceptApprovalEmployeeRelations.VMList.Any(a => a.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid)))
                        {
                            // Nur einmal in der Liste
                            var employeeContainingRel = currentApprovalPeriodList.SupportConceptApprovalEmployeeRelations.VMList.FirstOrDefault(f => f.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid));
                            if(employeeContainingRel != null)
                            {
                                employeeContainingRel.Employee = null;
                                employeeContainingRel.Employee = updatedEmployee;
                            }
                        }
                    }
                }

                if(pSupportConceptView.ViewModel.CostBearerRelations.VMList.Any(a => a.ApprovalPeriodList.VMList.Any(a2 => a2.SupportConceptApprovalEmployeeRelations.VMList.Any(a3 => a3.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid)))))
                {
                    var emp = pSupportConceptView.SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.VMList.FirstOrDefault(f => f.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid));
                    if(emp != null)
                    {
                        emp.Employee = null;
                        emp.Employee = updatedEmployee;
                        emp.EmployeeString = updatedEmployee.ToString();
                    }
                }

                if(pSupportConceptView.SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                {
                    pSupportConceptView.SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Employee = null;
                    pSupportConceptView.SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.Employee = updatedEmployee;
                    pSupportConceptView.SelectedApprovalPeriodVM.SupportConceptApprovalEmployeeRelations.NewVM.EmployeeString = updatedEmployee.ToString();
                }

                if(pSupportConceptView.ViewModel.Originator.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                {
                    pSupportConceptView.ViewModel.Originator = null;
                    pSupportConceptView.ViewModel.Originator = updatedEmployee;
                    pSupportConceptView.popupedit_employee.Text = updatedEmployee.ToString();
                }

                if(BeWoApp.LoggedOnUser.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                {
                    BeWoApp.LoggedOnUser.Employee = updatedEmployee;
                }

                pSupportConceptView.popupedit_employee.Text = updatedEmployee.ToString();
                UpdateLoggedInEmployee(updatedEmployee.EmployeeOid);
                UpdateSearchViewObjectList(pSupportConceptView.employeesearchview, updatedEmployee);

                foreach(var item in pSupportConceptView.ViewModel.Tasks.VMList)
                {
                    for(var i = 0; i < item.EmployeeList.Count; i++)
                    {
                        var prevDirty = item.IsDirty;
                        if(!item.EmployeeList[i].Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                        {
                            continue;
                        }

                        item.EmployeeList[i].Employee = updatedEmployee;

                        if(!prevDirty && item.IsDirty)
                        {
                            item.SetDirty(false);
                        }
                    }
                }

                pSupportConceptView.grid_tasks.RefreshData();
            }
            else if(typeof(T) == typeof(CompactPersonDC))
            {
                var updatedPerson = new CompactPersonDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedPerson = s.LoadPersonCompact((pUpdatedObject as CompactPersonDC).PersonOid));

                ((SupportConceptCostBearerRelVM) pSupportConceptView.tabcontrol_costbearers.SelectedItem).CostBearerContactPerson = null;
                ((SupportConceptCostBearerRelVM) pSupportConceptView.tabcontrol_costbearers.SelectedItem).CostBearerContactPerson = updatedPerson;
            }
            else if(typeof(T) == typeof(CompactCustomerDC))
            {
                var updatedCustomer = pSupportConceptView.ViewModel.Customer;

                ServiceFacade.DoCustomerServiceSync(s => updatedCustomer = s.GetCompactCustomerDC(pSupportConceptView.ViewModel.Customer.CustomerOid));

                pSupportConceptView.ViewModel.Customer = new CompactCustomerDC();
                pSupportConceptView.ViewModel.Customer = updatedCustomer;

                pSupportConceptView.popupedit_customer.Text = updatedCustomer.ToString();

                UpdateSearchViewObjectList(pSupportConceptView.customersearchview, updatedCustomer);
            }
        }

        private static void UpdateServiceRecordView<T>(ServiceRecordView2 pServiceRecordView, T pUpdatedObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactCustomerDC))
            {
                var updatedCustomer = new CompactCustomerDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedCustomer = s.GetCompactCustomerDC((pUpdatedObject as CompactCustomerDC).CustomerOid));

                foreach(var item in pServiceRecordView.ViewModel.VMList.Where(item => item.Customer.Equals(updatedCustomer)))
                {
                    item.Customer = new CompactCustomerDC();
                    item.Customer = updatedCustomer;
                }

                pServiceRecordView.multiSupportConceptControl.UpdateSupportConcepts(updatedCustomer);
                pServiceRecordView.multiSupportConceptControl.UpdateListBox();

                UpdateSingleSupportConceptSelectionControl(pServiceRecordView.supportConceptSelectionControl, updatedCustomer);
            }
            else if(typeof(T) == typeof(CompactEmployeeDC))
            {
                var updatedEmployee = new CompactEmployeeDC();
                ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid));

                UpdateSearchViewObjectList(pServiceRecordView.employeeSearchView, updatedEmployee);
                pServiceRecordView.popupedit_employee.Text = updatedEmployee.ToString();

                UpdateLoggedInEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid);

                for(var i = 0; i < pServiceRecordView.multiEmployeeControl.SelectedEmployees.Count; i++)
                {
                    if(!pServiceRecordView.multiEmployeeControl.SelectedEmployees[i].EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                    {
                        continue;
                    }

                    pServiceRecordView.multiEmployeeControl.SelectedEmployees[i] = new CompactEmployeeDC();
                    pServiceRecordView.multiEmployeeControl.SelectedEmployees[i] = updatedEmployee;
                }

                pServiceRecordView.multiEmployeeControl.UpdateListBox();
                UpdateSearchViewObjectList(pServiceRecordView.multiEmployeeControl.employeesearchview, updatedEmployee);

                //CB EINKOMMENTIEREN
                //if (pServiceRecordView.ViewModel.BedarfsMedViewModel.NewVM.Employee != null && pServiceRecordView.ViewModel.BedarfsMedViewModel.NewVM.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                //{
                //    pServiceRecordView.ViewModel.BedarfsMedViewModel.NewVM.Employee = updatedEmployee;
                //    pServiceRecordView.popupedit_employee_bedarfsmed.Text = updatedEmployee.ToString();
                //    UpdateSearchViewObjectList(pServiceRecordView.MedRecordEmployeeSearchView, updatedEmployee);
                //}

                //// TODO: Bedarfsmedikationen
                //UpdateSearchViewObjectList(pServiceRecordView.MedRecordEmployeeSearchView, updatedEmployee);

                // foreach (var item in ((BindingList<MedRecordVM>)pServiceRecordView.MedRecordGridControl.ItemsSource).Where(item => item.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid)))
                //{
                //    item.Employee = null;
                //    item.Employee = updatedEmployee;
                //}

                //pServiceRecordView.MedRecordGridControl.RefreshData();

                if(pServiceRecordView.ViewModel.CustomerNodes.Count <= 0 || pServiceRecordView.ViewModel.ServiceRecordsForSelectedCustomer == null)
                {
                    return;
                }

                foreach(var item in pServiceRecordView.ViewModel.ServiceRecordsForSelectedCustomer.Where(item => item.Employee.EmployeeOid.Equals(updatedEmployee.EmployeeOid)))
                {
                    item.Employee = null;
                    item.Employee = updatedEmployee;
                }

                pServiceRecordView.ViewModel.RefreshServiceRecordsForSelectedTreeNode(false);
            }
            else if(typeof(T) == typeof(CompactOrganisationDC))
            {
                var updatedOrganisation = new CompactOrganisationDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedOrganisation = s.LoadOrganisationCompact((pUpdatedObject as CompactOrganisationDC).OrganisationOid));

                foreach(var item in pServiceRecordView.ViewModel.VMList.Where(item => item.CostBearer.Equals(updatedOrganisation)))
                {
                    item.CostBearer = new CompactOrganisationDC();
                    item.CostBearer = updatedOrganisation;
                }
            }
        }

        private static void UpdateTeamView<T>(TeamView pTeamView, T pUpdatedObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactEmployeeDC))
            {
                var updatedEmployee = new CompactEmployeeDC();

                ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid));

                if(pTeamView.ViewModel.Leader.Equals(pUpdatedObject as CompactEmployeeDC))
                {
                    pTeamView.ViewModel.Leader = null;
                    pTeamView.ViewModel.Leader = updatedEmployee;
                }

                if(pTeamView.ViewModel.Member.Contains(updatedEmployee))
                {
                    var newMember = new ObservableSortCollection<CompactEmployeeDC>();
                    foreach(var item in pTeamView.ViewModel.Member)
                    {
                        newMember.Add(item.EmployeeOid.Equals(updatedEmployee.EmployeeOid) ? updatedEmployee : item);
                    }

                    pTeamView.ViewModel.Member = null;
                    pTeamView.ViewModel.Member = newMember;
                }

                if(pTeamView.ViewModel.Leader.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                {
                    pTeamView.ViewModel.Leader = null;
                    pTeamView.ViewModel.Leader = updatedEmployee;
                }

                UpdateSearchViewObjectList(pTeamView.employeesearchview, updatedEmployee);
                UpdateSearchViewObjectList(pTeamView.leaderSearchView, updatedEmployee);
                UpdateLoggedInEmployee(updatedEmployee.EmployeeOid);
            }
            else if(typeof(T) == typeof(CompactTeamDC))
            {
                pTeamView.ReloadViewModel();
            }
        }

        private static void UpdateUserView(UserView pUserView)
        {
            var updatedEmployee = new CompactEmployeeDC();

            ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee(pUserView.ViewModel.Employee.EmployeeOid));

            pUserView.ViewModel.Employee = null;
            pUserView.ViewModel.Employee = updatedEmployee;

            var myView = new BeWoView();
            BeWoApp.MainControl.Views.TryGetValue(UIContext.User, out myView);

            if(myView is UserNavigationView naviView)
            {
                if(naviView.ObjectList.Contains(updatedEmployee))
                {
                    var copiedList = naviView.ObjectList as List<IFilterableDC>;
                    copiedList[copiedList.IndexOf(updatedEmployee)] = new CompactEmployeeDC();
                    copiedList[copiedList.IndexOf(updatedEmployee)] = updatedEmployee;
                    naviView.ObjectList = copiedList;
                }

                if(naviView.RecentList.Contains(updatedEmployee))
                {
                    var copiedList = naviView.RecentList as List<IFilterableDC>;
                    copiedList[copiedList.IndexOf(updatedEmployee)] = new CompactEmployeeDC();
                    copiedList[copiedList.IndexOf(updatedEmployee)] = updatedEmployee;
                    naviView.RecentList = copiedList;
                }
            }

            UpdateSearchViewObjectList(pUserView.employeeSearchView, updatedEmployee);
            UpdateLoggedInEmployee(updatedEmployee.EmployeeOid);
        }

        private static void UpdateReportView<T>(ReportView pReportView, T pUpdatedObject) where T : IFilterableDC
        {
            pReportView.OpenViews.TryGetValue(pReportView.tabitem_maReport, out var aus);
            pReportView.OpenViews.TryGetValue(pReportView.tabitem_flsReport, out var fls);
            pReportView.OpenViews.TryGetValue(pReportView.tabitem_serviceOverview, out var serv);

            if(typeof(T) == typeof(CompactCustomerDC))
            {
                var updatedCustomer = new CompactCustomerDC();
                ServiceFacade.DoCustomerServiceSync(s => updatedCustomer = s.GetCompactCustomerDC((pUpdatedObject as CompactCustomerDC).CustomerOid));

                if(fls is FLSReportView fls2)
                {
                    if(fls2._SelectedCustomer != null)
                    {
                        if(fls2._LastSelectedCustomer != null)
                        {
                            if(fls2._LastSelectedCustomer.Equals(updatedCustomer))
                            {
                                fls2._LastSelectedCustomer = updatedCustomer;
                            }
                        }

                        fls2._SelectedCustomer = updatedCustomer;
                        fls2.popupedit_client.Text = updatedCustomer.ToString();
                    }

                    UpdateSearchViewObjectList(fls2.customerSearchView, updatedCustomer);
                }

                var serv2 = serv as ServicesReportView;
                if(serv2 != null)
                {
                    if(serv2.Customer != null)
                    {
                        serv2.Customer = updatedCustomer;
                        serv2.popupedit_customer.Text = updatedCustomer.ToString();
                    }

                    UpdateSearchViewObjectList(serv2.customersearchview, updatedCustomer);
                }
            }

            if(typeof(T) == typeof(CompactEmployeeDC))
            {
                var updatedEmployee = new CompactEmployeeDC();
                ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid));

                if(aus is AuslastungReportView aus2)
                {
                    if(aus2._SelectedEmployee != null)
                    {
                        if(aus2._SelectedEmployee != null)
                        {
                            if(aus2._SelectedEmployee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                            {
                                aus2._SelectedEmployee = updatedEmployee;
                            }
                        }

                        if(aus2._LastSelectedEmployee != null)
                        {
                            if(aus2._LastSelectedEmployee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                            {
                                aus2._LastSelectedEmployee = updatedEmployee;
                            }
                        }

                        if(aus2._SelectedEmployee != null)
                        {
                            aus2.popupedit_employee.Text = updatedEmployee.ToString();
                        }
                    }

                    UpdateSearchViewObjectList(aus2.employeesearchview, updatedEmployee);
                }

                if(fls is FLSReportView fls2)
                {
                    if(fls2._SelectedEmployee != null)
                    {
                        if(fls2._LastSelectedEmployee != null)
                        {
                            if(fls2._LastSelectedEmployee.EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                            {
                                fls2._LastSelectedEmployee = updatedEmployee;
                            }
                        }

                        fls2._SelectedEmployee = updatedEmployee;
                        fls2.popupedit_employee.Text = updatedEmployee.ToString();
                    }

                    UpdateSearchViewObjectList(fls2.employeeSearchView, updatedEmployee);
                }

                if(serv is ServicesReportView serv2)
                {
                    if(serv2.Employee != null)
                    {
                        serv2.Employee = updatedEmployee;
                        serv2.popupedit_employee.Text = updatedEmployee.ToString();
                    }

                    UpdateSearchViewObjectList(serv2.employeesearchview, updatedEmployee);
                }

                UpdateLoggedInEmployee(updatedEmployee.EmployeeOid);
            }

            if(typeof(T) == typeof(CompactOrganisationDC))
            {
                var updatedOrganisation = new CompactOrganisationDC();
                ServiceFacade.DoCustomerServiceSync(s => updatedOrganisation = s.LoadOrganisationCompact((pUpdatedObject as CompactOrganisationDC).OrganisationOid));

                if(serv is ServicesReportView serv2)
                {
                    if(serv2.Organisation != null)
                    {
                        serv2.Organisation = updatedOrganisation;
                        serv2.popupedit_costbearer.Text = updatedOrganisation.ToString();
                    }

                    UpdateSearchViewObjectList(serv2.organisationsearchview, updatedOrganisation);
                }
            }

            if(typeof(T) == typeof(CompactTeamDC))
            {
                var updatedTeam = new CompactTeamDC();
                ServiceFacade.DoEmployeeServiceSync(s => updatedTeam = s.LoadCompactTeam((pUpdatedObject as CompactTeamDC).TeamOid));

                if(aus is AuslastungReportView aus2)
                {
                    if(aus2._SelectedTeam != null)
                    {
                        if(aus2._SelectedTeam.Equals(updatedTeam))
                        {
                            aus2._SelectedTeam = updatedTeam;
                        }

                        if(aus2._LastSelectedTeam != null)
                        {
                            if(aus2._LastSelectedTeam.Equals(updatedTeam))
                            {
                                aus2._LastSelectedTeam = updatedTeam;
                            }
                        }

                        aus2.popupedit_team.Text = updatedTeam.ToString();
                    }

                    UpdateSearchViewObjectList(aus2.teamsearchview, updatedTeam);
                }
            }
        }

        private static void UpdatePersonView<T>(PersonView pPersonView, T pUpdatedObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactOrganisationDC))
            {
                var gridRelations = (GridControl)pPersonView.rootGrid.Resources["grid_Relations"];
                var updatedOrganisation = new CompactOrganisationDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedOrganisation = s.LoadOrganisationCompact((pUpdatedObject as CompactOrganisationDC).OrganisationOid));

                if(!string.IsNullOrWhiteSpace(pPersonView.popupedit_organisation.Text) && pPersonView.popupedit_organisation.Text.Equals((pUpdatedObject as CompactOrganisationDC).Name))
                {
                    pPersonView.popupedit_organisation.Text = updatedOrganisation.ToString();
                }

                foreach(var item in pPersonView.ViewModel.OrganisationRelations.VMList.Where(item => item.Organisation.OrganisationOid == updatedOrganisation.OrganisationOid))
                {
                    item.OrganisationString = updatedOrganisation.Name;
                }

                gridRelations.RefreshData();

                if(pPersonView.ViewModel.OrganisationRelations.NewVM?.Organisation != null)
                {
                    if(pPersonView.ViewModel.OrganisationRelations.NewVM.Organisation.OrganisationOid.Equals(updatedOrganisation.OrganisationOid))
                    {
                        pPersonView.ViewModel.OrganisationRelations.NewVM.OrganisationString = updatedOrganisation.Name;
                    }
                }

                UpdateSearchViewObjectList(pPersonView.organisationSearchView, updatedOrganisation);
            }
            else if(typeof(T) == typeof(CompactPersonDC))
            {
                pPersonView.ReloadViewModel();
            }
            else if(typeof(T) == typeof(CompactCustomerDC))
            {
                pPersonView.UpdateCustomerList();
            }
        }

        private static void UpdateAdditionalServiceView<T>(AdditionalServiceView pAdditionalServiceView, T pUpdatedObject) where T : IFilterableDC
        {
            if(typeof(T) == typeof(CompactEmployeeDC))
            {
                var updatedEmployee = new CompactEmployeeDC();
                ServiceFacade.DoEmployeeServiceSync(s => updatedEmployee = s.LoadCompactEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid));

                UpdateLoggedInEmployee((pUpdatedObject as CompactEmployeeDC).EmployeeOid);

                for(var i = 0; i < pAdditionalServiceView.MultiEmployeeControlAddServ.SelectedEmployees.Count; i++)
                {
                    if(!pAdditionalServiceView.MultiEmployeeControlAddServ.SelectedEmployees[i].EmployeeOid.Equals(updatedEmployee.EmployeeOid))
                    {
                        continue;
                    }

                    pAdditionalServiceView.MultiEmployeeControlAddServ.SelectedEmployees[i] = new CompactEmployeeDC();
                    pAdditionalServiceView.MultiEmployeeControlAddServ.SelectedEmployees[i] = updatedEmployee;
                }

                UpdateSearchViewObjectList(pAdditionalServiceView.MultiEmployeeControlAddServ.employeesearchview, updatedEmployee);
            }
            else if(typeof(T) == typeof(CompactCustomerDC))
            {
                var updatedCustomer = new CompactCustomerDC();

                ServiceFacade.DoCustomerServiceSync(s => updatedCustomer = s.GetCompactCustomerDC((pUpdatedObject as CompactCustomerDC).CustomerOid));

                pAdditionalServiceView.MultiAddServGroupOfPeopleSelectionControl.UpdateCustomers(updatedCustomer);

                foreach(var item in pAdditionalServiceView.AdditionalServiceBookings.VMList)
                {
                    var newCustomerList = item.CustomerOidDict.ToDictionary(element => element.Key.Equals(updatedCustomer.CustomerOid) ? updatedCustomer.CustomerOid : element.Key, element => element.Value);
                    item.CustomerOidDict = newCustomerList;
                }

                var containsUpdatedCustomer = false;

                foreach(var element in from item in pAdditionalServiceView.AdditionalServiceBookings.VMList from element in item.CustomerOidDict where element.Key.Equals(updatedCustomer.CustomerOid) select element)
                {
                    containsUpdatedCustomer = true;
                }

                if(!containsUpdatedCustomer)
                {
                    return;
                }

                pAdditionalServiceView.UpdateTeilnahmeGrid();
            }
        }


        private static void UpdateSingleSupportConceptSelectionControl(SingleSupportConceptSelectionControl control, CompactCustomerDC updatedCustomer)
        {
            if (control.SelectedItem.SupportConceptTreeNodeDC == null)
                return;

            var supConSelConSeletedItem = control.SelectedItem;
            
            if (supConSelConSeletedItem != null)
            {
                if (supConSelConSeletedItem.SupportConceptTreeNodeDC.Customer.Equals(updatedCustomer))
                    supConSelConSeletedItem.SupportConceptTreeNodeDC.Customer = updatedCustomer;
                if (supConSelConSeletedItem.SupportConceptTreeNodeDC.SupportConcept.Customer.Equals(updatedCustomer))
                    supConSelConSeletedItem.SupportConceptTreeNodeDC.SupportConcept.Customer = updatedCustomer;
            }

            var newList = control.SearchView.ObjectList;

            foreach (var concept in newList.Where(concept => concept.Customer.Equals(updatedCustomer)))
                concept.Customer = updatedCustomer;

            control.SearchView.ObjectList = newList;
            control.SetSelectedSupportConceptOid(control.SelectedItem.SupportConceptTreeNodeDC.SupportConcept.SupportConceptOid);
            control.UpdateControls();
            control.customerText.Text = updatedCustomer.ToString();
        }

        private static void UpdateLoggedInEmployee(long employeeOid)
        {
            if (employeeOid != BeWoApp.LoggedOnUser.Employee.EmployeeOid) 
                return;

            ServiceFacade.DoEmployeeServiceSync(s => BeWoApp.LoggedOnUser.Employee = s.LoadCompactEmployee(BeWoApp.LoggedOnUser.Employee.EmployeeOid));

            if (BeWoApp.MainControl.HomeButtonPanel == null) 
                return;
            
            //BeWoApp.MainControl.HomeView.txtHeader.Text = BeWoApp.LoggedOnUser.Employee.ToString();
        }

        public static void WriteExcelFile(string content, string path)
        {
            using (var uFileStream = File.Create(path))
                using (var uSw = new StreamWriter(uFileStream))
                    uSw.Write(content);

            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(path));
        }

        public static void WriteFile(string content, string path)
        {
            using (var uFileStream = File.Create(path))
            using (var uSw = new StreamWriter(uFileStream, Encoding.GetEncoding(1252)))
                uSw.Write(content);

            if (MessageBox.Show("Möchten Sie die Datei öffnen?", "Datei öffnen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
            {
                System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(path));
            }
        }

        //public static void Richloaded(object sender, RoutedEventArgs e)
        //{
        //    var richEditControl1 = (RichEditControl) sender;
        //    richEditControl1.ActiveViewType = RichEditViewType.Simple;
        //    richEditControl1.ShowBorder = false;
        //    richEditControl1.ShowHoverMenu = false;
        //    richEditControl1.CornerBoxVisibility = Visibility.Visible;
        //    richEditControl1.VerticalRulerVisibility = Visibility.Collapsed;
        //    richEditControl1.HorizontalRulerVisibility = Visibility.Collapsed;
        //    richEditControl1.Language = System.Windows.Markup.XmlLanguage.GetLanguage("de-DE");
        //}

        //public static void Popupmenu(object sender, PopupMenuShowingEventArgs e)
        //{
        //    foreach (var item in e.Menu.ItemLinks.Where(x => x.ActualIsVisible).Where(item => !(item is BarItemLinkSeparator)))
        //    {
        //        var btn = (BarButtonItemLink)item;

        //        if (btn.ActualContent.Equals("Lösche Zeile") ||
        //            btn.ActualContent.Equals("Lösche Spalte") ||
        //            btn.ActualContent.Equals("Lösche Zelle...") ||
        //            btn.ActualContent.Equals("Zellen verbinden") ||
        //            btn.ActualContent.Equals("Teile Zellen...") ||
        //            btn.ActualContent.Equals("Zellausrichtung") ||
        //            btn.ActualContent.Equals("AutoAnpassen") ||
        //            btn.ActualContent.Equals("Tabelleneigenschaften...") ||
        //            btn.ActualContent.Equals("Einzug erhöhen") ||
        //            btn.ActualContent.Equals("Einzug verringern") ||
        //            btn.ActualContent.Equals("Schriftart") ||
        //            btn.ActualContent.Equals("Absatz") ||
        //            btn.ActualContent.Equals("Nummerierun") ||
        //            btn.ActualContent.Equals("Lesezeichen...") ||
        //            btn.ActualContent.Equals("Hyperlink...") ||
        //            btn.ActualContent.Equals("Zeilenumbruch") ||
        //            btn.ActualContent.Equals("Eine Ebene nach vorne") ||
        //            btn.ActualContent.Equals("Eine Ebene nach hinten") ||
        //            btn.ActualContent.Equals("Layout"))
        //            item.IsVisible = false;
        //    }
        //}

        public static void OpenMailClient(string mailAddress, string subject = "", string body = "")
        {
            //mailAddress = "cb@ownsoft.de";
            //subject = "Betreff";
            
            var mailCmd = string.Format(@"mailto:{0}?subject={1}&body={2}", mailAddress, subject, body);

            System.Diagnostics.Process.Start(mailCmd);
        }
		
		public static bool ValidateServiceRecordVM(ServiceRecordVM vm, SupportConceptStatisticsDC statistics, FlatSupportConceptTreeNodeDC node, bool withoutClient, CompactEmployeeDC selectedEmployee, List<long> employeeOids, List<long> cb2ScOids, int groupIndex)
        {
            var lValid = true;

			if(vm.ServiceDescription == null)
			{
				MessageBox.Show("Bitte wählen Sie eine Leistung aus. Sollten keine Leistungen für die gewählte Kategorie verfügbar sein, müssen diese zunächst in der Verwaltung angelegt werden.", "Speichern", MessageBoxButton.OK, MessageBoxImage.Information);
				return false;
			}
			if(vm.GoalTree != null && vm.GoalTree.Count > 0 && groupIndex == 1/* && (cb2ScOids == null || cb2ScOids.Count < 2)*/)
			{
                //Nur für abrechenbare Leistungen
				if (vm.SelectedGoals.Count == 0)
				{
                    if (BeWoApp.AppSettings.IsServiceRecordGoalMandatory && vm.ServiceDescription.ProzentAbrechnung.HasValue && vm.ServiceDescription.ProzentAbrechnung >= 100 && vm.ServiceDescription.Category.IsBillable)
                    {
                        MessageBox.Show(Translator.Translate("Sie müssen mindestens ein Ziel auswählen, bevor Sie speichern können."), "Speichern", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                        return false;
                    }
                    else if (MessageBox.Show("Es wurde kein Ziel zugeordnet. Sind Sie sicher, dass Sie speichern möchten?", "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                    {
                        return false;
                    }
				}
                else
                {
                    if (BeWoApp.AppSettings.IsServiceRecordRatingMandatory)
                    {
                        foreach (var goal in vm.SelectedGoals)
                        {
                            if (!goal.RatingTypeOid.HasValue)
                            {
                                MessageBox.Show(String.Format("Das Ziel '{0}' wurde nicht bewertet.\nSpeichern nicht möglich.", goal.DisplayName), "Speichern", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                                return false;
                            }   
                        }   
                    }
                }
			}

			CompactSupportConceptDC scDc = null;
			CompactOrganisationDC cbDc = null;
			SupportConceptCostBearerRelDC relDc = null;

			if (node != null && node.SupportConceptTreeNodeDC != null)
			{
				scDc = node.SupportConceptTreeNodeDC.SupportConcept;
				cbDc = node.SupportConceptTreeNodeDC.CostBearer;
				relDc = node.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC;
			}

            var dc = vm.CommitToDataContract();
            dc.Employee = selectedEmployee ?? BeWoApp.LoggedOnUser.Employee;
            dc.SupportConcept = scDc;
			dc.CostBearer = cbDc;
            
            if (relDc != null)
            {
                dc.CostBearer2SupportConceptOid = relDc.CostBearer2SupportConceptOid;
            }
            else
            {
                dc.CostBearer2SupportConceptOid = null;
            }
            var validationResults = new List<ServiceRecordValidationResultDC>();

            var maxdays = BeWoApp.AppSettings.MaxDaysEditServiceRecordsAllowed;

            if (withoutClient && BeWoApp.AppSettings.MaxDaysEditServiceRecordsAllowed <= 0)
            {
                maxdays = -1;
            }

            if (BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowEditAfterMaxDaysInNextMonth))
            {
                maxdays = -1;
            }

			ServiceFacade.DoOperationsServiceSync(o => validationResults = o.ValidateServiceRecord(dc, statistics, maxdays, employeeOids, cb2ScOids));

            if (validationResults.Count > 0)
            {
                var exitLoop = false;
                
                foreach (var result in validationResults)
                {
                    switch (result.ResultType)
                    {
                        case ServiceRecordValidationResult.OutsideOfSupportConcept:
                            MessageBox.Show($"Das gewählte Datum '{vm.StartDate.ToShortDateString()}' liegt außerhalb des Zeitraums des gewählten Hilfeplans ({relDc.DateRangeString}).\nDas Speichern ist nicht möglich.", "Speichern", MessageBoxButton.OK, MessageBoxImage.Information);
                            lValid = false;
                            exitLoop = true;
                            break;
                        case ServiceRecordValidationResult.OutOfEditLimit:
                            MessageBox.Show($"Sie können keine neuen Leistungen für den {vm.StartDate.ToShortDateString()} dokumentieren, da bereits der {BeWoApp.AppSettings.MaxDaysEditServiceRecordsAllowed}. des nachfolgenden Monats überschritten ist.", "Speichern", MessageBoxButton.OK, MessageBoxImage.Information);
                            lValid = false;
                            exitLoop = true;
                            break;
						case ServiceRecordValidationResult.FristAbgelaufen:
							if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecordAllowEditAfterMindays))
							{
								if (BeWoApp.AppSettings.AnzTageZeiterfassErfolgt == 1)
								{
									MessageBox.Show($"Sie können keine neuen Leistungen für den {vm.StartDate.ToShortDateString()} dokumentieren, da die Zeiterfassung innerhalb von einem Tag erfolgen muss.", "Speichern", MessageBoxButton.OK, MessageBoxImage.Information);
								}
								else
								{
									MessageBox.Show($"Sie können keine neuen Leistungen für den {vm.StartDate.ToShortDateString()} dokumentieren, da die Zeiterfassung innerhalb von {BeWoApp.AppSettings.AnzTageZeiterfassErfolgt} Tagen erfolgen muss.", "Speichern", MessageBoxButton.OK, MessageBoxImage.Information);
								}

								lValid = false;
								exitLoop = true;
							}
							break;
                        case ServiceRecordValidationResult.Error:
                            MessageBox.Show("Beim Speichern ist ein Fehler aufgetreten.\nDas Speichern ist nicht möglich.", "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Error);
                            lValid = false;
                            exitLoop = true;
                            break;

                        case ServiceRecordValidationResult.ServiceRecordOverlapping:
							if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowCreateOverlappingFLS))
                            {
                                MessageBox.Show($"An dem gewählten Datum '{vm.StartDate.ToShortDateString()} {vm.StartDate.ToShortTimeString()}' existiert bereits ein Eintrag ({result.Message} bei " + BS.Shared.Translation.Translator.Translate("Klient/in") + " " + result.CustomerName + ") .\nSpeichern nicht möglich.", "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Information);
                                lValid = false;
                            }
							else if (MessageBox.Show($"An dem gewählten Datum '{vm.StartDate.ToShortDateString()} {vm.StartDate.ToShortTimeString()}' existiert bereits ein Eintrag ({result.Message} bei " + BS.Shared.Translation.Translator.Translate("Klient/in") + " " + result.CustomerName + ").\nMöchten Sie trotzdem speichern?", "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                            {
                                lValid = false;
                                exitLoop = true;
                            }
                            break;
                        case ServiceRecordValidationResult.EmployeeOverlapping:
		                   
                            if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowCreateOverlappingFLSForEmployee))
                            {
								MessageBox.Show($"An dem gewählten Datum '{vm.StartDate.ToShortDateString()} {vm.StartDate.ToShortTimeString()}' existiert bereits ein Eintrag von {result.EmployeeName}\n({result.Message}).\nSpeichern nicht möglich.", "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Information);
                                lValid = false;
                            }
							else if (MessageBox.Show($"An dem gewählten Datum '{vm.StartDate.ToShortDateString()} {vm.StartDate.ToShortTimeString()}' existiert bereits ein Eintrag von {result.EmployeeName}\n({result.Message}).\n\nMöchten Sie trotzdem speichern?", "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                            {
                                lValid = false;
                                exitLoop = true;
                            }
                            break;
                        case ServiceRecordValidationResult.ApprovedFLSOverspending:
                            var klient = "diesen Hilfeplan";
                            if (!string.IsNullOrEmpty(result.CustomerName))
                            {
                                klient = BS.Shared.Translation.Translator.Translate("Klient/in") + " " + result.CustomerName;
                            }

                            var msg = string.Format("Die für {2} genehmigten FLS ({0:N}) werden mit diesem Eintrag ({1:N}) überschritten.", result.ApprovedHours, result.HoursNew, klient);

                            if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecord_AllowCreateMoreFLSThanApproved))
                            {
								MessageBox.Show(msg + "\nSpeichern nicht möglich.", "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Information);
                                lValid = false;
                            }
							else if (MessageBox.Show(msg + "\nMöchten Sie trotzdem speichern?", "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
                            {
                                lValid = false;
                                exitLoop = true;
                            }
                            break;
                        case ServiceRecordValidationResult.SettlementInvoiceAlreadyExisting:
                            var klient2 = "diesen Hilfeplan";
                            if (!string.IsNullOrEmpty(result.CustomerName))
                            {
                                klient2 = BS.Shared.Translation.Translator.Translate("Klient/in") + " " + result.CustomerName;
                            }
                            if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.BookServiceRecordAfterSettlementInvoice))
                            {
                                MessageBox.Show($"Sie können den Eintrag nicht bearbeiten, da bereits eine Spitzabrechnung für {klient2} erstellt wurde.", "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Warning);
                                lValid = false;
                            }
							else if (MessageBox.Show($"Es existiert bereits eine Spitzabrechnung für {klient2}. Um diesen Eintrag zu berücksichtigen, muss eventuell eine neue Spitzabrechnung erstellt werden.\nMöchten Sie trotzdem speichern?", "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Warning).Equals(MessageBoxResult.No))
                            {
                                lValid = false;
                                exitLoop = true;
                            }
                            break;
						case ServiceRecordValidationResult.Custom:
                            if (result.Allow)
                            {
                                if (MessageBox.Show(result.Message, "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Warning).Equals(MessageBoxResult.No))
                                {
                                    lValid = false;
                                    exitLoop = true;
                                }
                            }
                            else
                            {
                                MessageBox.Show(result.Message, "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Error);
                                lValid = false;
                                exitLoop = true;
                            }
							break;
                        case ServiceRecordValidationResult.SignatureExists:
                            if(MessageBox.Show(result.Message, "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Warning).Equals(MessageBoxResult.No))
                            {
                                lValid = false;
                                exitLoop = true;
                            }
                            break;
                    }

                    if (exitLoop)
                    {
                        break;
                    }
                }
            }

            return lValid;
        }

        public static bool ValidateServiceRecordDeletion(ServiceRecordVM vm)
        {
            var lValid = true;

            
            var dc = vm.CommitToDataContract();
            var emp = BeWoApp.LoggedOnUser.Employee;
            

            var r = new List<ServiceRecordValidationResultDC>();

            
            ServiceFacade.DoOperationsServiceSync(o => r = o.ValidateServiceRecordDeletion(dc, emp.EmployeeOid));


            if (r.Count > 0)
            {
                var exitLoop = false;

                foreach (var result in r)
                {
                    switch (result.ResultType)
                    {
                        
                        case ServiceRecordValidationResult.Custom:
                            if (result.Allow)
                            {
                                if (MessageBox.Show(result.Message, "Löschen", MessageBoxButton.YesNo, MessageBoxImage.Warning).Equals(MessageBoxResult.No))
                                {
                                    lValid = false;
                                    exitLoop = true;
                                }
                            }
                            else
                            {
                                MessageBox.Show(result.Message, "Löschen nicht möglich", MessageBoxButton.OK, MessageBoxImage.Error);
                                lValid = false;
                                exitLoop = true;
                            }

                            break;
                    }

                    if (exitLoop) break;
                }
            }
            else
            {
                var msg = vm.GroupOid != null
                    ? "ACHTUNG, wenn Sie fortfahren, löschen Sie die gesamte Gruppenbuchung.\nWenn Sie nur einzelne " + BS.Shared.Translation.Translator.Translate("Klienten") + " aus der Gruppe entfernen möchten,\neditieren Sie die Gruppe und entfernen den Klienten aus der Liste aller Hilfepläne.\nSind Sie sicher, dass Sie den gesamten Gruppeneintrag löschen möchten?"
                    : "Sind Sie sicher, dass Sie den gewählten Eintrag löschen möchten?";

                if (MessageBox.Show(msg, "Eintrag löschen", MessageBoxButton.YesNo, MessageBoxImage.Warning) !=
                    MessageBoxResult.Yes)
                {
                    lValid = false;
                }
            }

            return lValid;
        }

        public static bool ValidateSupportConceptVM(SupportConceptVM vm)
        {
            var lValid = true;
            var dc = vm.CommitToDataContract();
            var r = ServiceFacade.DoOperationsServiceSync(o => o.ValidateSupportConcept(dc));

            if (r.Count > 0)
            {
                bool allowSave = true;

                StringBuilder msg = new StringBuilder();

                foreach (var result in r)
                {
                    if (msg.Length > 0)
                    {
                        msg.AppendLine();
                    }
                    msg.AppendLine(result.Message);

                    if (!result.AllowSave)
                    {
                        allowSave = false;
                    }
                }

                msg.AppendLine();

                if (allowSave)
                {
                    msg.Append(String.Format("Sind Sie sicher, dass Sie den Hilfeplan speichern möchten?", vm));

                    if (MessageBox.Show(msg.ToString(), "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Warning).Equals(MessageBoxResult.No))
                    {
                        lValid = false;
                    }
                }
                else
                {
                    msg.Append("Der Hilfeplan kann leider nicht gespeichert werden.");

                    MessageBox.Show(msg.ToString(), "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Error);
                    lValid = false;
                }

            }

            return lValid;
        }

        public static bool ValidateSupportConceptDeletion(CompactSupportConceptDC dc)
        {
            var lValid = true;

            var r = ServiceFacade.DoOperationsServiceSync(o => o.ValidateSupportConceptDeletion(dc.SupportConceptOid));

            bool allowSave = true;

            StringBuilder msg = new StringBuilder();

            foreach (var result in r)
            {
                if (msg.Length > 0)
                {
                    msg.AppendLine();
                }
                msg.AppendLine(result.Message);

                if (!result.AllowSave)
                {
                    allowSave = false;
                }
            }

            if (msg.Length > 0)
            {
                msg.AppendLine();
            }
            
            if (allowSave)
            {
                msg.Append(String.Format("Sind Sie sicher, dass Sie den gewählten Hilfeplan {0} {1} löschen möchten?", dc.CustomerName, dc));

                if (MessageBox.Show(msg.ToString(), "Löschen", MessageBoxButton.YesNo, MessageBoxImage.Exclamation).Equals(MessageBoxResult.No))
                {
                    lValid = false;
                }
            }
            else
            {
                msg.Append("Der gewählte Hilfeplan kann leider nicht gelöscht werden.");

                MessageBox.Show(msg.ToString(), "Löschen nicht möglich", MessageBoxButton.OK, MessageBoxImage.Error);
                lValid = false;
            }


            return lValid;
        }

        /// <summary>
        /// Erzeugt einen Report mit Hilfe des ReportServices und zeigt ihn in einem BeWoWindow
        /// </summary>
        /// <param name="title">Titel des Fensters</param>
        /// <param name="variablen">Dictionary mit Variablen für das ReportObject</param>
        /// <param name="reportType">Der Typ des Reports (z.B. KalenderMonatsformatReport)</param>
        public static void ShowReport(string title, Dictionary<string, object> variablen, ReportEnum reportType)
	    {
			switch (reportType)
			{
				case ReportEnum.KalenderMonatsReportEnum:
					var appointmentIds     = (List<long>)variablen["appointmentOidListe"];
					var selectedDays       = (List<DateTime>)variablen["datesList"];
					var employeeOid        = Convert.ToInt64(variablen["employeeOid"]);
					var serienTermine      = (List<SchedulerAppointmentDC>)variablen["serienTermine"];
					var mehrtaegigeTermine = (List<SchedulerAppointmentDC>)variablen["mehrtaegigeTermine"];
                    var nullableAbsenceTimeOids = (List<long?>) variablen["absenceTimeOids"] ?? new List<long?>();

                    var absenceTimeOids = new List<long>();
                    foreach(var absenceTimeOid in nullableAbsenceTimeOids)
                    {
                        if(absenceTimeOid.HasValue)
                        {
                            absenceTimeOids.AddIfNotIn(absenceTimeOid.Value);
                        }
                    }

					ServiceFacade.DoReportServiceAsync(strom => strom.CreateKalenderReportWithAbsenceTimes(appointmentIds, employeeOid, serienTermine, selectedDays, mehrtaegigeTermine, absenceTimeOids), ms => BeWoApp.MainControl.Dispatch(() => ShowReportWindow(ms, title)));

					break;
				case ReportEnum.KassenbuchReportEnum:
					var zeitraum      = (DateTime) variablen["zeitraum"];
                    var objectOid     = Convert.ToInt64(variablen["objectoid"]);
			        var objectTid     = (TableID) Enum.Parse(typeof (TableID), variablen["objecttid"].ToString());
                    var endzeitraum   = (DateTime)variablen["endzeitraum"]; 

			        var kasse = (BargeldkassenDC) variablen["bargeldkasse"];
			       
                    ServiceFacade.DoReportServiceAsync(strom => strom.CreateKassenbuchReportImZeitraum(zeitraum,endzeitraum, kasse, objectOid, objectTid), ms => BeWoApp.MainControl.Dispatch(() => ShowReportWindow(ms, title)));                        
					
					break;
				case ReportEnum.ZahlungsbelegEnum:
					var transaktion = (BargeldtransaktionDC) variablen["transaktion"];
                    var objectOid2  = Convert.ToInt64(variablen["objectoid"]);
                    var objectTid2  = (TableID) Enum.Parse(typeof(TableID), variablen["objecttid"].ToString());

					ServiceFacade.DoReportServiceAsync(strom => strom.CreateKassenbelegReport(transaktion, objectOid2, objectTid2), ms => BeWoApp.MainControl.Dispatch(() => ShowReportWindow(ms, title)));

					break;
			}
	    }

	    public static void ShowReportWindow(MemoryStream ms, string title, DocumentPreviewControl documentPreviewControl = null)
	    {
	        var report = new XtraReport();

			try
			{
				report.PrintingSystem.LoadDocument(ms);
			}
			catch(Exception)
			{
				var msg = Encoding.ASCII.GetString(ms.ToArray());

				MessageBox.Show("Beim Öffnen der Druckvorschau ist leider ein Fehler aufgetreten!\n\n" + msg, "Fehler", MessageBoxButton.OK, MessageBoxImage.Exclamation);
			}

			ms.Close();
			ms.Dispose();

			//report.DefaultPrinterSettingsUsing.UseLandscape = BeWoApp.AppSettings.PrinterSettingsUseLandscape;
			//report.DefaultPrinterSettingsUsing.UseMargins = BeWoApp.AppSettings.PrinterSettingsUseMargins;
			//report.DefaultPrinterSettingsUsing.UsePaperKind = BeWoApp.AppSettings.PrinterSettingsUsePaperKind;

			BeWoWindow window = null;

			if(documentPreviewControl == null)
			{
			    //ReportPrintTool tool = new ReportPrintTool(report);
			    //tool.ShowRibbonPreviewDialog(UserLookAndFeel.Default);
                documentPreviewControl = new DocumentPreviewControl {CommandBarStyle = CommandBarStyle.Bars};
				documentPreviewControl.Loaded += CustomizeReportPreviewToolBar;
			    documentPreviewControl.SnapsToDevicePixels = true;
                
				window = new BeWoWindow { GroupBoxContent = documentPreviewControl, Owner = BeWoApp.CurrentBeWo.MainWindow };

			    ThemeManager.SetTheme(window, Theme.Office2010Black);
            }
	        
            ThemeManager.SetTheme(documentPreviewControl, Theme.Office2010Black);

            documentPreviewControl.DocumentSource = report;

			if(window != null)
			{
				window.rootGroupBox.Header = string.IsNullOrEmpty(title) ? "Druckvorschau" : title;
				window.Title = "Druckvorschau";
				window.Show();
			}

			documentPreviewControl.Visibility = Visibility.Visible;

			BeWoApp.MainControl.EndWaiting();
	    }

        public static PasswortSecurityStrength CheckPasswordSecurity(string paswd)
        {
            PasswortSicherheit pwS = new PasswortSicherheit();

            return pwS.PasswortSecurityStaerke(paswd);
        }
        
        public static void ShowImageForm(ImageSource source)
        {
            try
            {
                using (var form = new Form())
                {
	                var imgg = new Image {Source = source};

	                var encoder = new BmpBitmapEncoder();

                    using (var ms = new MemoryStream())
                    {
                        encoder.Frames.Add(BitmapFrame.Create((BitmapSource)imgg.Source));
                        encoder.Save(ms);
                        
                        var img = System.Drawing.Image.FromStream(ms);

                        using (var imgbit = new Bitmap(img))
                        {
                            form.StartPosition = FormStartPosition.CenterScreen;
                            form.ClientSize = imgbit.Size;
                            form.FormBorderStyle = FormBorderStyle.Sizable;
                            form.ShowIcon = false;
                            using (var pb = new PictureBox())
                            {
                                pb.Dock = DockStyle.Fill;
                                pb.Image = imgbit;

                                pb.SizeMode = PictureBoxSizeMode.Zoom;

                                form.Controls.Add(pb);
                                form.ShowDialog();
                                
                            }
                        }
                    }
                }
            }
            catch (Exception edf)
            {
                MessageBox.Show("Unbekannter Fehler: " + edf.Message + "\n" + edf.StackTrace, "Fehler", MessageBoxButton.OK);
            }
        }

        public static void CreateZeiterfassung(DateTime start, DateTime end, List<CompactCustomerDC> customer, List<CompactEmployeeDC> employees, string notice, Appointment appointment, Action<List<ServiceRecordDC>> schedulerCallback)
        {
            ChatDokumentationsView newView;

            if(customer.Count == 0)
            {
                // Normale Buchung
                newView = new ChatDokumentationsView(notice, null, start, end, null, schedulerCallback, appointment);
            }
            else if(customer.Count == 1 && employees.Count < 2)
            {
                var compactKlient = ServiceFacade.DoCustomerServiceSync(s => s.GetCompactCustomerDC(customer[0].CustomerOid));

                // Normale Buchung
                
                newView = new ChatDokumentationsView(notice, compactKlient, start, end, employees.Count == 1 ? employees[0] : null, schedulerCallback, appointment);
            }
            else
            {
                if(employees.Count == 0)
                {
                    employees.Add(BeWoApp.CompactLoggedOnEmployee);
                }

                // Gruppenbuchungen
                newView = new ChatDokumentationsView(notice, start, end, customer, employees, schedulerCallback, appointment);
            }

            newView.ShowDialog();
        }
        public static void CreateAbsenceTime(DateTime start, DateTime end, List<CompactCustomerDC> customer, List<CompactEmployeeDC> employees, string notice, Appointment appointment, Action<List<AbsenceTimeDC>> schedulerCallback)
        {
            BeWo.Scheduling.View.AbsenceTimesCreationView newView = new Scheduling.View.AbsenceTimesCreationView(start, end, customer, employees, notice, appointment, schedulerCallback);

            newView.ShowDialog();
        }

        // Zeiterfassungseintrag aus dem neuen Kalendermodul erstellen
        public static void CreateZeiterfassung(DateTime start, DateTime end, List<CompactCustomerDC> customer, List<CompactEmployeeDC> employees, String notice, AppointmentItem appointment, Action schedulerCallback)
        {
            ChatDokumentationsView newView;

            if(customer.Count == 0)
            {
                // Normale Buchung
                newView = new ChatDokumentationsView(notice, null, null, start, end, schedulerCallback, appointment);
            }
            else if(customer.Count == 1 && employees.Count < 2)
            {
                var compactKlient = ServiceFacade.DoCustomerServiceSync(s => s.GetCompactCustomerDC(customer[0].CustomerOid));

                // Normale Buchung
                newView = new ChatDokumentationsView(notice, compactKlient, employees.Count == 1 ? employees[0] : null, start, end, schedulerCallback, appointment);
            }
            else
            {
                if(employees.Count == 0)
                {
                    employees.Add(BeWoApp.CompactLoggedOnEmployee);
                }

                // Gruppenbuchungen
                newView = new ChatDokumentationsView(appointment, notice, start, end, customer, employees, schedulerCallback);
            }

            newView.ShowDialog();
        }

        public static void CreateZeiterfassung(DateTime start, DateTime end, List<CompactCustomerDC> customer, List<CompactEmployeeDC> employees, String notice)
        {
            ChatDokumentationsView newView;

            if(customer.Count == 0)
            {
                // Normale Buchung
                newView = new ChatDokumentationsView(notice, null, start, end, null);
            }
            else if(customer.Count == 1 && employees.Count < 2)
            {
                var compactKlient = ServiceFacade.DoCustomerServiceSync(s => s.GetCompactCustomerDC(customer[0].CustomerOid));

                // Normale Buchung
                newView = new ChatDokumentationsView(notice, compactKlient, start, end, employees.Count == 1 ? employees[0] : null);
            }
            else
            {
                if(employees.Count == 0)
                {
                    employees.Add(BeWoApp.CompactLoggedOnEmployee);
                }

                // Gruppenbuchungen
                newView = new ChatDokumentationsView(notice, start, end, customer, employees);
            }

            newView.ShowDialog();
        }

        public static void OwnChatSynchronisationVeranlassen()
        {
            if (!BeWoApp.Mandator.Apikey.IsNullOrEmpty())
            {
                try
                {
                    var tenant = BeWoApp.Tenant;

                    #if DEBUG
                    tenant = "2509786400";
#endif

                    
                    BeWoApp.GetChatServerUrlAsync(serverUrl =>
                    {
                        var url = $"{serverUrl}/api/ownchat/sync/schedule/{BeWoApp.Mandator.Apikey}/{tenant}";

                        var client = new RestClient(url);
                        var request = new RestRequest();

                        client.ExecuteAsync(request, null);
                    });

//                    var serverUrl = BeWoApp.GetChatServerURL();

//                    if (!string.IsNullOrEmpty(serverUrl))
//                    {
//#if DEBUG
//                        var endurl = serverUrl + "/api/ownchat/sync/schedule/" + BeWoApp.Mandator.Apikey + "/5473568546";
//#else
//                        var endurl = serverUrl + "/api/ownchat/sync/schedule/" + BeWoApp.Mandator.Apikey + "/" + BeWoApp.Tenant;
//#endif
//                        WebRequest request = WebRequest.Create(endurl);

//                        request.Credentials = CredentialCache.DefaultCredentials;

//                        var response = request.GetResponse();
                        
//                        response.Close();
//                        response.Dispose();

                }
                catch (Exception exception)
                {
                    // MessageBox.Show("Die Verbindung konnte nicht aufgebaut werden.", "ownChat Fehler ", MessageBoxButton.OK);

                }
            }
        }

        public static bool HasRights(IEnumerable<UserRightType> pUserRightTypes)
        {
            return BeWoApp.HasLoggedOnUserRight(pUserRightTypes.ToArray());
        }
        
        public static bool HasRight(UserRightType pUserRightType)
        {
            return BeWoApp.LoggedOnUser.HasRight(pUserRightType);
        }
        
        public static bool CheckSchedulerRights(Appointment pAppointment, bool pIsNew, SchedulerRightsCheckType pCheckType, List<long> teamMemberCustomerOids, bool ignoreViewEditCreateAllRights)
        {
            var storage = pAppointment.GetCustomFieldStorage();

            return Utils.CheckSchedulerRights(storage.CustomerList, storage.ResourceList, storage.EmployeeList.ToList(), storage.Originator, pIsNew, pCheckType, BeWoApp.LoggedOnUser, teamMemberCustomerOids, ignoreViewEditCreateAllRights);
        }

        public static void EditServiceRecord(ServiceRecordDC dc, DispatcherObject p, Action<List<ServiceRecordDC>> callback)
        {
            
            var record = ServiceFacade.DoOperationsServiceSync(s => s.GetServiceRecordById(dc.ServiceRecordOid.Value));


            //var allgoalsCopy = GoalService.CopyGoals(selectedRecord.AllGoals, false);

            //var sr = new ServiceRecordVM(record, ViewModel.PrototypeVM.Category2Services,
                //selectedRecord.AllGoalCategories, allgoalsCopy);

            VMFactory.CreateServiceRecordVMAsync(
                BeWoApp.LoggedOnUser.Employee.EmployeeOid,
                vmList =>  p.Dispatch(
                    delegate
                    {
                        vmList.DispatcherObject = p;

                        if (record.Customer != null && record.SupportConcept != null)
                        {
                            vmList.InitPrototypeVM(record.Customer.CustomerOid, record.SupportConcept.SupportConceptOid, record.CostBearer2SupportConceptOid);
                        }
                        //var allgoalsCopy = GoalService.CopyGoals(selectedRecord.AllGoals, false);

                        //var sr = new ServiceRecordVM(record, ViewModel.PrototypeVM.Category2Services,
                        //    selectedRecord.AllGoalCategories, allgoalsCopy);
                        
                        var vm = new ServiceRecordVM(record, vmList.PrototypeVM.Category2Services, vmList.PrototypeVM.AllGoalCategories, vmList.PrototypeVM.AllGoals);

                        EditServiceRecord(vmList, vm, callback);
                    }));
        }
        public static void EditServiceRecord(ServiceRecordListVM listvm, ServiceRecordVM vm, Action<List<ServiceRecordDC>> savedCallback)
        {
            if (vm == null)
            {
                return;
            }

            BeWoView serviceRecordEditView;

            if (vm.GroupOid != null)
            {
                serviceRecordEditView = new ServiceRecordGroupEditView();
            }
            else
            {
                serviceRecordEditView = new ServiceRecordEditView();
            }
            double height = BeWoApp.MainControl.ActualHeight * 0.8;
            double width = 710;

            if (BeWoApp.AppSettings.ShowRtfTextfield)
            {
                height = BeWoApp.MainControl.ActualHeight - 120;
                width = 1000;
            }
            if (BeWoApp.MainControl.ActualWidth < width)
            {
                width = BeWoApp.MainControl.ActualWidth;
            }
            if (height < 600)
            {
                height = 600;
            }

            var beWoWindow = new BeWoWindow
            {
                Height = height,
                Width = width,
                WindowStartupLocation = WindowStartupLocation.CenterOwner,
                GroupBoxContent = serviceRecordEditView,
                Owner = BeWoApp.CurrentBeWo.MainWindow
            };

            beWoWindow.rootGroupBox.Style = null;
            beWoWindow.rootGroupBox.Visibility = Visibility.Visible;
            beWoWindow.rootGroupBox.Margin = new Thickness(-10);
            beWoWindow.rootGroupBox.Padding = new Thickness(0);

            if (serviceRecordEditView.CommandBindings.Count == 0)
            {
                serviceRecordEditView.CommandBindings.Add(
                    new CommandBinding(
                        ApplicationCommands.Close,
                        (s, e) =>
                        {
                            var result = ServiceRecordDialogResult.ClosedWithoutSaving;

                            if (vm.EditAllowed)
                            {
                                if (serviceRecordEditView is ServiceRecordEditView view)
                                {
                                    result = view.CloseAndDoSaveCheck();
                                }
                                else
                                {
                                    result = ((ServiceRecordGroupEditView)serviceRecordEditView).CloseAndDoSaveCheck();
                                }
                            }
                            
                            beWoWindow.Close();

                            if (savedCallback != null && result == ServiceRecordDialogResult.ClosedWithSaving)
                            {
                                savedCallback(null);
                            }
                        }));
                serviceRecordEditView.CommandBindings.Add(
                    new CommandBinding(
                        ApplicationCommands.Save,
                        (s, e) =>
                        {
                            if (vm.EditAllowed)
                            {
                                bool save;
                                if (serviceRecordEditView is ServiceRecordEditView)
                                {
                                    save = ((ServiceRecordEditView)serviceRecordEditView).IsValid() &&
                                           ((ServiceRecordEditView)serviceRecordEditView).IsCustomerChangeAllowed();
                                }
                                else
                                {
                                    save = ((ServiceRecordGroupEditView)serviceRecordEditView).IsValid() &&
                                           ((ServiceRecordGroupEditView)serviceRecordEditView)
                                           .IsCustomerChangeAllowed();
                                }

                                if (!save)
                                {
                                    return;
                                }

                                if (savedCallback != null && serviceRecordEditView is ServiceRecordGroupEditView)
                                {
                                    ((ServiceRecordGroupEditView)serviceRecordEditView).SaveWithCallback(savedCallback);
                                }
                                else
                                {
                                    serviceRecordEditView.SaveData();
                                    if (savedCallback != null)
                                    {
                                        savedCallback(null);
                                    }
                                }

                            }
                            beWoWindow.Close();
                        }));
            }

            if (serviceRecordEditView is ServiceRecordEditView)
            {
                ((ServiceRecordEditView)serviceRecordEditView).InitView(listvm, vm, vm.SupportConcept == null);
                
            }
            else
            {
                var group = ServiceFacade.DoOperationsServiceSync(s => s.GetServiceRecordGroup(vm.GroupOid.Value));

                ((ServiceRecordGroupEditView)serviceRecordEditView).InitView(listvm, vm, group);

                beWoWindow.Width += 190;
            }

            beWoWindow.ShowDialog();
        }

        public static bool CheckForExistingSignatures(ServiceRecordDC serviceRecord)
        {
            var validationResult = ServiceFacade.DoOperationsServiceSync(s => s.CheckForExistingSignature(serviceRecord));

            return validationResult != null && MessageBox.Show(validationResult.Message, "Speichern", MessageBoxButton.YesNo, MessageBoxImage.Warning).Equals(MessageBoxResult.Yes) || validationResult == null;
        }
    }
}