prs/prs.desktop/Panels/Tasks/KanbanSubscriberGrid.cs

using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;

namespace PRSDesktop
{
    public class KanbanSubscriberGrid : DynamicOneToManyGrid<Kanban, KanbanSubscriber>
    {
        protected override void Init()
        {
            base.Init();

            HiddenColumns.Add(x => x.Manager);
            HiddenColumns.Add(x => x.Assignee);
            HiddenColumns.Add(x => x.Observer);
            HiddenColumns.Add(x => x.Employee.ID);

            AddButton("Select Team", PRSDesktop.Resources.team.AsBitmapImage(), SelectTeamClick);
        }

        protected override void DoReconfigure(FluentList<DynamicGridOption> options)
        {
            base.DoReconfigure(options);
            options.AddRange(DynamicGridOption.RecordCount, DynamicGridOption.AddRows, DynamicGridOption.DeleteRows, DynamicGridOption.SelectColumns,
                DynamicGridOption.MultiSelect);
        }

        protected override KanbanSubscriber CreateItem()
        {
            var result = base.CreateItem();
            result.Observer = true;
            return result;
        }

        protected override void AfterLoad(IDynamicEditorForm editor, KanbanSubscriber[] items)
        {
            base.AfterLoad(editor, items);

            EnsureAssignee();
            EnsureAllocator();
        }

        protected override bool CanDeleteItems(params CoreRow[] rows)
        {
            var result = base.CanDeleteItems(rows);
            if (result)
            {
                result = !rows.Any(r => r.Get<KanbanSubscriber, bool>(c => c.Manager) || r.Get<KanbanSubscriber, bool>(c => c.Assignee));
                if (!result)
                    MessageBox.Show("You cannot delete an Assignee or Manager!");
            }

            return result;
        }

        private bool SelectTeamClick(Button arg1, CoreRow[] arg2)
        {
            var dlg = new MultiSelectDialog<Team>(LookupFactory.DefineFilter<Team>(), LookupFactory.DefineColumns<Team>());
            if (dlg.ShowDialog())
            {
                var observers = Items.Where(x => x.Observer).Select(x => x.Employee.ID).ToArray();

                var mr = MessageBoxResult.No;
                if (observers.Any())
                    mr = MessageBox.Show("Do you want to clear the existing subscriber list?", "Clear Subscribers", MessageBoxButton.YesNoCancel,
                        MessageBoxImage.Question);
                if (mr == MessageBoxResult.Cancel) return false;

                if (mr == MessageBoxResult.Yes)
                {
                    Items.RemoveAll(x => !x.Manager && !x.Assignee);
                    foreach (var item in Items)
                        item.Observer = false;
                }

                var emps = new Client<EmployeeTeam>().Query(
                    new Filter<EmployeeTeam>(x => x.TeamLink.ID).InList(dlg.IDs()),
                    new Columns<EmployeeTeam>(x => x.EmployeeLink.ID, x => x.EmployeeLink.Code, x => x.EmployeeLink.Name),
                    new SortOrder<EmployeeTeam>(x => x.EmployeeLink.Name)
                );

                foreach (var row in emps.Rows)
                {
                    var membership = row.ToObject<EmployeeTeam>();

                    var subscriber = Items.FirstOrDefault(x => x.Employee.ID == membership.EmployeeLink.ID);
                    if (subscriber == null)
                    {
                        subscriber = new KanbanSubscriber();
                        Items.Add(subscriber);
                    }

                    subscriber.Employee.ID = membership.EmployeeLink.ID;
                    subscriber.Employee.Synchronise(membership.EmployeeLink);
                    subscriber.Observer = true;
                }

                return true;
            }

            return false;
        }

        private void LoadEmployee(Guid empid, KanbanSubscriber subscriber)
        {
            var emp = new Client<Employee>().Load(new Filter<Employee>(x => x.ID).IsEqualTo(empid)).FirstOrDefault();
            if (emp != null)
                subscriber.Employee.Synchronise(emp);
        }

        private KanbanSubscriber? EnsureSubscriber(EmployeeLink employee)
        {
            if (!employee.IsValid()) return null;

            var result = Items.FirstOrDefault(x => x.Employee.ID == employee.ID);
            if (result is null)
            {
                result = new KanbanSubscriber();
                result.Employee.ID = employee.ID;
                LoadEmployee(employee.ID, result);
                Items.Add(result);
            }

            return result;
        }

        public void EnsureAssignee()
        {
            var subscriber = EnsureSubscriber(Item.EmployeeLink);
            foreach (var item in Items)
                item.Assignee = false;
            if (subscriber != null)
                subscriber.Assignee = true;
            Items.RemoveAll(x => !x.Assignee && !x.Manager && !x.Observer);
            Refresh(false, true);
        }

        public void EnsureAllocator()
        {
            var subscriber = EnsureSubscriber(Item.ManagerLink);
            foreach (var item in Items)
                item.Manager = false;
            if (subscriber != null)
                subscriber.Manager = true;
            Items.RemoveAll(x => !x.Assignee && !x.Manager && !x.Observer);
            Refresh(false, true);
        }
    }
}