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

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using Syncfusion.UI.Xaml.TreeGrid;
using Syncfusion.Windows.Controls.Gantt;
using Syncfusion.Windows.Controls.Grid;
using GridSelectionMode = Syncfusion.Windows.Controls.Grid.GridSelectionMode;
using SelectionChangedEventArgs = System.Windows.Controls.SelectionChangedEventArgs;

namespace PRSDesktop
{
    /// <summary>
    ///     Interaction logic for TaskPlannerControl.xaml
    /// </summary>
    public partial class TaskPlannerControl : UserControl, ITaskControl
    {

        private enum Suppress
        {
            This
        }
    
        private CoreTable _kanbans;

        private CoreTable _relationships;
        private readonly ObservableCollection<Resource> _resources = new();

        private CoreTable _stages;


        private readonly ObservableCollection<GanttTask> _tasks = new();

        private bool bLoading;

        public TaskPlannerControl()
        {
            using (new EventSuppressor(Suppress.This))
            {
                InitializeComponent();
                Gantt.ItemsSource = _tasks;
                Gantt.ResourceCollection = _resources;
            }
        }


        public void Setup()
        {
            LoadKanbanTypes();
        }

        private void LoadKanbanTypes()
        {
            using (new EventSuppressor(Suppress.This))
            {
                var types = new Dictionary<Guid, string>
                {
                    { CoreUtils.FullGuid, "All Task Types" },
                    { Guid.Empty, "Uncategorized Tasks" }
                };
                new Client<KanbanType>().Query(new Filter<KanbanType>(x => x.Hidden).IsEqualTo(false))
                    .IntoDictionary<Kanban, Guid>(types, x => x.ID, x => x.Description);
                SelectedType.ItemsSource = types;
            }
        }

        public void Refresh(bool resetselection)
        {
            Refresh();
        }

        public void Shutdown()
        {
        }

        private void Gantt_TemplateApplied(object sender, TemplateAppliedEventArgs args)
        {
            if (Gantt.GanttGrid != null)
            {
                //Gantt.GanttGrid.Model.Options.ListBoxSelectionMode = GridSelectionMode.One;
                //Gantt.GanttGrid.Model.Sizer.AllowAutoCalculateSize = true;
                //Gantt.GanttGrid.Model.Sizer.ListenToSizeChanged = true;
                //Gantt.GanttGrid.Model.Options.ColumnSizer = GridControlLengthUnitType.Star;
                Gantt.GanttGrid.RowHeaderWidth = 0;
                Gantt.GanttGrid.ShowRowHeader = false;

                CreateGanttColumns();

                //Gantt.GanttGrid.ReadOnly = true;
            }
        }

        private void CreateGanttColumns()
        {
            if (Gantt.GanttGrid == null)
                return;
            Gantt.GanttGrid.Columns.Clear();
            //Gantt.GanttGrid.Columns.Add(new Syncfusion.Windows.Controls.Grid.GridTreeColumn("TaskId") { Width = 60F, HeaderText = "#", StyleInfo = new Syncfusion.Windows.Controls.Grid.GridStyleInfo() { VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center } });
            Gantt.GanttGrid.Columns.Add(new TreeGridTextColumn()
            {
                MappingName = "TaskName",
                Width = 220F, 
                HeaderText = "Description",
                VerticalAlignment = VerticalAlignment.Center
            });
            Gantt.GanttGrid.Columns.Add(new TreeGridDateTimeColumn()
            {
                MappingName = "StartDate",
                Width = 70F, 
                HeaderText = "Start",
                VerticalAlignment = VerticalAlignment.Center
                //StyleInfo = new GridStyleInfo
                //    { VerticalAlignment = VerticalAlignment.Center, Format = "dd MMM yy", HorizontalAlignment = HorizontalAlignment.Center }
            });
            Gantt.GanttGrid.Columns.Add(new TreeGridNumericColumn()
            {
                MappingName = "Manpower",
                Width = 60F, 
                HeaderText = "Hrs",
                //StyleInfo = new GridStyleInfo { VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center }
                VerticalAlignment = VerticalAlignment.Center
            });
            Gantt.GanttGrid.Columns.Add(new TreeGridNumericColumn()
            {
                MappingName = "Percentage",
                Width = 40F, 
                HeaderText = "%",
                //StyleInfo = new GridStyleInfo
                //    { VerticalAlignment = VerticalAlignment.Center, Format = "#0.##%", HorizontalAlignment = HorizontalAlignment.Center }
                VerticalAlignment = VerticalAlignment.Center
            });
            Gantt.GanttGrid.Columns.Add(new TreeGridDateTimeColumn()
            {
                MappingName = "FinishDate",
                Width = 70F, 
                HeaderText = "Due",
                //StyleInfo = new GridStyleInfo
                //    { VerticalAlignment = VerticalAlignment.Center, Format = "dd MMM yy", HorizontalAlignment = HorizontalAlignment.Center }
                VerticalAlignment = VerticalAlignment.Center
            });
        }

