BeWoPlaner/BeWo/Scheduling/ViewModel/SchedulingAppointmentListVM.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using BeWo.Scheduling.SchedulingUtils;
using BeWo.ViewModel.ListViewModel;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using DevExpress.Mvvm;

namespace BeWo.Scheduling.ViewModel
{
    public class SchedulingAppointmentListVM : AbstractDCListMapperVM<SchedulerAppointmentDC, SchedulingAppointmentVM>
    {
        #region Filtereinstellungen
        private bool _IsAbsenceTimeVisible;
        public bool IsAbsenceTimeVisible
        {
            get => _IsAbsenceTimeVisible;

            set
            {
                _IsAbsenceTimeVisible = value;
                FirePropertyChanged(nameof(IsAbsenceTimeVisible));
            }
        }

        private bool _IsTasksVisible;
        public bool IsTasksVisible
        {
            get => _IsTasksVisible;

            set
            {
                _IsTasksVisible = value;
                FirePropertyChanged(nameof(IsTasksVisible));
            }
        }

        private bool _OnlyPrivateAppointments;
        public bool OnlyPrivateAppointments
        {
            get => _OnlyPrivateAppointments;
            set
            {
                _OnlyPrivateAppointments = value;
                FirePropertyChanged(nameof(OnlyPrivateAppointments));
            }
        }

        public bool ZeigeNurMeineTermine
        {
            get => BeWoApp.AppSettings.ZeigeNurMeineTermine;
            set
            {
                if(BeWoApp.AppSettings.ZeigeNurMeineTermine != value)
                {
                    BeWoApp.AppSettings.ZeigeNurMeineTermine = value;
                    BeWoApp.SaveAppSettings();
                    FirePropertyChanged(nameof(ZeigeNurMeineTermine));
                }
            }
        }
        #endregion Filtereinstellungen


        private int _SelectedTabItemIndex;
        public int SelectedTabItemIndex
        {
            get => _SelectedTabItemIndex;
            set
            {
                _SelectedTabItemIndex = value;
                FirePropertyChanged(nameof(SelectedTabItemIndex));
            }
        }


        public bool DisableUpdateRequestString = false;
        private string _Requests;

        public string Requests
        {
            get => _Requests ?? (_Requests = "keine Benachrichtigung");
            set
            {
                if(AreDifferent(_Requests, value))
                {
                    _Requests = value ?? string.Empty;
                    FirePropertyChanged(nameof(Requests));
                }
            }
        }

        private bool _IsEmployeeBrushVisible;

        public bool IsEmployeeBrushVisible
        {
            get => _IsEmployeeBrushVisible;

            set
            {
                _IsEmployeeBrushVisible = value;
                FirePropertyChanged(nameof(IsEmployeeBrushVisible));
            }
        }

        public bool IsInCustomerViewMode { get; set; }


        public ObservableCollection<ResourceDC> AllResources
        {
            get
            {
                if(Categories2Resources?.Any() ?? false)
                {
                    var result = new ObservableCollection<ResourceDC>();

                    foreach(var cat2Res in Categories2Resources)
                    {
                        foreach(var res in cat2Res.Value)
                        {
                            result.AddIfNotIn(res.DataContract);
                        }
                    }

                    return result;
                }

                return new ObservableCollection<ResourceDC>();
            }
        }

        private ObservableSortCollection<EmployeeDependencyObject> _FilteredEmployees;
        /// <summary>
        /// Die nach Suchtext gefilterten Mitarbeiter
        /// </summary>
        public ObservableSortCollection<EmployeeDependencyObject> FilteredEmployees
        {
            get => _FilteredEmployees ?? (_FilteredEmployees = new ObservableSortCollection<EmployeeDependencyObject>(Employees));

            set
            {
                if(!ICollectionExtensions.ListEquals(_FilteredEmployees, value))
                {
                    _FilteredEmployees = value;
                    _FilteredEmployees.Sort((x, y) => string.Compare(x.Employee.LastName + ", " + x.Employee.FirstName, y.Employee.LastName + ", " + y.Employee.FirstName, StringComparison.Ordinal));

                    FirePropertyChanged(nameof(FilteredEmployees));
                }
            }
        }

