prs/prs.desktop/Components/EmployeeSelector/EmployeeSelector.xaml.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Configuration;
using InABox.Core;
using NPOI.HSSF.Util;
using Syncfusion.Windows.Tools.Controls;

namespace PRSDesktop
{
    public class EmployeeSelectorData
    {
        // if first == FullGuid, remainder are selected
        // Otherwise, ignore the rest
        public Guid[] Teams { get; set; }
        
        // if first == FullGuid, select all
        public Guid[] Employees { get; set; }
        
        public EmployeeSelectorData( Guid[] teams, Guid[] employees)
        {
            Teams = teams;
            Employees = employees;
        }

        public EmployeeSelectorData() : this(new[] { Guid.Empty }, new[] { CoreUtils.FullGuid })
        {
        }
    }

    public class EmployeeSelectorSettings
    {
        public double SplitPosition { get; set; }

        public EmployeeSelectorSettings()
        {
            SplitPosition = 200.0F;
        }
    }
    
    public class EmployeeSelectorSettingsChangedArgs : EventArgs
    {
        public EmployeeSelectorSettings Settings { get; private set; }

        public EmployeeSelectorSettingsChangedArgs(EmployeeSelectorSettings settings)
        {
            Settings = settings;
        }
    }
    
    public delegate void EmployeeSelectorSettingsChanged(object sender, EmployeeSelectorSettingsChangedArgs args);
    
    public class EmployeeSelectorSelectionChangedArgs : EventArgs
    {
        public EmployeeSelectorData Selection { get; private set; }

        public EmployeeSelectorSelectionChangedArgs(EmployeeSelectorData selection)
        {
            Selection = selection;
        }
    }

    public delegate void EmployeeSelectorSelectionChanged(object sender, EmployeeSelectorSelectionChangedArgs args);


    public partial class EmployeeSelector : UserControl
    {

        private enum Suppress
        {
            This
        }

        private class ListEntry
        {
            public Guid Key { get; set; }
            public String Value { get; set; }
        }

        public EmployeeSelectorSettings Settings { get; set; }
        
        public event EmployeeSelectorSettingsChanged SettingsChanged;
        public event EmployeeSelectorSelectionChanged SelectionChanged;
        
        private CoreTable _employees;
        private ListEntry[] _teams;
        private Tuple<Guid,Guid,String>[] _employeeteams;

        public T[] GetEmployeeData<T>(Func<CoreRow, T> transform)
        {
            List<T> result = new List<T>();
            var selteams = GetSelectedTeams();
            var selemps = GetSelectedEmployees();
            var empids = _employeeteams
                .Where(x => selteams.Contains(x.Item1) && selemps.Contains(CoreUtils.FullGuid) || selemps.Contains(x.Item2))
                .Select(x => x.Item2)
                .Distinct()
                .ToArray();
            var rows = _employees.Rows.Where(r => empids.Contains(r.Get<Employee, Guid>(c => c.ID)));
            foreach (var row in rows)
                result.Add(transform.Invoke(row));
            return result.ToArray();
        }

        private bool loaded;
        private bool templated;
        
        public EmployeeSelector()
        {
            Settings = new EmployeeSelectorSettings();
            using (new EventSuppressor(Suppress.This))
                InitializeComponent();
        }
        

        public void Setup()
        {
            using (new EventSuppressor(Suppress.This))
            {

                MultiQuery query = new MultiQuery();
                query.Add<Employee>(
                    LookupFactory.DefineFilter<Employee>()
                );
                query.Add<Team>(
                    LookupFactory.DefineFilter<Team>(),
                    new Columns<Team>(x => x.ID)
                        .Add(x => x.Name),
                    new SortOrder<Team>(x => x.Name)
                );

                query.Add<EmployeeTeam>(
                    LookupFactory.DefineFilter<EmployeeTeam>(),
                    new Columns<EmployeeTeam>(x => x.TeamLink.ID)
                        .Add(x => x.EmployeeLink.ID)
                        .Add(x => x.EmployeeLink.Name)
                );
                query.Query();

                _employees = query.Get<Employee>();

                _teams = query.Get<Team>().Rows.Select(r => new ListEntry() { Key = r.Get<Team,Guid>(c=>c.ID), Value = r.Get<Team,String>(c=>c.Name) }).ToArray();
                TeamList.ItemsSource = _teams;
                
                ObservableCollection<ListEntry> teamdata = new() { new ListEntry() { Key = Guid.Empty, Value = "All Staff" } };
                foreach (var team in _teams)
                    teamdata.Add(team);
                teamdata.Add(new ListEntry() { Key = CoreUtils.FullGuid, Value = "Multiple Teams" });
                Teams.ItemsSource = teamdata;
                
                _employeeteams = query.Get<EmployeeTeam>().Rows.Select(
                    row => new Tuple<Guid, Guid, String>(
                        row.Get<EmployeeTeam, Guid>(c => c.TeamLink.ID),
                        row.Get<EmployeeTeam, Guid>(c => c.EmployeeLink.ID),
                        row.Get<EmployeeTeam, String>(c => c.EmployeeLink.Name)
                    )
                ).Union(
                    _employees.Rows.Select(
                        row => new Tuple<Guid,Guid,String>(
                            Guid.Empty,
                            row.Get<Employee, Guid>(c => c.ID),
                            row.Get<Employee, String>(c => c.Name)
                        )
                    )    
                ).ToArray();

                Teams.SelectedValue = Guid.Empty;

            }

        }

