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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
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 => InitializeField(ref _employee, nameof(Employee));
    private EmployeeLink? _employee;
    public TimeSpan Start { get; set; }
    public TimeSpan Finish { get; set; }
    public string Window { get; set; }
    public JobLink Job => InitializeField(ref _job, nameof(Job));
    private JobLink? _job;
    public JobITPLink ITP => InitializeField(ref _iTP, nameof(ITP));
    private JobITPLink? _iTP;
    public ActivityLink Activity => InitializeField(ref _activity, nameof(Activity));
    private ActivityLink? _activity;
    public Guid Tracker { get; set; }
}

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 DoReconfigure(DynamicGridOptions options)
    {
        base.DoReconfigure(options);
        options.RecordCount = true;
        options.DirectEdit = true;
    }

    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);
        return new DynamicGridColumns<WindowTrackerHistory>()
            .AddFluent(x => x.Start, width: 70, format: "hh:mm", alignment: Alignment.MiddleCenter)
            .AddFluent(x => x.Finish, width: 70, format: "hh:mm", alignment: Alignment.MiddleCenter)
            .AddFluent(x => x.Window, width: 0)
            .AddFluent(x => x.Job.ID, width: 200)
            .AddFluent(x => x.ITP.ID, width: 200)
            .AddFluent(x => x.Activity.ID, width: 200);
    }

    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;
    }

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

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

    protected override void Reload(
    	Filters<WindowTrackerHistory> criteria, Columns<WindowTrackerHistory> columns, ref SortOrder<WindowTrackerHistory>? sort,
    	CancellationToken token, 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);
    }
}