prs/prs.desktop/Panels/Tasks/TasksByUserControl.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using Syncfusion.UI.Xaml.Kanban;
using Syncfusion.Windows.Tools.Controls;

namespace PRSDesktop;

public class TasksByUserEmployeeHeader
{
    public Guid EmployeeID { get; set; }

    public string Name { get; set; }

    public BitmapImage Image { get; set; }

    public int NumTasks { get => Tasks.Count(); }

    public double NumHours { get => Tasks.Sum(x => x.EstimatedTime.TotalHours); }

    public IEnumerable<TaskModel> Tasks => Model.Categories
        .SelectMany(x => x.EmployeeCategoryDictionary.GetValueOrDefault(EmployeeID)?.Tasks ?? Enumerable.Empty<TaskModel>());

    private TasksByUserModel Model;

    public TasksByUserEmployeeHeader(Guid employeeID, string name, BitmapImage image, TasksByUserModel model)
    {
        EmployeeID = employeeID;
        Name = name;
        Image = image;
        Model = model;
    }
}

public class TasksByUserEmployeeCategory
{
    public Guid EmployeeID { get; set; }

    public List<TaskModel> Tasks { get; set; } = new();

    public TasksByUserEmployeeCategory(Guid employeeID)
    {
        EmployeeID = employeeID;
    }
}

public class TasksByUserCategory
{
    public string Category { get; set; }

    public IEnumerable<TasksByUserEmployeeCategory> EmployeeCategories => EmployeeCategoryDictionary.Values;

    public Dictionary<Guid, TasksByUserEmployeeCategory> EmployeeCategoryDictionary { get; set; } = new();

    public TasksByUserCategory(string category)
    {
        Category = category;
    }
}

public class TasksByUserModel
{
    public List<TasksByUserEmployeeHeader> SectionHeaders { get; set; } = new();

    public List<TasksByUserCategory> Categories { get; set; } = new();
}

public partial class TasksByUserControl : UserControl, INotifyPropertyChanged, ITaskControl
{
    private static readonly BitmapImage anonymous = PRSDesktop.Resources.anonymous.AsBitmapImage();

    public TasksByUserModel Model { get; set; }

    private ILookup<Guid, Guid> TeamEmployees;

    private Dictionary<Guid, EmployeeModel> Employees;

    private KanbanViewMode _mode;

    private bool bPopulating;

    public KanbanViewMode Mode
    {
        get => _mode;
        set
        {
            _mode = value;
            OnPropertyChanged();
        }
    }

    public TasksByUserControl()
    {
        InitializeComponent();
    }

    #region INotifyPropertyChanged

    public event PropertyChangedEventHandler? PropertyChanged;

    // Create the OnPropertyChanged method to raise the event
    // The calling member's name will be used as the parameter.
    protected void OnPropertyChanged([CallerMemberName] string? name = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
    }

    #endregion

    #region Setup

    private void LoadEmployees()
    {
        var empfilter = LookupFactory.DefineFilter<Employee>();

        var results = Client.QueryMultiple(
            new KeyedQueryDef<Employee>(
                LookupFactory.DefineFilter<Employee>(),
                new Columns<Employee>(x => x.ID)
                    .Add(x => x.Name)
                    .Add(x => x.Thumbnail.ID),
                new SortOrder<Employee>(x => x.Name)),
            new KeyedQueryDef<Team>(
                LookupFactory.DefineFilter<Team>(),
                new Columns<Team>(x => x.ID)
                    .Add(x => x.Name),
                new SortOrder<Team>(x => x.Name)),
            new KeyedQueryDef<EmployeeTeam>(
                LookupFactory.DefineFilter<EmployeeTeam>(),
                new Columns<EmployeeTeam>(x => x.EmployeeLink.ID)
                    .Add(x => x.TeamLink.ID)));

        TeamEmployees = results.Get<EmployeeTeam>().ToLookup<EmployeeTeam, Guid, Guid>(x => x.TeamLink.ID, x => x.EmployeeLink.ID);
        Employees = results.GetObjects<Employee>().ToDictionary(
            x => x.ID,
            x => new EmployeeModel(x.ID, x.Name, x.Thumbnail.ID, null));

        var teams = results.GetObjects<Team>().ToDictionary(x => x.ID, x => x.Name);
        SelectedTeams.ItemsSource = teams;
        foreach (var team in Host.KanbanSettings.UserSettings.SelectedTeams)
        {
            SelectedTeams.SelectedItems.Add(teams.Where(x => x.Key == team));
        }
    }

