prs/prs.desktop/Dashboards/HumanResources/EmployeeQualificationDashboard.xaml.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using PRSDesktop.WidgetGroups;
using Syncfusion.UI.Xaml.Grid.Helpers;
using Syncfusion.UI.Xaml.ScrollAxis;
using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using InABox.Configuration;
using System.ComponentModel;

namespace PRSDesktop
{

    class CellBackgroundConverter : IValueConverter
    {
        private EmployeeQualificationDashboard Dashboard;

        public CellBackgroundConverter(EmployeeQualificationDashboard dashboard)
        {
            Dashboard = dashboard;
        }

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if(value is DateTime date)
            {
                if (date == DateTime.MinValue || date == DateTime.MaxValue)
                    return DependencyProperty.UnsetValue;

                var diff = date - DateTime.Now;
                if (diff <= TimeSpan.Zero)
                    return new SolidColorBrush(Colors.Salmon);
                else if (diff.TotalDays < 7)
                    return new SolidColorBrush(Colors.Orange);
                else if (diff.TotalDays < 30)
                    return new SolidColorBrush(Colors.Yellow);
                return DependencyProperty.UnsetValue;
            }
            if(value is EmployeeQualificationDashboard.CellValue cellValue)
            {
                switch (cellValue)
                {
                    case EmployeeQualificationDashboard.CellValue.Required:
                        return Dashboard.Resources["shadedBackground"];
                    case EmployeeQualificationDashboard.CellValue.None:
                        return DependencyProperty.UnsetValue;
                }
            }
            return DependencyProperty.UnsetValue;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
    public class CellContentConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is null || value is not DateTime date || date == DateTime.MinValue)
                return DependencyProperty.UnsetValue;

            if(date == DateTime.MaxValue)
                return "Perm.";

