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.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 HashSet<Guid> _subscribedSet = new();

    public Guid EmployeeID { get; set; }

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

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

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

    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)
        {
            using var stream = new MemoryStream(ev.Data);
            var reader = new CoreBinaryReader(stream, BinarySerializationSettings.Latest);
            data = EventUtils.Deserialize(reader);
        }
        EventData = data;
    }

    protected override void CustomiseEditor(Event[] items, DynamicGridColumn column, BaseEditor editor)
    {
        base.CustomiseEditor(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)
            {
                using var stream = new MemoryStream();
                EventUtils.Serialize(data, new CoreBinaryWriter(stream, BinarySerializationSettings.Latest));
                ev.Data = stream.ToArray();
            }
            else
            {
                ev.Data = [];
            }
        }
    }

    protected override void Reload(Filters<Event> criteria, Columns<Event> columns, ref SortOrder<Event>? sort, CancellationToken token, Action<CoreTable?, Exception?> action)
    {
        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);
        });
    }
}