    private void PopulateEmployees()
    {
        bPopulating = true;
        try
        {
            var availableemployees = new List<Guid>();
            foreach (var team in SelectedTeams.SelectedItems.Select(v => (KeyValuePair<Guid, string>)v))
                availableemployees.AddRange(TeamEmployees[team.Key].Where(x => !availableemployees.Contains(x)));

            SelectedEmployees.ItemsSource = Employees.Where(x => availableemployees.Contains(x.Key));
            SelectedEmployees.SelectedItems.Clear();
            foreach (var employee in Host.KanbanSettings.UserSettings.SelectedEmployees.Where(x => availableemployees.Contains(x)))
                SelectedEmployees.SelectedItems.Add(Employees.FirstOrDefault(x => Equals(x.Key, employee)));
        }
        catch (Exception e)
        {
        }

        bPopulating = false;
    }

    private void SetupToolbar()
    {
        IncludeCompleted.Visibility = Security.IsAllowed<CanHideTaskCompletedColumn>() ? Visibility.Visible : Visibility.Collapsed;
        IncludeCompleted.IsChecked = IncludeCompleted.Visibility == Visibility.Visible ? Host.KanbanSettings.UserSettings.IncludeCompleted : true;
        IncludeObserved.IsChecked = Host.KanbanSettings.UserSettings.IncludeObserved;
        IncludeManaged.IsChecked = Host.KanbanSettings.UserSettings.IncludeManaged;
        ViewType.SelectedIndex = Host.KanbanSettings.UserSettings.CompactView ? 1 : 0;
    }

    private void PopulateKanbanTypes()
    {
        TaskType.Items.Add("");
        foreach (var kanbanType in Host.KanbanTypes)
        {
            TaskType.Items.Add(kanbanType);
        }
    }

    public void Setup()
    {
        SetupToolbar();

        SplitPanel.AnchorWidth = Host.KanbanSettings.UserSettings.AnchorWidth;
        TeamsRow.Height = new GridLength(Host.KanbanSettings.UserSettings.TeamsHeight);

        LoadEmployees();
        PopulateEmployees();

        Mode = Host.KanbanSettings.StatusSettings.CompactView ? KanbanViewMode.Compact : KanbanViewMode.Full;

        PopulateKanbanTypes();
    }

    #endregion

    #region Refresh

    private Filter<KanbanSubscriber> GetKanbanSubscriberFilter()
    {
        var filter = new Filter<KanbanSubscriber>(c => c.Kanban.Closed).IsEqualTo(DateTime.MinValue)
            .And(x => x.Kanban.Locked).IsEqualTo(false);

        var privateFilter = new Filter<KanbanSubscriber>(x => x.Kanban.Private).IsEqualTo(false);
        if (App.EmployeeID != Guid.Empty)
        {
            privateFilter = privateFilter.Or(x => x.Employee.ID).IsEqualTo(App.EmployeeID);
        }
        filter.And(privateFilter);

        if (Host.Job != null)
        {
            if (Host.Job.ID != Guid.Empty)
                filter = filter.And(c => c.Kanban.JobLink.ID).IsEqualTo(Host.Job.ID);
            else
                filter = filter.And(c => c.Kanban.JobLink.ID).None();
        }

        if (!Host.KanbanSettings.UserSettings.IncludeCompleted)
            filter = filter.And(new Filter<KanbanSubscriber>(x => x.Kanban.Completed).IsEqualTo(DateTime.MinValue));

        var emps = Employees.Where(x => Host.KanbanSettings.UserSettings.SelectedEmployees.Contains(x.Key));

        filter = filter.And(c => c.Employee.ID).InList(emps.Select(x => x.Key).ToArray());
        if (!Host.KanbanSettings.UserSettings.IncludeObserved)
        {
            if (Host.KanbanSettings.UserSettings.IncludeManaged)
                filter = filter.And(new Filter<KanbanSubscriber>(x => x.Manager).IsEqualTo(true).Or(x => x.Assignee).IsEqualTo(true));
            else
                filter = filter.And(x => x.Assignee).IsEqualTo(true);
        }
        return filter;
    }

