prs/prs.desktop/Panels/DailyReports/WindowTrackerHistory.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;

namespace PRSDesktop
{
    public class WindowTrackerHistory : BaseObject
    {
        public EmployeeLink Employee { get; set; }
        public TimeSpan Start { get; set; }
        public TimeSpan Finish { get; set; }
        public string Window { get; set; }
        public JobLink Job { get; set; }
        public JobITPLink ITP { get; set; }
        public ActivityLink Activity { get; set; }
        public Guid Tracker { get; set; }

        protected override void Init()
        {
            base.Init();
            Employee = new EmployeeLink();
            Job = new JobLink();
            ITP = new JobITPLink();
            Activity = new ActivityLink();
        }
    }

    public class WindowTrackerHistoryGrid : DynamicGrid<WindowTrackerHistory>
    {
        private readonly BitmapImage apply = PRSDesktop.Resources.next.AsBitmapImage();
        private readonly BitmapImage apply_disabled = null; // PRSDesktop.Resources.lightbulb.AsGrayScale().AsBitmapImage();

        public List<WindowTrackerHistory> History = new();

        private readonly BitmapImage saved = PRSDesktop.Resources.tick.AsBitmapImage();
        private readonly BitmapImage unsaved = PRSDesktop.Resources.disk.AsBitmapImage();

        protected override void Init()
        {
        }

        protected override void DoReconfigure(FluentList<DynamicGridOption> options)
        {
            options.AddRange(DynamicGridOption.RecordCount, DynamicGridOption.DirectEdit);
        }

        protected override DynamicGridColumns LoadColumns()
        {
            ActionColumns.Clear();
            ActionColumns.Add(new DynamicImageColumn(GetDefault, ToggleDefault) { Position = DynamicActionColumnPosition.Start });
            ActionColumns.Add(new DynamicImageColumn(GetApply, ApplyToAll));
            //ActionColumns.Add(new DynamicRowMovementColumn(DynamicRowMovement.Down, SwapRows));
            HiddenColumns.Add(x => x.Employee.ID);
            HiddenColumns.Add(x => x.Tracker);
            var columns = new DynamicGridColumns
            {
                new() { ColumnName = "Start", Width = 70, Format = "hh:mm", Alignment = Alignment.MiddleCenter },
                new() { ColumnName = "Finish", Width = 70, Format = "hh:mm", Alignment = Alignment.MiddleCenter },
                new() { ColumnName = "Window", Width = 0 },
                new() { ColumnName = "Job.ID", Width = 200 },
                new() { ColumnName = "ITP.ID", Width = 200 },
                new() { ColumnName = "Activity.ID", Width = 200 }
            };
            return columns;
        }

        private bool ApplyToAll(CoreRow? arg)
        {
            if (arg == null)
                return false;
            var title = arg.Get<WindowTracker, string>(x => x.Window);
            var jobid = arg.Get<WindowTracker, Guid>(x => x.Job.ID);
            var itpid = arg.Get<WindowTracker, Guid>(x => x.ITP.ID);
            var actid = arg.Get<WindowTracker, Guid>(x => x.Activity.ID);
            foreach (var item in History)
                if (item.Window.Equals(title))
                {
                    item.Job.ID = jobid;
                    item.ITP.ID = itpid;
                    item.Activity.ID = actid;
                }

            return true;
        }

        private BitmapImage? GetApply(CoreRow? arg)
        {
            if (arg == null)
                return null;
            var window = arg.Get<WindowTrackerHistory, string>(x => x.Window);
            if (string.IsNullOrWhiteSpace(window))
                window = "";
            var others = arg.Table.Rows.Where(r => window.Equals(r.Get<WindowTrackerHistory, string>(c => c.Window))).ToArray();
            return others.Length > 1 ? apply : apply_disabled;
        }

        private bool ToggleDefault(CoreRow? arg)
        {
            if (arg == null)
                return false;
            var tracker = arg.Get<WindowTrackerHistory, Guid>(x => x.Tracker);
            if (tracker != Guid.Empty)
            {
                var delete = new WindowTracker { ID = tracker };
                new Client<WindowTracker>().Delete(delete, "");
                foreach (var item in History)
                    if (item.Tracker.Equals(tracker))
                        item.Tracker = Guid.Empty;
            }
            else
            {
                var update = new WindowTracker();
                update.Window = arg.Get<WindowTrackerHistory, string>(x => x.Window);
                update.Employee.ID = arg.Get<WindowTrackerHistory, Guid>(x => x.Employee.ID);
                update.Job.ID = arg.Get<WindowTrackerHistory, Guid>(x => x.Job.ID);
                update.ITP.ID = arg.Get<WindowTrackerHistory, Guid>(x => x.Job.ID);
                update.Activity.ID = arg.Get<WindowTrackerHistory, Guid>(x => x.Activity.ID);
                new Client<WindowTracker>().Save(update, "");
                foreach (var item in History)
                    if (item.Window.Equals(arg.Get<WindowTrackerHistory, string>(x => x.Window)))
                        item.Tracker = update.ID;
            }

            return true;
        }

        private BitmapImage? GetDefault(CoreRow? arg)
        {
            if (arg == null)
                return null;
            return arg.Get<WindowTrackerHistory, Guid>(x => x.Tracker) != Guid.Empty ? saved : unsaved;
        }

        protected override void DeleteItems(params CoreRow[] rows)
        {
            foreach (var row in rows)
            {
                var index = Data.Rows.IndexOf(row);
                History.RemoveAt(index);
            }
        }

        protected override WindowTrackerHistory LoadItem(CoreRow row)
        {
            return History[row.Index];
        }

        protected override void Reload(Filters<WindowTrackerHistory> criteria, Columns<WindowTrackerHistory> columns,
            ref SortOrder<WindowTrackerHistory>? sort, Action<CoreTable?, Exception?> action)
        {
            var result = new CoreTable();
            result.LoadColumns(typeof(WindowTrackerHistory));
            result.LoadRows(History);
            action.Invoke(result, null);
        }

        public override void SaveItem(WindowTrackerHistory item)
        {
            if (!History.Contains(item))
                History.Add(item);
        }
    }
}