prs/prs.desktop/Panels/Tasks/TaskGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;

namespace PRSDesktop;

public class TaskGrid : DynamicDataGrid<Kanban>, ITaskControl, IDefaultGrid
{
    public TaskGrid()
    {
        ActionColumns.Add(new DynamicImageColumn(PRSDesktop.Resources.menu.AsBitmapImage(), FormMenuClick));

        HiddenColumns.Add(x => x.EmployeeLink.ID);

        OnCustomiseEditor += CustomiseEditor;
        OnBeforeSave += BeforeSave;
    }

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        base.DoReconfigure(options);

        options.SelectColumns = true;
        options.FilterRows = true;
        options.RecordCount = true;
        options.PageSize = 1000;
    }

    protected override void DoValidate(Kanban[] items, List<string> errors)
    {
        base.DoValidate(items, errors);

        if (Host.Properties.RequireTaskTypes && items.Any(x => x.Type.ID == Guid.Empty))
        {
            errors.Add("[Task Type] may not be blank!");
        }
    }

    private bool FormMenuClick(CoreRow? row)
    {
        if (row is null)
            return false;

        var kanbanID = row.Get<Kanban, Guid>(x => x.ID);

        var menu = new ContextMenu();

        DynamicGridUtils.PopulateFormMenu<KanbanForm, Kanban, KanbanLink>(menu, kanbanID, () => row.ToObject<Kanban>());

        menu.IsOpen = true;

        return false;
    }

    private void CustomiseEditor(IDynamicEditorForm sender, Kanban[]? items, DynamicGridColumn column, BaseEditor editor)
    {
        var kanban = items?.FirstOrDefault();
        if (kanban is null) return;

        var bFullControl = IsFullControl(new[] { kanban });
        bool? enabled = null;
        switch (column.ColumnName)
        {
            case "Private":
                enabled = kanban.EmployeeLink.ID == App.EmployeeID && kanban.ManagerLink.ID == App.EmployeeID;
                break;
            case "Description":
                enabled = kanban.ID == Guid.Empty || (bFullControl && !kanban.Private);
                break;
            case "EmployeeLink.ID":
                enabled = bFullControl && !kanban.Private;
                break;
            case "ManagerLink.ID":
                enabled = bFullControl && !kanban.Private;
                break;
            case "Category":
                enabled = bFullControl && !kanban.Private;
                break;
            case "Closed":
                enabled = bFullControl || Security.IsAllowed<CanCloseOthersTasks>();
                break;
        }
        if(enabled != null)
        {
            editor.Editable = enabled.Value ? Editable.Enabled : Editable.Disabled;
        }
    }

    private bool IsFullControl(Kanban[] kanbans)
    {
        foreach (var kanban in kanbans)
        {
            if (!App.EmployeeID.Equals(kanban.ManagerLink.ID) && !App.EmployeeID.Equals(kanban.EmployeeLink.ID))
            {
                // If you can change others tasks, IsFullControl is true - but we don't check at the beginning of the function
                // to save checking security tokens every time.
                return Security.IsAllowed<CanChangeOthersTasks>();
            }
        }
        return true;
    }

    private void BeforeSave(IDynamicEditorForm editor, BaseObject[] items)
    {
        EnsureAssignee(editor, items.FirstOrDefault() as Kanban);
        EnsureAllocator(editor, items.FirstOrDefault() as Kanban);
    }

    protected override void SelectPage(object sender, BaseObject[]? items)
    {
        base.SelectPage(sender, items);
        var tab = sender as TabItem;
        if(tab?.Content is KanbanSubscriberGrid grid)
        {
            grid.EnsureAssignee();
            grid.EnsureAllocator();
        }
    }

    protected override Dictionary<string, object?> EditorValueChanged(IDynamicEditorForm editor, Kanban[] items, string name, object value)
    {
        var result = base.EditorValueChanged(editor, items, name, value);

        if (name == "Type.ID")
        {
            //ReloadForms<Kanban, KanbanForm, KanbanTypeForm>(editor, items.FirstOrDefault(), x => x.Type.ID,
            //    value != null ? (Guid)value : Guid.Empty);
        }
        else if (name == "EmployeeLink.ID")
        {
            EnsureAssignee(editor, items.FirstOrDefault());
            var enabled = items.FirstOrDefault()?.ManagerLink.UserLink.ID == ClientFactory.UserGuid &&
                          (Guid)(value ?? Guid.Empty) == items.FirstOrDefault()?.ManagerLink.ID;
            editor.FindEditor("Private").IsEnabled = enabled;
        }
        else if (name == "ManagerLink.ID")
        {
            EnsureAllocator(editor, items.FirstOrDefault());
            var enabled = items.FirstOrDefault()?.EmployeeLink.UserLink.ID == ClientFactory.UserGuid &&
                          (Guid)(value ?? Guid.Empty) == items.FirstOrDefault()?.EmployeeLink.ID;
            editor.FindEditor("Private").IsEnabled = enabled;
        }
        else if (name == "Private")
        {
            var enabled = !Equals(value, true);
            var employeeEditor = editor.FindEditor("EmployeeLink.ID");
            var managerEditor = editor.FindEditor("ManagerLink.ID");
            employeeEditor.IsEnabled = enabled;
            managerEditor.IsEnabled = enabled;
            if (!enabled)
            {
                employeeEditor.SetValue(employeeEditor.ColumnName, App.EmployeeID);
                managerEditor.SetValue(managerEditor.ColumnName, App.EmployeeID);

                foreach(var item in items)
                {
                    item.EmployeeLink.ID = App.EmployeeID;
                    item.ManagerLink.ID = App.EmployeeID;
                }
            }
        }

        return result;
    }

    private static KanbanSubscriberGrid? EnsurePage(IDynamicEditorForm editor, Kanban item)
    {
        var type = typeof(IDynamicOneToManyGrid<,>).MakeGenericType(typeof(Kanban), typeof(KanbanSubscriber));
        var page = editor.Pages.FirstOrDefault(x => x.GetType().GetInterfaces().Contains(type)) as KanbanSubscriberGrid;

        if (page != null && !page.Ready)
            page.Load(item, null);

        return page;
    }

    private static void EnsureAssignee(IDynamicEditorForm editor, Kanban? kanban)
    {
        if (kanban is null) return;

        var page = EnsurePage(editor, kanban);
        if (page is null) return;

        page.EnsureAssignee();
    }

    private static void EnsureAllocator(IDynamicEditorForm editor, Kanban? kanban)
    {
        if (kanban is null) return;

        var page = EnsurePage(editor, kanban);
        if (page is null) return;

        page.EnsureAllocator();
    }

    protected override void Reload(
    	Filters<Kanban> criteria, Columns<Kanban> columns, ref SortOrder<Kanban>? sort,
    	CancellationToken token, Action<CoreTable?, Exception?> action)
    {
        if (Host.Master != null)
            criteria.Add(new Filter<Kanban>(x => x.JobLink.ID).IsEqualTo(Host.Master.ID));
        
        base.Reload(criteria, columns, ref sort, token, action);
    }

    #region ITaskControl Support

    public KanbanViewType KanbanViewType => KanbanViewType.List;

    public ITaskHost Host { get; set; }

    public bool IsReady { get; set; }

    public string SectionName => "Task List";

    public DataModel DataModel(Selection selection)
    {
        var ids = ExtractValues<Guid>(x => x.ID, selection);
        if (!ids.Any())
            ids = [Guid.Empty];
        return new AutoDataModel<Kanban>(new Filter<Kanban>(x => x.ID).InList(ids.ToArray()));
    }

    public void Refresh()
    {
        Refresh(false, true);
    }

    public void Refresh(bool resetselection)
    {
        Refresh(false, true);
        // reset selected rows here
    }

    public void Setup()
    {
        FilterComponent.SetSettings(Host.KanbanSettings.Filters, false);

        Refresh(true, false);
    }

    public IEnumerable<TaskModel> SelectedModels(TaskModel? sender = null)
    {
        MessageBox.Show("TaskListControl.SelectedModels() is not Implemented!");
        return Array.Empty<TaskModel>();
    }

    protected override bool CanCreateItems()
    {
        return base.CanCreateItems() &&  (Host.Master?.ID ?? Guid.Empty) != Guid.Empty;
    }

    public override Kanban CreateItem()
    {
        var result = base.CreateItem();
        result.JobLink.ID = Host.Master?.ID ?? Guid.Empty;
        result.JobLink.Synchronise(Host.Master ?? new Job());
        return result;
    }

    #endregion
}