    private void ReloadColumns()
    {
        Model.SectionHeaders.Clear();
        foreach (var employeeID in Host.KanbanSettings.UserSettings.SelectedEmployees)
        {
            if (Employees.TryGetValue(employeeID, out var employee))
            {
                Model.SectionHeaders.Add(new TasksByUserEmployeeHeader(employeeID, employee.Name, employee.Image ?? anonymous, Model));
            }
        }
    }

    public void Refresh()
    {
        var categoryOrder = new Dictionary<string, int>
            {
                { Kanban.OPEN, 0 },
                { Kanban.INPROGRESS, 1 },
                { Kanban.WAITING, 2 },
                { Kanban.COMPLETE, 3 }
            };
        var filter = GetKanbanSubscriberFilter();

        using (new WaitCursor())
        {
            var kanbans = new Client<KanbanSubscriber>().Query(
                filter,
                new Columns<KanbanSubscriber>
                (
                    x => x.Kanban.ID,
                    x => x.Kanban.DueDate,
                    x => x.Kanban.Completed,
                    //x => x.Kanban.Description,
                    x => x.Kanban.Summary,
                    x => x.Kanban.Category,
                    x => x.Kanban.EmployeeLink.ID,
                    x => x.Kanban.EmployeeLink.Name,
                    x => x.Kanban.ManagerLink.ID,
                    x => x.Kanban.ManagerLink.Name,
                    x => x.Kanban.Notes,
                    x => x.Kanban.Title,
                    x => x.Kanban.JobLink.ID,
                    x => x.Kanban.JobLink.JobNumber,
                    x => x.Kanban.JobLink.Name,
                    x => x.Kanban.Type.ID,
                    x => x.Kanban.Type.Code,
                    x => x.Kanban.Number,
                    x => x.Kanban.Attachments,
                    x => x.Kanban.Locked,
                    x => x.Employee.ID,
                    x => x.Kanban.EstimatedTime
                ),
                new SortOrder<KanbanSubscriber>(x => x.Kanban.DueDate) { Direction = SortDirection.Ascending }
            );
            var models = CreateModels(kanbans.ToObjects<KanbanSubscriber>()).ToList();

            ReloadColumns();

            AllTasks = models.OrderBy(x => categoryOrder[x.Category]).ThenBy(x => x.DueDate).ToList();
            FilterKanbans();
        }
    }

    private void FilterKanbans()
    {
        var categoryOrder = new Dictionary<string, int>
            {
                { Kanban.OPEN, 0 },
                { Kanban.INPROGRESS, 1 },
                { Kanban.WAITING, 2 },
                { Kanban.COMPLETE, 3 }
            };

        IEnumerable<TaskModel> filtered = AllTasks;
        if (TaskType.SelectedItem is KanbanType kanbanType)
        {
            filtered = filtered.Where(x => x.Type.ID == kanbanType.ID);
        }
        if (!string.IsNullOrWhiteSpace(Search.Text))
        {
            var searches = Search.Text.Split();
            filtered = filtered.Where(x => x.Search(searches));
        }

        var categories = new Dictionary<string, TasksByUserCategory>();

        foreach (var task in filtered)
        {
            if(!categories.TryGetValue(task.Category, out var category))
            {
                category = new TasksByUserCategory(task.Category);
                categories.Add(task.Category, category);
            }

            if(!category.EmployeeCategoryDictionary.TryGetValue(task.EmployeeCategory, out var employeeCategory))
            {
                employeeCategory = new TasksByUserEmployeeCategory(task.EmployeeCategory);
                category.EmployeeCategoryDictionary.Add(task.EmployeeCategory, employeeCategory);
            }

            employeeCategory.Tasks.Add(task);
            if (task.Checked)
            {
                SelectedTasks.Add(task);
            }
        }

        Model.Categories.AddRange(categories.Values.OrderBy(x => categoryOrder[x.Category]));
    }

