prs/prs.desktop/Components/TeamSelector/TeamSelector.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.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using NPOI.HSSF.Util;
using Syncfusion.Windows.Tools.Controls;

namespace PRSDesktop
{
    public class TeamSelectorData
    {
        // FullGuid => All Staff
        public Guid[] Teams { get; set; }
        
        public TeamSelectorData(Guid[] teams)
        {
            Teams = teams;
        }

        public TeamSelectorData() : this(new[] { CoreUtils.FullGuid })
        {
        }
    }

    public class TeamSelectorSettings
    {
        public TeamSelectorSettings()
        {
        }
    }
    
    public class TeamSelectorSettingsChangedArgs : EventArgs
    {
        public TeamSelectorSettings Settings { get; private set; }

        public TeamSelectorSettingsChangedArgs(TeamSelectorSettings settings)
        {
            Settings = settings;
        }
    }
    
    public delegate void TeamSelectorSettingsChanged(object sender, TeamSelectorSettingsChangedArgs args);
    
    public class TeamSelectorSelectionChangedArgs : EventArgs
    {
        public TeamSelectorData Selection { get; private set; }

        public TeamSelectorSelectionChangedArgs(TeamSelectorData selection)
        {
            Selection = selection;
        }
    }

    public delegate void TeamSelectorSelectionChanged(object sender, TeamSelectorSelectionChangedArgs args);


    public partial class TeamSelector : UserControl
    {

        private enum Suppress
        {
            This
        }

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

        public TeamSelectorSettings Settings { get; set; }

        public event TeamSelectorSettingsChanged SettingsChanged;
        public event TeamSelectorSelectionChanged SelectionChanged;
        
        private void UpdateSettings()
        {
            bool changed = false;

            if (changed && (!EventSuppressor.IsSet(Suppress.This)))
                SettingsChanged?.Invoke(this, new TeamSelectorSettingsChangedArgs(Settings));
        }
        
        private ListEntry[] _teams;
        private Tuple<Guid,Guid,String>[] _employeeteams;
        private Dictionary<Guid, EmployeeRosterItem[]> _rosters;
        private CoreTable _employees;
        
        public TeamSelector()
        {
            Settings = new TeamSelectorSettings();
            using (new EventSuppressor(Suppress.This))
                InitializeComponent();
        }
        
        public void Setup()
        {
            using (new EventSuppressor(Suppress.This))
            {
                var results = Client.QueryMultiple(
                    new KeyedQueryDef<Employee>(
                        LookupFactory.DefineFilter<Employee>(),
                        null,
                        new SortOrder<Employee>(x => x.Name)),
                    new KeyedQueryDef<EmployeeRosterItem>(
                        new Filter<EmployeeRosterItem>(x => x.Employee.ID)
                            .InQuery(LookupFactory.DefineFilter<Employee>(), x => x.ID)),
                    new KeyedQueryDef<Team>(
                        LookupFactory.DefineFilter<Team>(),
                        Columns.None<Team>().Add(x => x.ID)
                            .Add(x => x.Name),
                        new SortOrder<Team>(x => x.Name)),
                    new KeyedQueryDef<EmployeeTeam>(
                        LookupFactory.DefineFilter<EmployeeTeam>(),
                        Columns.None<EmployeeTeam>().Add(x => x.TeamLink.ID)
                            .Add(x => x.EmployeeLink.ID)
                            .Add(x => x.EmployeeLink.Name)));

                _employees = results.Get<Employee>();
                _rosters = results.Get<EmployeeRosterItem>().ToObjects<EmployeeRosterItem>()
                    .GroupBy(x => x.Employee.ID, x => x).ToDictionary(x => x.Key, x => x.ToArray());

                _employeeteams = results.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(
                        r => new Tuple<Guid,Guid,String>(
                            CoreUtils.FullGuid,
                            r.Get<Employee,Guid>(c=>c.ID),
                            r.Get<Employee,String>(c=>c.Name)
                        )
                    )    
                ).ToArray();
                
                _teams = results.Get<Team>().Rows.Select(
                    r => new ListEntry()
                    {
                        Key = r.Get<Team, Guid>(c => c.ID), 
                        Value = r.Get<Team, String>(c => c.Name)
                    }
                ).ToArray();
                SelectedTeams.ItemsSource = _teams;
                
            }
        }
        
        public T[] GetEmployeeData<T>(Func<CoreRow, EmployeeRosterItem[], T> transform)
        {
            List<T> result = new List<T>();
            var selteams = GetSelectedTeams();
            var empids = _employeeteams
                .Where(x => selteams.Contains(CoreUtils.FullGuid) || selteams.Contains(x.Item1))
                .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)
            {
                if (!_rosters.TryGetValue(row.Get<Employee, Guid>(x => x.ID), out var rosters))
                {
                    rosters = Array.Empty<EmployeeRosterItem>();
                }
                result.Add(transform.Invoke(row, rosters));
            }
            return result.ToArray();
        }

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

        public TeamSelectorData Selection
        {
            get => GetSelectionData();
            set => SelectTeams(value);
        }
        
        private TeamSelectorData GetSelectionData()
        {
            return new TeamSelectorData(
                GetSelectedTeams()
            );
        }
        
        private void SelectTeams(TeamSelectorData selection)
        {
            using (new EventSuppressor(Suppress.This))
            {
                var sels = _teams.Where(x => selection.Teams.Contains(CoreUtils.FullGuid) || selection.Teams.Contains(x.Key));
                SelectedTeams.SelectedItems.Clear();
                foreach (var sel in sels)
                    SelectedTeams.SelectedItems.Add(sel);
            }            
        }

        private void SelectedTeams_OnItemChecked(object? sender, ItemCheckedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
                return;
            UpdateSettings();
            SelectionChanged?.Invoke(this, new TeamSelectorSelectionChangedArgs(GetSelectionData()));            
        }
    }
}