prs/prs.desktop/Grids/KanbanGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using NPOI.SS.Formula.Functions;

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

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

            Options.Add(DynamicGridOption.SelectColumns);
            Options.Add(DynamicGridOption.FilterRows);
            

            OnCustomiseEditor += CustomiseEditor;
            OnBeforeSave += BeforeSave;
        }

        public Guid MyID { get; set; } = CoreUtils.FullGuid;

        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 == MyID && kanban.ManagerLink.ID == MyID;
                    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 (!MyID.Equals(kanban.ManagerLink.ID) && !MyID.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, Kanban[] items)
        {
            EnsureAssignee(editor, items.FirstOrDefault());
            EnsureAllocator(editor, items.FirstOrDefault());
        }

        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 void AfterLoad(IDynamicEditorForm editor, Kanban[] kanbans)
        {
            base.AfterLoad(editor, kanbans);
            //EnsureAssignee(editor, kanbans.FirstOrDefault());
            //EnsureAllocator(editor, kanbans.FirstOrDefault());

            if (MyID == CoreUtils.FullGuid)
            {
                var row = new Client<Employee>()
                    .Query(new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(ClientFactory.UserGuid), new Columns<Employee>(x => x.ID)).Rows
                    .FirstOrDefault();
                if (row != null)
                    MyID = row.Get<Employee, Guid>(x => x.ID);
            }

            //if (kanbans.FirstOrDefault().ID == Guid.Empty)
            //    ReloadForms<Kanban, KanbanForm, KanbanTypeForm>(editor, kanbans.FirstOrDefault(), x => x.Type.ID, kanbans.FirstOrDefault().Type.ID);
        }

        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 = (Guid)value == items.FirstOrDefault()?.ManagerLink.ID &&
                              items.FirstOrDefault()?.ManagerLink.UserLink.ID == ClientFactory.UserGuid;
                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 == 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, MyID);
                    managerEditor.SetValue(managerEditor.ColumnName, MyID);

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

            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,
            Action<CoreTable?, Exception?> action)
        {
            if (Host.ParentID != Guid.Empty)
                criteria.Add(new Filter<Kanban>(x => x.JobLink.ID).IsEqualTo(Host.ParentID));
            base.Reload(criteria, columns, ref sort, action);
        }

        #region ITaskControl Support

        public KanbanView KanbanView => KanbanView.List;

        public ITaskHost Host { get; set; }

        public bool IsReady { get; set; }

        public string SectionName => "Task List";

        public DataModel DataModel(Selection selection)
        {
            return new AutoDataModel<Kanban>(new Filter<Kanban>(x => x.ID).IsEqualTo(Guid.Empty));
        }

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

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

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

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

        #endregion
    }
}