    private IEnumerable<TaskModel> CreateModels(IEnumerable<KanbanSubscriber> subscribers)
    {
        foreach(var subscriber in subscribers)
        {
            var kanban = subscriber.Kanban;

            var empValid = Entity.IsEntityLinkValid<KanbanSubscriber, EmployeeLink>(x => x.Kanban.EmployeeLink, row);
            var mgrValid = Entity.IsEntityLinkValid<KanbanSubscriber, EmployeeLink>(x => x.Kanban.ManagerLink, row);

            var completed = row.Get<KanbanSubscriber, DateTime>(e => e.Kanban.Completed);
            var locked = row.Get<KanbanSubscriber, bool>(e => e.Kanban.Locked);
            var typeID = row.Get<KanbanSubscriber, Guid>(e => e.Kanban.Type.ID);
            var typeCode = row.Get<KanbanSubscriber, string>(e => e.Kanban.Type.Code);
            var job = row.Get<KanbanSubscriber, string>(x => x.Kanban.JobLink.JobNumber);

            var model = new TaskModel();

            model.Title = kanban.Title;
            model.ID = kanban.ID;
            model.Description = kanban.Summary ?? "";
            model.EmployeeCategory = subscriber.Employee.ID;
            model.Category = kanban.Category;

            if (model.Category.IsNullOrWhiteSpace())
                model.Category = "Open";

            var colour = subscriber.Employee.ID == kanban.EmployeeLink.ID
                ? TaskModel.KanbanColor(
                    kanban.DueDate,
                    kanban.Completed)
                : subscriber.Employee.ID == kanban.ManagerLink.ID
                    ? Color.Silver
                    : Color.Plum;
            if (kanban.Locked)
            {
                colour = colour.MixColors(0.5F, Color.White);
            }
            model.Color = System.Windows.Media.Color.FromArgb(colour.A, colour.R, colour.G, colour.B);

            model.Attachments = kanban.Attachments > 0;
            model.DueDate = kanban.DueDate;
            model.CompletedDate = kanban.Completed;
            model.Locked = kanban.Locked;
            model.EstimatedTime = kanban.EstimatedTime;

            var notes = new List<List<string>> { new() };
            var kanbanNotes = kanban.Notes;
            if (kanbanNotes != null)
            {
                foreach (var line in kanbanNotes)
                {
                    if (line == "===================================")
                    {
                        notes.Add(new());
                    }
                    else
                    {
                        notes.Last().Add(line);
                    }
                }
            }
            model.Notes = string.Join("\n===================================\n", notes.Reverse<List<string>>().Select(x => string.Join('\n', x)));

            model.EmployeeID = kanban.EmployeeLink.ID;
            model.ManagerID = kanban.ManagerLink.ID;

            var employeeString = kanban.EmployeeLink.ID == subscriber.Employee.ID
                ? ""
                : kanban.EmployeeLink.ID == Guid.Empty
                    ? " to (Unallocated)"
                    : " to " + kanban.EmployeeLink.Name;

            var managerString = kanban.ManagerLink.ID == Guid.Empty || kanban.ManagerLink.ID == subscriber.Employee.ID
                ? ""
                : " by " + kanban.ManagerLink.Name;

            model.AssignedTo = !string.IsNullOrEmpty(employeeString) || !managerString.IsNullOrWhiteSpace()
                ? $"Assigned{employeeString}{managerString}"
                : "";

            model.JobID = kanban.JobLink.ID;
            model.JobNumber = kanban.JobLink.JobNumber?.Trim() ?? "";
            model.JobName = kanban.JobLink.Name;
            model.Checked = SelectedTasks.Any(x => x.ID == model.ID);
            model.Type = new KanbanType
            {
                ID = typeID,
                Code = typeCode
            };
            model.Number = kanban.Number;

            yield return model;
        }
    }

    #endregion

    #region Kanban

    private readonly List<TaskModel> SelectedTasks = new();
    private List<TaskModel> AllTasks { get; set; } = new();

    private void DoEdit(TaskModel task)
    {
        var result = Host.EditReferences(new[] { task });
        if (result)
        {
            Refresh();
        }
    }