        private void UpdateSettings()
        {
            bool changed = false;
            
            var teams = GetSelectedTeams();
            if (teams.Contains(CoreUtils.FullGuid) && (Math.Abs(Settings.SplitPosition - TeamListRow.Height.Value) >= 1.0F))
            {
                changed = true;
                Settings.SplitPosition = TeamListRow.Height.Value;
            }

            if (changed && (!EventSuppressor.IsSet(Suppress.This)))
                SettingsChanged?.Invoke(this, new EmployeeSelectorSettingsChangedArgs(Settings));
        }
        
        private Guid[] GetSelectedTeams()
        {
            Guid teamid = (Guid)Teams.SelectedValue;
            var teams = (teamid == CoreUtils.FullGuid)
                ? TeamList.SelectedItems
                    .OfType<ListEntry>()
                    .Select(x => x.Key)
                    .Prepend(teamid)
                    .ToArray()
                : new Guid[] { teamid };
            return teams;
        }

        private Guid[] GetSelectedEmployees()
        {
            var emps = (SelectedEmployees.SelectedItems.Count == SelectedEmployees.Items.Count)
                ? new Guid[] { CoreUtils.FullGuid }
                : SelectedEmployees.SelectedItems
                    .OfType<ListEntry>()
                    .Select(x => x.Key)
                    .ToArray();
            return emps;
        }

        public EmployeeSelectorData Selection
        {
            get => GetSelectionData();
            set => SelectEmployees(value);
        }
        
        private EmployeeSelectorData GetSelectionData()
        {
            return new EmployeeSelectorData(
                GetSelectedTeams(),
                GetSelectedEmployees()
            );
        }
        
        private void SelectEmployees(EmployeeSelectorData selection)
        {
            using (new EventSuppressor(Suppress.This))
            {
                Teams.SelectedValue = selection.Teams.Contains(CoreUtils.FullGuid)
                    ? CoreUtils.FullGuid
                    : selection.Teams.FirstOrDefault();
                LoadTeams(selection.Teams);
                var employees = SelectedEmployees.ItemsSource as ObservableCollection<ListEntry>;
                var pairs = employees.Where(x => selection.Employees.Contains(CoreUtils.FullGuid) || selection.Employees.Contains(x.Key));
                SelectedEmployees.SelectedItems.Clear();
                foreach (var pair in pairs)
                    SelectedEmployees.SelectedItems.Add(pair);
            }            
        }
        
        private void LoadTeams(Guid[] teamids)
        {
            using (new EventSuppressor(Suppress.This))
            {
                Guid teamid = teamids.FirstOrDefault();
                if (Guid.Equals(teamid, CoreUtils.FullGuid))
                {
                    TeamListRow.Height = new GridLength(Settings.SplitPosition, GridUnitType.Pixel);
                    TeamListSplitterRow.Height = new GridLength(4, GridUnitType.Pixel);
                    var selected = new ObservableCollection<object>(_teams.Where(x => teamids.Contains(x.Key)));
                    TeamList.SelectedItems = selected;
                    LoadEmployees(teamids.Skip(1).ToArray());
                }
                else
                {
                    TeamListRow.Height = new GridLength(0, GridUnitType.Pixel);
                    TeamListSplitterRow.Height = new GridLength(0, GridUnitType.Pixel);
                    LoadEmployees(new Guid[] { teamid });
                }
            }
        }

        private void LoadEmployees(Guid[] teamids)
        {
            using (new EventSuppressor(Suppress.This))
            {
                var empids =_employeeteams
                    .OrderBy(x => x.Item3)
                    .Where(x => teamids.Contains(x.Item1))
                    .Select(x => new Tuple<Guid,String>(x.Item2, x.Item3))
                    .Distinct();
                var emps = empids.Select(x => new ListEntry() { Key = x.Item1, Value = x.Item2 }).ToArray();
                SelectedEmployees.ItemsSource = new ObservableCollection<ListEntry>(emps);
                SelectedEmployees.SelectedItems = new ObservableCollection<object>(emps);
            }
        }
        
        public void SelectEmployee(Guid employeeid)
        {
            using (new EventSuppressor(Suppress.This))
            {
                LoadTeams(new Guid[] { Guid.Empty });
                if (SelectedEmployees.ItemsSource is ObservableCollection<ListEntry> employees)
                {
                    var emp = employees.FirstOrDefault(x => x.Key == employeeid);
                    if (emp != null)
                        SelectedEmployees.SelectedItems = new ObservableCollection<object>() { emp };
                }
            }
        }
        
        private void TeamsSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
                return;
            using (new EventSuppressor(Suppress.This))
                LoadTeams(GetSelectedTeams());
            UpdateSettings();
            SelectionChanged?.Invoke(this, new EmployeeSelectorSelectionChangedArgs(GetSelectionData())); 
        }
        
        private void SelectedTeams_ItemChecked(object? sender, ItemCheckedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
                return;
            using (new EventSuppressor(Suppress.This))
                LoadEmployees(GetSelectedTeams());
            UpdateSettings();
            SelectionChanged?.Invoke(this, new EmployeeSelectorSelectionChangedArgs(GetSelectionData())); 
        }
        
        private void SelectedEmployees_OnItemChecked(object? sender, ItemCheckedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
                return;
            UpdateSettings();
            SelectionChanged?.Invoke(this, new EmployeeSelectorSelectionChangedArgs(GetSelectionData()));            
        }
        
        private void SelectedTeams_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
                return;
            UpdateSettings();
        }


    }
}