        private void LoadData()
        {
            var query = new MultiQuery();

            var kanbanfilter = new Filter<Kanban>(x => x.Closed).IsEqualTo(DateTime.MinValue);
            if (Host.Master != null)
                kanbanfilter = kanbanfilter.And(x => x.JobLink.ID).IsEqualTo(Host.Master.ID);
            
            query.Add(
                new QueryDef<Kanban>(
                    kanbanfilter,
                    Columns.None<Kanban>().Add(
                        x => x.ID,
                        x => x.Created,
                        x => x.DueDate,
                        x => x.Completed,
                        x => x.Description,
                        x => x.Summary,
                        x => x.Status,
                        x => x.EmployeeLink.ID,
                        x => x.EmployeeLink.Name,
                        x => x.ManagerLink.ID,
                        x => x.Title,
                        x => x.Notes,
                        x => x.Number,
                        x => x.Attachments,
                        x => x.Type.Code,
                        x => x.StartDate,
                        x => x.EstimatedTime,
                        x => x.ActualTime,
                        x => x.Type.ID
                    ),
                    new SortOrder<Kanban>(x => x.DueDate).ThenBy(x => x.StartDate)
                ),
                typeof(Kanban)
            );

            var stagefilter = (Host.Master != null)
                ? new Filter<JobStage>(x => x.Job.ID).IsEqualTo(Host.Master.ID)
                : new Filter<JobStage>(x => x.Job.ID).All();
            
            query.Add(
                new QueryDef<JobStage>(
                    stagefilter,
                    null,
                    null
                ),
                typeof(JobStage)
            );

            var relfilter = (Host.Master != null)
                ? new Filter<KanbanRelationship>(x => x.Parent.ID).IsEqualTo(Host.Master.ID)
                : new Filter<KanbanRelationship>(x => x.Parent.ID).All();
            
            query.Add(
                new QueryDef<KanbanRelationship>(
                    relfilter,
                    Columns.None<KanbanRelationship>().Add(
                        x => x.ID,
                        x => x.Predecessor.ID,
                        x => x.Successor.ID,
                        x => x.Type,
                        x => x.Parent.ID
                    ),
                    null
                ),
                typeof(KanbanRelationship)
            );

            query.Query();
            _kanbans = query.Get(typeof(Kanban));
            _stages = query.Get(typeof(JobStage));
            _relationships = query.Get(typeof(KanbanRelationship));
        }