    private void EditTask_Executed(object sender, ExecutedRoutedEventArgs e)
    {
        if (e.Parameter is not TaskModel model) return;

        DoEdit(model);
    }

    private void OpenTaskMenu_Executed(object sender, ExecutedRoutedEventArgs e)
    {
        if (e.Parameter is not KanbanResources.OpenTaskMenuCommandArgs args) return;

        Host.PopulateMenu(this, args.Model, args.Menu);
    }

    private void SelectTask_Executed(object sender, ExecutedRoutedEventArgs e)
    {
        if (e.Parameter is not TaskModel model) return;

        if (!SelectedTasks.Remove(model))
        {
            SelectedTasks.Add(model);
        }
    }

    private void CommandBinding_CanExecute(object sender, CanExecuteRoutedEventArgs e)
    {
        e.CanExecute = true;
    }

    #endregion

    #region ITaskControl

    public ITaskHost Host { get; set; }

    public KanbanViewType KanbanViewType => KanbanViewType.User;

    public bool IsReady { get; set; }

    public string SectionName => "Tasks By User";

    public DataModel DataModel(Selection selection)
    {
        var ids = SelectedModels().Select(x => x.ID).ToArray();
        return new AutoDataModel<Kanban>(new Filter<Kanban>(x => x.ID).InList(ids));
    }

    public IEnumerable<TaskModel> SelectedModels(TaskModel? sender = null)
    {
        if (sender is null)
        {
            return SelectedTasks;
        }
        else
        {
            var result = SelectedTasks.ToList();
            if (!result.Contains(sender))
            {
                result.Add(sender);
            }
            return result;
        }
    }

    #endregion

    #region Settings

    private void SaveSettings()
    {
        Host.KanbanSettings.UserSettings.AnchorWidth = SplitPanel.AnchorWidth;

        Host.KanbanSettings.UserSettings.TeamsHeight = SelectedTeams.ActualHeight;

        var teams = SelectedTeams.SelectedItems.Select(x => ((KeyValuePair<Guid, string>)x).Key);
        Host.KanbanSettings.UserSettings.SelectedTeams = teams.ToArray();

        var emps = SelectedEmployees.SelectedItems.Select(x => ((KeyValuePair<Guid, string>)x).Key);
        emps = emps.Where(e => TeamEmployees.Any(t => t.Contains(e)));
        Host.KanbanSettings.UserSettings.SelectedEmployees = emps.ToArray();

        Host.KanbanSettings.UserSettings.IncludeCompleted = IncludeCompleted.IsChecked == true;
        Host.KanbanSettings.UserSettings.IncludeObserved = IncludeObserved.IsChecked == true;
        Host.KanbanSettings.UserSettings.IncludeManaged = IncludeManaged.IsChecked == true;

        Host.SaveSettings();
    }

    private void SplitPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
    {
        if (!IsReady || Equals(Host.KanbanSettings.UserSettings.AnchorWidth, e.AnchorWidth))
            return;
        SaveSettings();
    }

    private void SelectedTeams_ItemChecked(object sender, ItemCheckedEventArgs e)
    {
        if (!IsReady)
            return;
        PopulateEmployees();
        SaveSettings();
        Refresh();
    }

    private void SelectedTeams_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (!IsReady || Equals(Host.KanbanSettings.UserSettings.TeamsHeight, SelectedTeams.ActualHeight))
            return;
        SaveSettings();
    }

    private void EmployeesSelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (!IsReady || bPopulating)
            return;
        SaveSettings();
        Refresh();
    }

    #endregion

    private void Export_Click(object sender, RoutedEventArgs e)
    {

    }

    private void IncludeCompleted_Checked(object sender, RoutedEventArgs e)
    {

    }

    private void IncludeObserved_Checked(object sender, RoutedEventArgs e)
    {

    }

    private void IncludeManaged_Checked(object sender, RoutedEventArgs e)
    {

    }

    private void ViewType_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {

    }

    private void TaskType_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {

    }

    private void Search_KeyUp(object sender, KeyEventArgs e)
    {

    }

    private void ItemsControl_DragOver(object sender, DragEventArgs e)
    {

    }

    private void ItemsControl_Drop(object sender, DragEventArgs e)
    {

    }
}