        private ObservableSortCollection<CompactCustomerDC> _FilteredCustomers;
        /// <summary>
        /// Die nach Suchtext gefilterten Klienten
        /// </summary>
        public ObservableSortCollection<CompactCustomerDC> FilteredCustomers
        {
            get => _FilteredCustomers ?? (_FilteredCustomers = new ObservableSortCollection<CompactCustomerDC>(AllCustomers));

            set
            {
                if(!ICollectionExtensions.ListEquals(_FilteredCustomers, value))
                {
                    _FilteredCustomers = value;
                    _FilteredCustomers.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));

                    FirePropertyChanged(nameof(FilteredCustomers));
                }
            }
        }

        private ObservableSortCollection<CompactCustomerDC> _CustomerList;
        public ObservableSortCollection<CompactCustomerDC> CustomerList
        {
            get => _CustomerList ?? (_CustomerList = new ObservableSortCollection<CompactCustomerDC>());

            set
            {
                if(!ICollectionExtensions.ListEquals(_CustomerList, value))
                {
                    _CustomerList = value;
                    _CustomerList.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));
                    FirePropertyChanged(nameof(CustomerList));
                }
            }
        }

        private List<CompactEmployeeDC> _SelectedEmployees = new List<CompactEmployeeDC>();
        public List<CompactEmployeeDC> SelectedEmployees
        {
            get => _SelectedEmployees;
            set
            {
                if(!ICollectionExtensions.ListEquals(_SelectedEmployees, value))
                {
                    _SelectedEmployees = value;
                    _SelectedEmployees.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));

                    AllEmployeesCheckBoxIsChecked = ICollectionExtensions.ListEquals(value, AllEmployees);

                    ZeigeNurMeineTermine = value.Count == 1 && value.Contains(BeWoApp.CompactLoggedOnEmployee);

                    UpdateSelectedItems();
                }
            }
        }

        private List<CompactCustomerDC> _SelectedCustomers = new List<CompactCustomerDC>();
        public List<CompactCustomerDC> SelectedCustomers
        {
            get => _SelectedCustomers;
            set
            {
                if(!ICollectionExtensions.ListEquals(_SelectedCustomers, value))
                {
                    _SelectedCustomers = value;
                    _SelectedCustomers.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));

                    if(OnlyMyCustomersCheckBoxIsChecked || ICollectionExtensions.ListEquals(AllCustomers, value))
                    {
                        AllCustomersCheckBoxIsChecked = true;
                    }

                    UpdateSelectedItems();
                }
            }
        }

        private List<ResourceDC> _SelectedResources = new List<ResourceDC>();
        public List<ResourceDC> SelectedResources
        {
            get => _SelectedResources;
            set
            {
                if(!ICollectionExtensions.ListEquals(_SelectedResources, value))
                {
                    _SelectedResources = value;

                    AllResourcesCheckBoxChecked = ICollectionExtensions.ListEquals(value, AllResources);

                    UpdateSelectedItems();
                }
            }
        }





        private bool _AllEmployeesCheckBoxIsChecked;
        public bool AllEmployeesCheckBoxIsChecked
        {
            get => _AllEmployeesCheckBoxIsChecked;

            set
            {
                _AllEmployeesCheckBoxIsChecked = value;

                FirePropertyChanged(nameof(AllEmployeesCheckBoxIsChecked));
                UpdateSelectedItems();
            }
        }


        private bool _OnlyMyCustomersCheckBoxIsChecked;
        public bool OnlyMyCustomersCheckBoxIsChecked
        {
            get => _OnlyMyCustomersCheckBoxIsChecked;
            set
            {
                if(AreDifferent(_OnlyMyCustomersCheckBoxIsChecked, value))
                {
                    _OnlyMyCustomersCheckBoxIsChecked = value;
                    FilterCustomers();
                    SelectedCustomers.Clear();
                    SelectedCustomers = FilteredCustomers.ToList();
                    FirePropertyChanged(nameof(OnlyMyCustomersCheckBoxIsChecked));
                    UpdateSelectedItems();
                }
            }
        }


        private bool _AllCustomersCheckBoxIsChecked;
        public bool AllCustomersCheckBoxIsChecked
        {
            get => _AllCustomersCheckBoxIsChecked;

            set
            {
                _AllCustomersCheckBoxIsChecked = value;

                FirePropertyChanged(nameof(AllCustomersCheckBoxIsChecked));
                UpdateSelectedItems();
            }
        }

        private bool _AllResourcesCheckBoxChecked;
        public bool AllResourcesCheckBoxChecked
        {
            get => _AllResourcesCheckBoxChecked;

            set
            {
                _AllResourcesCheckBoxChecked = value;

                FirePropertyChanged(nameof(AllResourcesCheckBoxChecked));
                UpdateSelectedItems();
            }
        }




        public ObservableCollection<IDataContract> SelectedItems
        {
            get
            {
                var selectedItems = new ObservableCollection<IDataContract>();

                selectedItems.AddRange(SelectedEmployees);
                selectedItems.AddRange(SelectedCustomers);
                selectedItems.AddRange(SelectedResources);

                return selectedItems;
            }
        }

        public IEnumerable<IDataContract> AllItems
        {
            get
            {
                var allItems = new List<IDataContract>();

                allItems.AddRange(FilteredEmployees.Select(s => s.Employee));
                allItems.AddRange((IEnumerable<IDataContract>)FilteredCustomers);
                allItems.AddRange(AllResources);

                return allItems;
            }
        }

        public Visibility EmployeeControlsVisibility => BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAnsehen) ? Visibility.Visible : Visibility.Collapsed;
        public Visibility ResourceControlsVisibility => BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAnsehen) ? Visibility.Visible : Visibility.Collapsed;
        public Visibility CustomerControlsVisibility => BeWoApp.LoggedOnUser.HasRight(UserRightType.CustomerView_View) || BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_ViewMyTeams) || BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_ViewMyCustomers) || BeWoApp.LoggedOnUser.HasRight(UserRightType.ViewAll) ? Visibility.Visible : Visibility.Collapsed;

        public Visibility SelectionControlVisibility => EmployeeControlsVisibility == Visibility.Visible || ResourceControlsVisibility == Visibility.Visible || CustomerControlsVisibility == Visibility.Visible ? Visibility.Visible : Visibility.Collapsed;

        public Visibility DeleteInInvervalButtonVisibility => BeWoApp.LoggedOnUser.HasRight(UserRightType.Termine_IntervalDelete) ? Visibility.Visible : Visibility.Collapsed;

        private DateTimeRange _Interval;

        public DateTimeRange Interval
        {
            get => _Interval;
            set
            {
                if(AreDifferent(_Interval, value))
                {
                    _Interval = value;
                    FirePropertyChanged(nameof(Interval));
                }
            }
        }

        public void ReloadRights()
        {
            FirePropertyChanged(nameof(EmployeeControlsVisibility));
            FirePropertyChanged(nameof(ResourceControlsVisibility));
            FirePropertyChanged(nameof(CustomerControlsVisibility));
            FirePropertyChanged(nameof(SelectionControlVisibility));
            FirePropertyChanged(nameof(DeleteInInvervalButtonVisibility));
        }

        public bool ShouldLockOverlappingAppointmentCheck { get; set; }


        private ObservableSortCollection<CompactCustomerDC> _AllCustomers;
        public ObservableSortCollection<CompactCustomerDC> AllCustomers
        {
            get => _AllCustomers ?? (_AllCustomers = new ObservableSortCollection<CompactCustomerDC>());
            set
            {
                if(AreDifferent(_AllCustomers, value))
                {
                    _AllCustomers = value;
                    FilterCustomers();
                    FirePropertyChanged(nameof(AllCustomers));
                }
            }
        }

        private ObservableSortCollection<CompactEmployeeDC> _AllEmployees;
        public ObservableSortCollection<CompactEmployeeDC> AllEmployees
        {
            get => _AllEmployees ?? (_AllEmployees = new ObservableSortCollection<CompactEmployeeDC>());
            set
            {
                if(AreDifferent(_AllEmployees, value))
                {
                    _AllEmployees = value;
                    FirePropertyChanged(nameof(AllEmployees));
                }
            }
        }

        public ObservableCollection<SchedulingAppointmentVM> SelectedAppointments { get; set; }

        private ObservableDictionary<CategoryDependencyObject, List<ResourceDependencyObject>> _Categories2Resources;

        public ObservableDictionary<CategoryDependencyObject, List<ResourceDependencyObject>> Categories2Resources
        {
            get => _Categories2Resources ?? (_Categories2Resources = new ObservableDictionary<CategoryDependencyObject, List<ResourceDependencyObject>>());

            set
            {
                if(!SchedulingUtils.Utils.Categories2ResourcesEquals(_Categories2Resources, value))
                {
                    _Categories2Resources = value;
                    FirePropertyChanged(nameof(Categories2Resources));
                }
            }
        }


        public List<CompactCustomerDC> OwnCustomers { get; }

        public SchedulingAppointmentListVM()
        {
            Categories2Resources = new ObservableDictionary<CategoryDependencyObject, List<ResourceDependencyObject>>();
            AllCustomers = new ObservableSortCollection<CompactCustomerDC>();
            AllEmployees = new ObservableSortCollection<CompactEmployeeDC>();

            SelectedAppointments = new ObservableCollection<SchedulingAppointmentVM>();

            OwnCustomers = BeWoApp.LoggedOnEmployee.RelatedCustomers.Select(s => s.Customer).ToList();

            UpdateSelectedItems();

            InitViewModel();
        }

        public void AddAbsenceTimes(List<AbsenceTimeDC> absenceTimes, DateTime intervalEnd)
        {
            foreach(var absenceTime in absenceTimes.Where(w => w.Start != null))
            {
                var subject = absenceTime.Reason.Description;
                var employee = absenceTime.EmployeeOid != null ? AllEmployees.FirstOrDefault(e => e.EmployeeOid == absenceTime.EmployeeOid.Value) : null;

                if(employee != null)
                {
                    subject += $" ({employee.SimpleDescription})";
                }

                var absenceTimeEnd = absenceTime.End?.AddTicks(1);

                VMList.Add(new SchedulingAppointmentVM(true, subject, absenceTime.Start.Value, absenceTime.End ?? intervalEnd, employee, absenceTime.Start, absenceTimeEnd));
            }
        }

        private bool _Enabled;

        public bool Enabled
        {
            get => _Enabled;
            set
            {
                _Enabled = value;
                FirePropertyChanged(nameof(Enabled));
            }
        }

        private void InitViewModel()
        {
            foreach(var item in VMList)
            {
                item.Id = item.DataContract.SchedulerAppointmentOid;

                if(!item.IsPrivate || item.Originator.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid) || item.EmployeeList.Select(s => s.Employee).Contains(BeWoApp.CompactLoggedOnEmployee))
                {
                    continue;
                }

                item.Description = "Privater Termin";
                item.Subject = $"Privat ({item.Originator})";
            }
        }

        private ObservableCollection<SchedulerAppointmentDC> _OpenAppointments;

        public ObservableCollection<SchedulerAppointmentDC> OpenAppointments
        {
            get => _OpenAppointments;
            set
            {
                if(AreDifferent(_OpenAppointments, value))
                {
                    _OpenAppointments = value;
                    FirePropertyChanged(nameof(OpenAppointments));
                }
            }
        }

        public void FilterCustomers()
        {
            FilteredCustomers.Clear();

            var customersToAdd = OnlyMyCustomersCheckBoxIsChecked ? AllCustomers.Where(customer => customer.IsRelatedToEmployee) : AllCustomers;

            FilteredCustomers.AddRange(customersToAdd);
        }

        public void UpdateSelectedItems()
        {
            FirePropertyChanged(nameof(SelectedItems));
            FirePropertyChanged(nameof(SelectedEmployees));
            FirePropertyChanged(nameof(SelectedCustomers));
            FirePropertyChanged(nameof(SelectedResources));
            FirePropertyChanged(nameof(VMList));
            FirePropertyChanged(nameof(Categories2Resources));
            FirePropertyChanged(nameof(FilteredEmployees));
            FirePropertyChanged(nameof(Employees));
            FirePropertyChanged(nameof(AllEmployeesCheckBoxIsChecked));
        }

        public void UpdateEmployeeSelection()
        {
            AllEmployeesCheckBoxIsChecked = SelectedEmployees.Count == AllEmployees.Count;
        }

        public void UpdateEmployeeSelection2()
        {
            SelectedEmployees = GetSelectedEmployees();

            FirePropertyChanged(nameof(Employees));
            AllEmployeesCheckBoxIsChecked = SelectedEmployees.Count == AllEmployees.Count;
        }

        public void UpdateCustomerSelection()
        {
            AllCustomersCheckBoxIsChecked = SelectedCustomers.Count == AllCustomers.Count;
        }

        public void UpdateResourceSelection()
        {
            SelectedResources = new List<ResourceDC>(GetSelectedResources());

            FirePropertyChanged(nameof(Categories2Resources));
            AllResourcesCheckBoxChecked = SelectedResources.Count == AllResources.Count;
        }

        public void FilterEmployees(string searchText)
        {
            FilteredEmployees.Clear();
            FilteredEmployees.AddRangeIfElementsNotIn(
                Employees.Where(employeeDependencyObject => employeeDependencyObject.Employee.FirstName.ToLower().Contains(searchText.ToLower()) ||
                                                            employeeDependencyObject.Employee.LastName.ToLower().Contains(searchText.ToLower())
                ));
        }

        public void FilterCustomers(string searchText)
        {
            FilteredCustomers.Clear();
            FilteredCustomers.AddRangeIfElementsNotIn(AllCustomers.Where(customer => customer.FirstName.ToLower().Contains(searchText.ToLower()) || customer.LastName.ToLower().Contains(searchText.ToLower())));
        }

        private IEnumerable<ResourceDC> GetSelectedResources()
        {
            var result = new List<ResourceDC>();

            foreach(var cat2Res in Categories2Resources)
            {
                foreach(var resource in cat2Res.Value)
                {
                    if(resource.GetValue(TreeViewItemHelper.IsCheckedProperty) is bool value && value)
                    {
                        result.AddIfNotIn(resource.DataContract);
                    }
                }
            }

            return result;
        }

        public void DeselectResource(long oid)
        {
            foreach(var cat2Res in Categories2Resources)
            {
                foreach(var resource in cat2Res.Value)
                {
                    if(resource.DataContract.ResourceOid.HasValue && resource.DataContract.ResourceOid.Value == oid)
                    {
                        resource.SetValue(TreeViewItemHelper.IsCheckedProperty, false);
                    }
                }
            }
        }

        public void DeselectAllResources()
        {
            foreach(var cat2Res in Categories2Resources)
            {
                foreach(var resource in cat2Res.Value)
                {
                    resource.SetValue(TreeViewItemHelper.IsCheckedProperty, false);
                }
            }

            SelectedResources.Clear();
        }

        public void SelectAllResources()
        {
            foreach(var cat2Res in Categories2Resources)
            {
                foreach(var resource in cat2Res.Value)
                {
                    resource.SetValue(TreeViewItemHelper.IsCheckedProperty, true);
                }
            }

            UpdateResourceSelection();
        }

        private ObservableSortCollection<EmployeeDependencyObject> _Employees;
        public ObservableSortCollection<EmployeeDependencyObject> Employees
        {
            get => _Employees ?? (_Employees = new ObservableSortCollection<EmployeeDependencyObject>());
            set
            {
                if(AreDifferent(_Employees, value))
                {
                    _Employees = value;
                    FirePropertyChanged(nameof(Employees));
                }
            }
        }

        private List<CompactEmployeeDC> GetSelectedEmployees()
        {
            var result = new List<CompactEmployeeDC>();

            foreach(var employee in Employees)
            {
                if(employee.GetValue(ListItemHelper.IsCheckedProperty) is bool isChecked && isChecked)
                {
                    result.AddIfNotIn(employee.Employee);
                }
            }

            return result;
        }

        public void DeselectEmployee(long oid)
        {
            foreach(var employeeDependencyObject in Employees)
            {
                if(employeeDependencyObject.Employee.EmployeeOid == oid)
                {
                    employeeDependencyObject.SetValue(ListItemHelper.IsCheckedProperty, false);
                }
            }
        }

        public void DeselectAllEmployees()
        {
            foreach(var employeeDependencyObject in Employees)
            {
                employeeDependencyObject.SetValue(ListItemHelper.IsCheckedProperty, false);
            }

            SelectedEmployees.Clear();
        }

        public void SelectAllEmployees()
        {
            foreach(var employeeDependencyObject in Employees)
            {
                employeeDependencyObject.SetValue(ListItemHelper.IsCheckedProperty, true);
            }
        }

        public void SelectEmployeesAfterReload()
        {
            foreach(var employeeDependencyObject in Employees)
            {
                var val = SelectedEmployees.Any(employee => employee.EmployeeOid == employeeDependencyObject.Employee.EmployeeOid);

                employeeDependencyObject.SetValue(ListItemHelper.IsCheckedProperty, val);
            }
        }

        public List<long> TeamRelatedCustomerOids { get; set; } = new List<long>();
    }
}