        public void Refresh()
        {
            bLoading = true;
            using (new WaitCursor())
            {
                try
                {
                    LoadData();

                    _tasks.Clear();

                    var startmarker = new GanttTask
                    {
                        StartDate = DateTime.Today,
                        FinishDate = DateTime.Today,
                        TaskName = "Start of Job",
                        IsMileStone = true
                    };

                    var endmarker = new GanttTask
                    {
                        StartDate = DateTime.Today,
                        FinishDate = DateTime.Today,
                        TaskName = "End of Job",
                        IsMileStone = true
                    };

                    var curstart = DateTime.MaxValue;
                    var curend = DateTime.MinValue;

                    _tasks.Add(startmarker);

                    foreach (var row in _kanbans.Rows)
                        if ((Host.KanbanSettings.PlannerSettings.IncludeCompleted || row.Get<Kanban, DateTime>(c => c.Completed).IsEmpty()) &&
                            (Host.KanbanSettings.PlannerSettings.SelectedType == CoreUtils.FullGuid ||
                             row.Get<Kanban, Guid>(c => c.Type.ID) == Host.KanbanSettings.PlannerSettings.SelectedType))
                        {
                            var task = new GanttTask();

                            LoadTask(row, task);

                            if (task.StartDate < curstart)
                                curstart = task.StartDate;

                            if (task.FinishDate > curend)
                                curend = task.FinishDate;

                            _tasks.Add(task);
                        }

                    _tasks.Add(endmarker);


                    foreach (var row in _relationships.Rows)
                    {
                        var predtask = _tasks.FirstOrDefault(x => x.ID == row.Get<KanbanRelationship, Guid>(c => c.Predecessor.ID));
                        var succtask = _tasks.FirstOrDefault(x => x.ID == row.Get<KanbanRelationship, Guid>(c => c.Successor.ID));
                        if (predtask != null && succtask != null)
                        {
                            var type = row.Get<KanbanRelationship, GanttRelationshipType>(x => x.Type);
                            var relationship = type == GanttRelationshipType.FinishToFinish
                                ? GanttTaskRelationship.FinishToFinish
                                : type == GanttRelationshipType.FinishToStart
                                    ? GanttTaskRelationship.FinishToStart
                                    : type == GanttRelationshipType.StartToFinish
                                        ? GanttTaskRelationship.StartToFinish
                                        : GanttTaskRelationship.StartToStart;
                            succtask.Predecessor.Add(new Predecessor { GanttTaskIndex = predtask.TaskId, GanttTaskRelationship = relationship });
                        }
                    }

                    var _striplines = new List<StripLineInfo>();

                    foreach (var row in _stages.Rows)
                    {
                        if (!_striplines.Any())
                        {
                            var startline = new StripLineInfo();
                            startline.Content = "Start of Job";
                            startline.StartDate = row.Get<JobStage, DateTime>(c => c.StartDate);
                            startline.EndDate = startline.StartDate;
                            startline.HorizontalContentAlignment = HorizontalAlignment.Center;
                            startline.VerticalContentAlignment = VerticalAlignment.Center;
                            startline.Background = Brushes.Gold;
                            startline.RepeatBehavior = Repeat.None;
                            _striplines.Add(startline);
                        }

                        var stripline = new StripLineInfo();
                        stripline.Content = row.Get<JobStage, string>(c => c.Name);
                        stripline.StartDate = row.Get<JobStage, DateTime>(c => c.EndDate);
                        stripline.EndDate = stripline.StartDate;
                        stripline.HorizontalContentAlignment = HorizontalAlignment.Center;
                        stripline.VerticalContentAlignment = VerticalAlignment.Center;
                        stripline.Background = Brushes.Gold;
                        stripline.RepeatBehavior = Repeat.None;
                        _striplines.Add(stripline);

                        if (stripline.StartDate < curstart)
                            curstart = stripline.StartDate;

                        if (stripline.EndDate > curend)
                            curend = stripline.EndDate;
                    }

                    Gantt.StripLines = _striplines;
                    Gantt.ShowStripLines = true;
                    Gantt.UseOnDemandSchedule = true;

                    if (curstart != DateTime.MaxValue)
                    {
                        startmarker.StartDate = curstart.Date;
                        startmarker.FinishDate = curstart.Date;
                    }

                    if (curend != DateTime.MinValue)
                    {
                        endmarker.StartDate = curend.Date.AddDays(1);
                        endmarker.FinishDate = curend.AddDays(1);
                    }
                }
                finally
                {
                    bLoading = false;
                }

                foreach (var task in _tasks)
                    task.PropertyChanged += Task_PropertyChanged;
            }
        }

