prs/prs.shared/Grids/EventGrid.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using PRS.Shared.Events;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace PRS.Shared;

public class EventGrid : DynamicDataGrid<Event>
{
    private readonly BitmapImage _tick = InABox.Wpf.Resources.tick.AsBitmapImage();
    private readonly BitmapImage _disabled = InABox.Wpf.Resources.disabled.AsBitmapImage();

    private Button? EnableButton = null;

    private HashSet<Guid> _subscribedSet = new();

    public Guid EmployeeID { get; set; }

    protected override void Init()
    {
        base.Init();

        HiddenColumns.Add(x => x.Data);
        HiddenColumns.Add(x => x.Enabled);

        ActionColumns.Add(new DynamicImageColumn(Subscribed_Image, Subscribed_Click) { ToolTip = Subscribed_ToolTip });

        if (Security.IsAllowed<CanManageEvents>())
        {
            EnableButton = AddButton("Disable", null, Enable_Click);
            EnableButton.Visibility = Visibility.Collapsed;
        }
    }

    protected override void SelectItems(CoreRow[]? rows)
    {
        base.SelectItems(rows);
        if(EnableButton is not null)
        {
            if(rows is not null && rows.Length > 0)
            {
                EnableButton.Visibility = Visibility.Visible;
                EnableButton.Content = rows.Any(x => !x.Get<Event, bool>(x => x.Enabled))
                    ? "Enable" : "Disable";
            }
            else
            {
                EnableButton.Visibility = Visibility.Collapsed;
            }
        }
    }

    private bool Enable_Click(Button button, CoreRow[] rows)
    {
        var items = LoadItems(rows);
        if(items.Any(x => !x.Enabled))
        {
            foreach(var item in items)
            {
                item.Enabled = true;
            }
            Client.Save(items, "Event enabled.");
            return true;
        }
        else
        {
            foreach(var item in items)
            {
                item.Enabled = false;
            }
            Client.Save(items, "Event disabled.");
            return true;
        }
    }

    #region UIComponent

    private class UIComponent : DynamicGridGridUIComponent<Event>
    {
        protected override Brush? GetCellBackground(CoreRow row, DynamicColumnBase column)
        {
            if(row.Get<Event, bool>(x => x.Enabled))
            {
                return null;
            }
            else
            {
                return Colors.Gainsboro.ToBrush(0.5);
            }
        }
    }

    protected override IDynamicGridUIComponent CreateUIComponent()
    {
        return new UIComponent { Parent = this };
    }

    #endregion

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        base.DoReconfigure(options);