            return date.ToString("dd/MM/yy");
        }

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

    public class EmployeeQualificationDashboardProperties : IUserConfigurationSettings, IDashboardProperties
    {
        public Dictionary<Guid, bool>? Employees { get; set; } = null;
        public Dictionary<Guid, bool>? Qualifications { get; set; } = null;
    }

    public class EmployeeQualificationDashboardElement : DashboardElement<EmployeeQualificationDashboard, HumanResources, EmployeeQualificationDashboardProperties> { }

    /// <summary>
    /// Interaction logic for EmployeeQualificationDashboard.xaml
    /// </summary>
    public partial class EmployeeQualificationDashboard : UserControl, IDashboardWidget<HumanResources, EmployeeQualificationDashboardProperties>, IRequiresCanView<EmployeeQualification>, IHeaderDashboard
    {
        private DataTable DataTable;
        private CoreTable CoreTable;

        private List<Guid> AllEmployees;
        private Dictionary<Guid, bool> Employees;
        private Dictionary<Guid, bool> Qualifications;

        private Dictionary<Guid, string> ColumnHeaders;

        private List<Guid> QualificationIDs;
        private List<Guid> EmployeeIDs;

        public enum CellValue
        {
            None,
            Required
        }

        private Filter<Employee> EmployeeFilter { get; set; } = new Filter<Employee>().All()
            .And(new Filter<Employee>(x => x.StartDate).IsEqualTo(DateTime.MinValue)
                .Or(x => x.StartDate).IsLessThan(DateTime.Now))
            .And(new Filter<Employee>(x => x.FinishDate).IsEqualTo(DateTime.MinValue)
                .Or(x => x.FinishDate).IsGreaterThan(DateTime.Now));
        
        public EmployeeQualificationDashboardProperties Properties { get; set; }

        public DashboardHeader Header { get; set; } = new();

        public event LoadSettings<EmployeeQualificationDashboardProperties>? LoadSettings;
        public event SaveSettings<EmployeeQualificationDashboardProperties>? SaveSettings;

        public EmployeeQualificationDashboard()
        {
            InitializeComponent();
        }

        #region CorePanel Stuff

        public void Refresh()
        {
            //Properties.Qualifications = Qualifications;
            //Properties.Employees = Employees;

            CoreTable = new("Qualifications");
            ColumnHeaders = new();

            var employeeFilter = EmployeeFilter;
            var employeeIDs = Employees.Where(x => x.Value).Select(x => x.Key).ToArray();
            var results = Client.QueryMultiple(
                new KeyedQueryDef<Employee>(nameof(Employee),
                    new Filter<Employee>(x => x.ID).InList(employeeIDs),
                    Columns.None<Employee>().Add(x => x.ID, x => x.Name)),
                new KeyedQueryDef<EmployeeQualification>(nameof(EmployeeQualification),
                    new Filter<EmployeeQualification>(x => x.Employee.ID).InList(employeeIDs),
                    Columns.None<EmployeeQualification>().Add(
                        x => x.Employee.ID,
                        x => x.Qualification.ID,
                        x => x.Expiry)),
                new KeyedQueryDef<Qualification>(nameof(Qualification),
                    new Filter<Qualification>(x => x.ID).InList(Qualifications.Where(x => x.Value).Select(x => x.Key).ToArray()),
                    Columns.None<Qualification>().Add(x => x.ID, x => x.Description)),
                new KeyedQueryDef<EmployeeRequiredQualification>(
                    new Filter<EmployeeRequiredQualification>(x => x.Employee.ID).InList(employeeIDs),
                    Columns.None<EmployeeRequiredQualification>().Add(x => x.Employee.ID, x => x.Qualification.ID)));

            CoreTable.Columns.Add(new CoreColumn() { ColumnName = "Employee", DataType = typeof(string) });

            var columns = new List<Guid>();

            var qualifications = results[nameof(Qualification)];
            foreach (var qualification in qualifications.Rows)
            {
                var qID = qualification.Get<Qualification, Guid>(x => x.ID);
                if (!columns.Contains(qID))
                {
                    CoreTable.Columns.Add(new CoreColumn() { ColumnName = qID.ToString(), DataType = typeof(object) });
                    columns.Add(qID);
                    ColumnHeaders.Add(qID, qualification.Get<Qualification, string>(x => x.Description));
                }
            }
            QualificationIDs = columns;

            EmployeeIDs = new();

            var requiredQualifications = results.Get<EmployeeRequiredQualification>()
                .ToObjects<EmployeeRequiredQualification>()
                .GroupBy(x => x.Employee.ID, x => x.Qualification.ID)
                .ToDictionary(x => x.Key, x => x.ToHashSet());

            var employeeQualifications = results[nameof(EmployeeQualification)];
            foreach (var employee in results[nameof(Employee)].Rows)
            {
                var employeeID = employee.Get<Employee, Guid>(x => x.ID);
                EmployeeIDs.Add(employeeID);

                var required = requiredQualifications.GetValueOrDefault(employeeID) ?? new HashSet<Guid>();

                List<object?> values = new()
                {
                    employee["Name"]
                };

                var thisQualifications = employeeQualifications.Rows
                    .Where(x => x.Get<EmployeeQualification, Guid>(x => x.Employee.ID) == employeeID)
                    .ToList();
                foreach (var qID in columns)
                {
                    var employeeQualification = thisQualifications
                        .Where(x => x.Get<EmployeeQualification, Guid>(x => x.Qualification.ID) == qID)
                        .FirstOrDefault();
                    if(employeeQualification != null)
                    {
                        var expiry = employeeQualification.Get<EmployeeQualification, DateTime>(x => x.Expiry);
                        if(expiry == DateTime.MinValue || expiry == DateTime.MaxValue)
                        {
                            values.Add(DateTime.MaxValue);
                        }
                        else
                        {
                            values.Add(expiry);
                        }
                    }
                    else if (required.Contains(qID))
                    {
                        values.Add(CellValue.Required);
                    }
                    else
                    {
                        values.Add(CellValue.None);
                    }
                }
                var row = CoreTable.NewRow();
                row.LoadValues(values);
                CoreTable.Rows.Add(row);
            }

            DataTable = CoreTable.ToDataTable();
            DataGrid.ItemsSource = DataTable;

            foreach(var column in CoreTable.Columns)
            {
                if(Guid.TryParse(column.ColumnName, out var qID))
                {
                    column.ColumnName = ColumnHeaders[qID];
                }
            }
        }

        public static bool IsEmployeeActive(Employee employee)
            => (employee.StartDate == DateTime.MinValue || employee.StartDate < DateTime.Now)
            && (employee.FinishDate == DateTime.MinValue || employee.FinishDate > DateTime.Now);

        private void LoadEmployees()
        {
            var employees = Client.Query(null, Columns.None<Employee>().Add(x => x.ID, x => x.StartDate, x => x.FinishDate))
                .ToObjects<Employee>()
                .ToDictionary(
                    x => x.ID,
                    IsEmployeeActive);
            if (Properties.Employees is not null)
            {
                employees = employees
                    .ToDictionary(
                        x => x.Key,
                        x => !Properties.Employees.ContainsKey(x.Key) || Properties.Employees[x.Key]);
            }
            Employees = employees;
        }
        private void LoadQualifications()
        {
            var qualifications = Client.Query(null, Columns.None<Qualification>().Add(x => x.ID))
                .Rows.Select(x => x.Get<Qualification, Guid>(x => x.ID)).ToDictionary(x => x, x => true);
            if (Properties.Qualifications is not null)
            {
                qualifications = qualifications
                    .ToDictionary(
                        x => x.Key,
                        x => !Properties.Qualifications.ContainsKey(x.Key) || Properties.Qualifications[x.Key]);
            }
            Qualifications = qualifications;
        }

        public void Setup()
        {
            var employeeFilter = EmployeeFilter;
            var results = Client.QueryMultiple(
                new KeyedQueryDef<Employee>(nameof(Employee),
                    new Filter<Employee>().All(),
                    Columns.None<Employee>().Add(x => x.ID, x => x.StartDate, x => x.FinishDate)),
                new KeyedQueryDef<Qualification>(nameof(Qualification),
                    new Filter<Qualification>().All(),
                    Columns.None<Qualification>().Add(x => x.ID)));

            var employees = results[nameof(Employee)].ToObjects<Employee>().ToDictionary(
                x => x.ID,
                IsEmployeeActive);
            if (Properties.Employees is not null)
            {
                employees = employees
                    .ToDictionary(
                        x => x.Key,
                        x => !Properties.Employees.ContainsKey(x.Key) || Properties.Employees[x.Key]);
            }

            var qualifications = results[nameof(Qualification)].Rows.Select(x => x.Get<Qualification, Guid>(x => x.ID)).ToDictionary(x => x, x => true);
            if(Properties.Qualifications is not null)
            {
                qualifications = qualifications
                    .ToDictionary(
                        x => x.Key,
                        x => !Properties.Qualifications.ContainsKey(x.Key) || Properties.Qualifications[x.Key]);
            }

            Employees = employees;
            Qualifications = qualifications;

            DataGrid.CellDoubleTapped += DataGrid_CellDoubleTapped;

            SetupHeader();
        }

        public void Shutdown(CancelEventArgs? cancel)
        {
        }

        #endregion

        #region Header

        public void SetupHeader()
        {
            var exportButton = new Button
            {
                Content = "Export",
                Padding = new Thickness(5)
            };
            exportButton.Click += (o, e) =>
            {
                DoExport();
            };

            Header.BeginUpdate()
                .Clear()
                .AddRight(exportButton);

            Header.EndUpdate();
        }

        private void DoExport()
        {
            var newTable = new CoreTable(CoreTable.TableName);
            newTable.LoadColumns(CoreTable.Columns);
            foreach (var row in CoreTable.Rows)
            {
                var newRow = newTable.NewRow();
                foreach (var value in row.Values)
                {
                    object? newValue;
                    if (value is DateTime date)
                    {
                        if (date == DateTime.MaxValue)
                            newValue = "Permanent";
                        else if (date == DateTime.MinValue)
                            newValue = "";
                        else
                            newValue = date;
                    }
                    else if(value is CellValue cellValue)
                    {
                        newValue = "";
                    }
                    else
                    {
                        newValue = value;
                    }
                    newRow.Values.Add(newValue);
                }
                newTable.Rows.Add(newRow);
            }

            ExcelExporter.DoExport(newTable, "EmployeeQualifications");
        }

        #endregion

        #region Grid Events

        private EmployeeQualification? GetCellEmployeeQualification(int row, int column)
        {
            var employeeID = EmployeeIDs[row - 1];
            var qualificationID = QualificationIDs[column - 1];

            var qualification = new Client<EmployeeQualification>()
                .Query(
                    new Filter<EmployeeQualification>(x => x.Employee.ID).IsEqualTo(employeeID)
                        .And(x => x.Qualification.ID).IsEqualTo(qualificationID));
            return qualification.Rows.FirstOrDefault()?.ToObject<EmployeeQualification>();
        }

        private object? GetCellData(int row, int column)
        {
            var cell = DataGrid.GetGridCellInfo(new RowColumnIndex(row, column));

            if (!cell.IsDataRowCell)
                return null;
            var propertyCollection = DataGrid.View.GetPropertyAccessProvider();
            return propertyCollection.GetValue(cell.RowData, cell.Column.MappingName);
        }
        private string GetColumnHeader(int column)
        {
            var header = DataGrid.GetHeaderCell(DataGrid.Columns[column]);

            if (header is null)
                return "";
            return header.Content?.ToString() ?? "";
        }
        private string GetRowHeader(int row) => GetCellData(row, 0)?.ToString() ?? "";

        private void DoEditQualification(int row, int column)
        {
            var qualification = GetCellEmployeeQualification(row, column);
            if (qualification is null)
                return;

            var grid = DynamicGridUtils.CreateDynamicGrid(typeof(DynamicDataGrid<>), typeof(EmployeeQualification)) as DynamicDataGrid<EmployeeQualification>;
            if (grid!.EditItems(new[] { qualification }))
            {
                new Client<EmployeeQualification>().Save(qualification, "Edited by user from dashboard");

                Refresh();
            }
        }

        private void DataGrid_CellDoubleTapped(object? sender, Syncfusion.UI.Xaml.Grid.GridCellDoubleTappedEventArgs e)
        {
            var rowIndex = e.RowColumnIndex.RowIndex;
            var columnIndex = e.RowColumnIndex.ColumnIndex;
            DoEditQualification(rowIndex, columnIndex);
        }


        private void DataGrid_AutoGeneratingColumn(object sender, Syncfusion.UI.Xaml.Grid.AutoGeneratingColumnArgs e)
        {
            if (e.Column.ValueBinding is not Binding value) return;

            if (Guid.TryParse(e.Column.HeaderText, out var qID))
            {
                e.Column.HeaderStyle = Resources["QualificationHeaderStyle"] as Style;
                e.Column.HeaderText = ColumnHeaders[qID];
                e.Column.Width = 55;
                e.Column.TextAlignment = TextAlignment.Center;
                e.Column.ShowHeaderToolTip = true;
                e.Column.ShowToolTip = true;

                var style = new Style();
                style.Setters.Add(new Setter(BackgroundProperty,
                    new Binding(value.Path.Path) { Converter = new CellBackgroundConverter(this) }));
                e.Column.CellStyle = style;
                e.Column.DisplayBinding = new Binding
                { Path = new PropertyPath(e.Column.MappingName), Converter = new CellContentConverter() };
            }
            else
            {
                e.Column.HeaderStyle = Resources["EmployeeHeaderStyle"] as Style;
            }
        }

        private bool OpenCellTooltip(ToolTip tooltip, int row, int column)
        {
            var data = GetCellData(row, column);
            if(data is CellValue cellValue)
            {
                if (cellValue == CellValue.Required)
                {
                    tooltip.Content = new TextBlock { Text = $"{GetRowHeader(row)} requires '{GetColumnHeader(column)}', but they do not have it." };
                    return true;
                }
            }
            return false;
        }
        private void DataGrid_CellToolTipOpening(object sender, Syncfusion.UI.Xaml.Grid.GridCellToolTipOpeningEventArgs e)
        {
            var vc = DataGrid.GetVisualContainer();
            var p = Mouse.GetPosition(vc);
            var rci = vc.PointToCellRowColumnIndex(p);

            if (rci.RowIndex > 0 && rci.ColumnIndex > 0)
            {
                if(!OpenCellTooltip(e.ToolTip, rci.RowIndex, rci.ColumnIndex))
                {
                    e.ToolTip.IsOpen = false;
                    e.ToolTip.Visibility = Visibility.Collapsed;
                }
                else
                {
                    e.ToolTip.Visibility = Visibility.Visible;
                }
            }
        }

        private void PopulateCellMenu(ContextMenu menu, int row, int column)
        {
            var data = GetCellData(row, column);
            if (data is null || data is not DateTime)
            {
                menu.AddItem("No Qualification", null, null, false);
                return;
            }

            menu.AddItem("Edit Qualification", null, new Tuple<int, int>(row, column), EditQualification_Click);
        }

        private void EditQualification_Click(Tuple<int, int> obj)
        {
            DoEditQualification(obj.Item1, obj.Item2);
        }

        private void DataGrid_ContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            var vc = DataGrid.GetVisualContainer();
            var p = Mouse.GetPosition(vc);
            var rci = vc.PointToCellRowColumnIndex(p);

            var menu = DataGrid.ContextMenu;
            menu.Items.Clear();
            if(rci.RowIndex == 0)
            {
                menu.AddItem("Select Qualifications", null, SelectQualification_Click);
                if (Properties.Qualifications is not null)
                {
                    menu.AddItem("Reset to Default", null, () =>
                    {
                        Properties.Qualifications = null;
                        LoadQualifications();
                        Refresh();
                    });
                }

                if (rci.ColumnIndex > 0)
                {
                    var column = CoreTable.Columns[rci.ColumnIndex];
                    var hideQualification = new MenuItem() { Header = $"Hide '{column.ColumnName}'" };
                    hideQualification.Click += (sender, e) =>
                    {
                        Qualifications[QualificationIDs[rci.ColumnIndex - 1]] = false;
                        Properties.Qualifications = Qualifications;
                        Refresh();
                    };
                    menu.Items.Add(hideQualification);
                }
            }
            if(rci.ColumnIndex == 0)
            {
                menu.AddItem("Select Employees", null, SelectEmployee_Click);
                if(Properties.Employees is not null)
                {
                    menu.AddItem("Reset to Default", null, () =>
                    {
                        Properties.Employees = null;
                        LoadEmployees();
                        Refresh();
                    });
                }

                if (rci.RowIndex > 0)
                {
                    var row = CoreTable.Rows[rci.RowIndex - 1];
                    var hideEmployee = new MenuItem() { Header = $"Hide '{row["Employee"]}'" };
                    hideEmployee.Click += (sender, e) =>
                    {
                        Employees[EmployeeIDs[rci.RowIndex - 1]] = false;
                        Properties.Employees = Employees;
                        Refresh();
                    };
                    menu.Items.Add(hideEmployee);
                }
            }

            if(rci.RowIndex > 0 && rci.ColumnIndex > 0)
            {
                PopulateCellMenu(menu, rci.RowIndex, rci.ColumnIndex);
            }
        }

        private void SelectEmployee_Click()
        {
            var window = new EntitySelectionWindow(typeof(Employee), Employees.Where(x => x.Value).Select(x => x.Key).ToHashSet(), typeof(EmployeeSelectionGrid));
            window.ShowDialog();

            Employees = Employees.ToDictionary(
                x => x.Key,
                x => window.Entities.Contains(x.Key));
            Properties.Employees = Employees;

            Refresh();
        }

        private void SelectQualification_Click()
        {
            var window = new EntitySelectionWindow(typeof(Qualification), Qualifications.Where(x => x.Value).Select(x => x.Key).ToHashSet());
            window.ShowDialog();
            Qualifications = Qualifications.ToDictionary(
                x => x.Key,
                x => window.Entities.Contains(x.Key));
            Properties.Qualifications = Qualifications;
            Refresh();
        }

        #endregion

    }

    class EmployeeSelectionGrid : EntitySelectionGrid<Employee>
    {
        public override DynamicGridColumns GenerateColumns()
        {
            var columns = new DynamicGridColumns();
            columns.Add<Employee>(x => x.Name, 0, "Name", "", Alignment.MiddleLeft);
            return columns;
        }
    }
}