        private void LoadTask(CoreRow row, GanttTask task)
        {
            var start = row.Get<Kanban, DateTime>(x => x.StartDate);
            if (start.IsEmpty())
                start = row.Get<Kanban, DateTime>(x => x.Created);
            var estimated = row.Get<Kanban, TimeSpan>(x => x.EstimatedTime);
            if (estimated.TotalMilliseconds == 0L)
                estimated = TimeSpan.FromHours(1);
            var actual = row.Get<Kanban, TimeSpan>(x => x.ActualTime);
            var progress = estimated.TotalMilliseconds != 0L ? actual.TotalMilliseconds * 100L / estimated.TotalMilliseconds : 0F;

            task.TaskId = row.Get<Kanban, int>(c => c.Number);
            task.ID = row.Get<Kanban, Guid>(x => x.ID);
            task.TaskName = string.Format("{0} - {1}", row.Get<Kanban, int>(c => c.Number), row.Get<Kanban, string>(x => x.Title));
            task.StartDate = start.Date;
            task.FinishDate = row.Get<Kanban, DateTime>(x => x.DueDate).Date.AddDays(1).AddMilliseconds(-1);
            task.Manpower = estimated;
            task.Percentage = progress;
            task.IsMileStone = false;

            var empid = row.EntityLinkID<Kanban, EmployeeLink>(x => x.EmployeeLink) ?? Guid.Empty;
            if (empid != Guid.Empty)
            {
                var resource = _resources.FirstOrDefault(x => (x as GanttResource).Guid == empid) as GanttResource;
                if (resource == null)
                {
                    resource = new GanttResource
                    {
                        ID = _resources.Count,
                        Guid = empid,
                        Name = row.Get<Kanban, string>(c => c.EmployeeLink.Name)
                    };
                    _resources.Add(resource);
                }

                task.Resources = new ObservableCollection<Resource> { resource };
            }
        }

        private void Task_PropertyChanged(object? sender, PropertyChangedEventArgs args)
        {
            if (bLoading)
                return;
            if (!string.Equals(args.PropertyName, "StartDate") && !string.Equals(args.PropertyName, "FinishDate"))
                return;
            var row = _kanbans.Rows.FirstOrDefault(r => r.Get<Kanban, Guid>(x => x.ID) == ((GanttTask)sender).ID);
            var kanban = row?.ToObject<Kanban>();
            var task = sender as GanttTask;
            var bChanged = false;
            if (task != null && kanban != null)
            {
                if (string.Equals(args.PropertyName, "FinishDate"))
                {
                    kanban.DueDate = task.FinishDate.Date;
                    bChanged = true;
                }
                else if (string.Equals(args.PropertyName, "StartDate"))
                {
                    kanban.StartDate = task.StartDate.Date;
                    bChanged = true;
                }
            }

            if (bChanged)
            {
                row.Set<Kanban, DateTime>(x => x.DueDate, kanban.DueDate.Date);
                row.Set<Kanban, DateTime>(x => x.StartDate, kanban.StartDate.Date);
                new Client<Kanban>().Save(kanban, "Updated by Planner", (o, e) => { });
            }
        }

        private void Gantt_RelationshipEstablished(object sender, GanttRelationshipEstablishedEventArgs args)
        {
            var pred = args.StartTask as GanttTask;
            var succ = args.EndTask as GanttTask;
            if (pred == null || pred.IsMileStone)
                throw new Exception("Cannot make a connection here");
            if (succ == null || succ.IsMileStone)
                throw new Exception("Cannot make a connection here");
            var relationship = new KanbanRelationship();
            relationship.Parent.ID = Host.Master?.ID ?? Guid.Empty;
            relationship.Parent.Synchronise(Host.Master ?? new Job());
            relationship.Predecessor.ID = pred.ID;
            relationship.Successor.ID = succ.ID;
            relationship.Type = args.Relationship == GanttTaskRelationship.FinishToFinish
                ? GanttRelationshipType.FinishToFinish
                : args.Relationship == GanttTaskRelationship.FinishToStart
                    ? GanttRelationshipType.FinishToStart
                    : args.Relationship == GanttTaskRelationship.StartToFinish
                        ? GanttRelationshipType.StartToFinish
                        : GanttRelationshipType.StartToStart;
            new Client<KanbanRelationship>().Save(relationship, "", (o, e) =>
            {
                _relationships.LoadRow(relationship);
            });
        }