        if (Security.IsAllowed<CanManageEvents>())
        {
            options.AddRows = true;
            options.EditRows = true;
            options.DeleteRows = true;
        }
        else
        {
            options.AddRows = false;
            options.EditRows = false;
            options.DeleteRows = false;
        }
    }

    #region Action Columns

    private FrameworkElement? Subscribed_ToolTip(DynamicActionColumn column, CoreRow? row)
    {
        if(row is null)
        {
            return column.TextToolTip("Are you subscribed to this event?");
        }
        else
        {
            return _subscribedSet.Contains(row.Get<Event, Guid>(x => x.ID))
                ? column.TextToolTip("You are subscribed to this event.")
                : null;
        }
    }

    private BitmapImage? Subscribed_Image(CoreRow? row)
    {
        if(row is null)
        {
            return _tick;
        }
        else
        {
            return _subscribedSet.Contains(row.Get<Event, Guid>(x => x.ID)) ? _tick : _disabled;
        }
    }

    private bool Subscribed_Click(CoreRow? row)
    {
        if (row is null) return false;

        var eventID = row.Get<Event, Guid>(x => x.ID);
        if(_subscribedSet.Contains(eventID))
        {
            Unsubscribe(row);
        }
        else
        {
            Subscribe(row);
        }
        return true;
    }

    private void Unsubscribe(CoreRow row)
    {
        var eventID = row.Get<Event, Guid>(x => x.ID);

        var subscriber = Client.Query(
            new Filter<EventSubscriber>(x => x.Employee.ID).IsEqualTo(EmployeeID)
                .And(x => x.Event.ID).IsEqualTo(eventID),
            Columns.None<EventSubscriber>().Add(x => x.ID))
            .ToObjects<EventSubscriber>().FirstOrDefault();
        if(subscriber is not null)
        {
            Client.Delete(subscriber, "");
        }

        _subscribedSet.Remove(eventID);
    }

    private void Subscribe(CoreRow row)
    {
        var ev = row.ToObject<Event>();
        var subscriber = new EventSubscriber();
        subscriber.Event.CopyFrom(ev);
        subscriber.Employee.ID = EmployeeID;
        Client.Save(subscriber, "");
        _subscribedSet.Add(ev.ID);
    }

    #endregion

    private readonly Column<Event> EventTypeColumn = new(x => x.EventType);
    private readonly Column<Event> NotificationExpressionColumn = new(x => x.NotificationExpression);

    private IEventData? EventData;

    protected override void BeforeLoad(IDynamicEditorForm form, Event[] items)
    {
        base.BeforeLoad(form, items);

        form.ReadOnly = !Security.IsAllowed<CanManageEvents>();

        var ev = items.First();

        IEventData? data = null;
        if(ev.Data is not null && ev.Data.Length != 0)
        {
            data = EventUtils.Deserialize(ev.Data);
        }
        EventData = data;
    }

    protected override void CustomiseEditor(IDynamicEditorForm form, Event[] items, DynamicGridColumn column, BaseEditor editor)
    {
        base.CustomiseEditor(form, items, column, editor);

        if(EventTypeColumn.IsEqualTo(column.ColumnName) && editor is EnumLookupEditor enumEditor)
        {
            var ev = items.First();

            var editButton = new EditorButton(ev, "Edit Event", 100, EditEvent_Click, false);
            enumEditor.Buttons = [editButton];
        }
        else if(NotificationExpressionColumn.IsEqualTo(column.ColumnName) && editor is ExpressionEditor exprEditor)
        {
            exprEditor.OnGetVariables += ExprEditor_OnGetVariables;
        }
    }

    private IEnumerable<string> ExprEditor_OnGetVariables()
    {
        return EventData?.Event.DataModelDefinition().GetVariables().Select(x => x.Name) ?? [];
    }

    private void EditEvent_Click(object editor, object? item)
    {
        if (item is not Event ev) return;

        var type = ev.EventType;

        var data = EventData;
        if(EventEditor.Run(ref type, ref data))
        {
            EventData = data;
            ev.EventType = type;
            if(data is not null)
            {
                ev.Data = EventUtils.Serialize(data);
            }
            else
            {
                ev.Data = "";
            }
        }
        else
        {
            // We have to 'cancel' by just re-deserialising.
            if(ev.Data is not null && ev.Data.Length != 0)
            {
                EventData = EventUtils.Deserialize(ev.Data);
            }
        }
    }

    protected override void Reload(Filters<Event> criteria, Columns<Event> columns, ref SortOrder<Event>? sort, CancellationToken token, Action<CoreTable?, Exception?> action)
    {
        if (!Security.IsAllowed<CanManageEvents>())
        {
            criteria.Add(new Filter<Event>(x => x.Enabled).IsEqualTo(true));
        }
        base.Reload(criteria, columns, ref sort, token, (data, error) =>
        {
            if(data is not null)
            {
                var ids = data.ExtractValues<Event, Guid>(x => x.ID);
                _subscribedSet = Client.Query(
                    new Filter<EventSubscriber>(x => x.Employee.ID).IsEqualTo(EmployeeID)
                        .And(x => x.Event.ID).InList(ids),
                    Columns.None<EventSubscriber>().Add(x => x.Event.ID))
                    .ToObjects<EventSubscriber>().Select(x => x.Event.ID).ToHashSet();
            }
            action(data, error);
        });
    }
}