        private void GanttContextMenu_Opened(object sender, RoutedEventArgs e)
        {
            var task = Gantt.SelectedItems.FirstOrDefault() as GanttTask;
            UnlinkTaskMenu.IsEnabled = task != null && task.Predecessor.Any();
            UnlinkTaskMenu.Tag = task;
        }

        private void UnlinkTaskMenu_Click(object sender, RoutedEventArgs args)
        {
            var successor = (sender as MenuItem).Tag as GanttTask;
            if (successor == null)
                return;
            var deletes = new List<KanbanRelationship>();
            foreach (var link in successor.Predecessor)
            {
                var predecessor = _tasks.FirstOrDefault(x => x.TaskId == link.GanttTaskIndex);
                if (predecessor != null)
                {
                    var rows = _relationships.Rows.Where(r =>
                        r.Get<KanbanRelationship, Guid>(c => c.Successor.ID).Equals(successor.ID) &&
                        r.Get<KanbanRelationship, Guid>(c => c.Predecessor.ID).Equals(predecessor.ID)).ToArray();
                    foreach (var row in rows)
                    {
                        deletes.Add(row.ToObject<KanbanRelationship>());
                        _relationships.Rows.Remove(row);
                    }
                }
            }

            if (deletes.Any())
                new Client<KanbanRelationship>().Delete(deletes, "", (o, e) => { });
            successor.Predecessor.Clear();
        }

        private void EditTask_Click(object sender, RoutedEventArgs e)
        {
            DoEditTask();
        }

        private void DoEditTask()
        {
            if (Gantt.SelectedItems.FirstOrDefault() is not GanttTask task)
                return;

            var row = _kanbans.Rows.FirstOrDefault(r => r.Get<Kanban, Guid>(x => x.ID) == task.ID);
            if (row is null) return;

            var kanban = row.ToObject<Kanban>();
            if (DynamicGridUtils.EditEntity(kanban))
            {
                _kanbans.FillRow(row, kanban);
                LoadTask(row, task);
            }
        }

        private void AddTask_Click(object sender, RoutedEventArgs e)
        {
            var kanban = new Kanban();
            kanban.JobLink.ID = Host.Master?.ID ?? Guid.Empty;
            kanban.JobLink.Synchronise(Host.Master ?? new Job());
            if (DynamicGridUtils.EditEntity(kanban))
            {
                var row = _kanbans.NewRow();
                _kanbans.FillRow(row, kanban);
                var task = new GanttTask();
                LoadTask(row, task);
                _tasks.Add(task);
                task.PropertyChanged += Task_PropertyChanged;
            }
        }
        

        private void IncludeCompleted_Checked(object sender, RoutedEventArgs e)
        {
            Host.KanbanSettings.PlannerSettings.IncludeCompleted = IncludeCompleted.IsChecked == true;
            Host.SaveSettings();
            Refresh();
        }

        #region ITaskControl Support

        public KanbanViewType KanbanViewType => KanbanViewType.Planner;

        public ITaskHost Host { get; set; }

        public bool IsReady { get; set; }

        public string SectionName => "Task Planner";

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


        public IEnumerable<TaskModel> SelectedModels(TaskModel sender = null)
        {
            MessageBox.Show("TaskPlannerControl.SelectedModels() is not Implemented!");
            return new TaskModel[] { };
        }

        #endregion

        private void TaskTypeButton_OnClick(object sender, RoutedEventArgs e)
        {
            var list = new MasterList(typeof(KanbanType));
            list.ShowDialog();
            LoadKanbanTypes();
        }

        private void SelectedType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (EventSuppressor.IsSet(Suppress.This))
            {
                Host.KanbanSettings.PlannerSettings.SelectedType = SelectedType.SelectedValue == null ? Guid.Empty : (Guid)SelectedType.SelectedValue;
                Host.SaveSettings();
                Refresh();
            }
        }
    }
}