prs/prs.shared/Events/SaveEvent.cs

using Comal.Classes;
using InABox.Core;
using InABox.Scripting;
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;

namespace PRS.Shared.Events;

public class SaveEvent<T> : IEvent<SaveEventDataModel<T>>
    where T : Entity
{
    public Type Entity => typeof(T);

    public IEventDataModelDefinition DataModelDefinition()
    {
        return new SaveEventDataModelDefinition<T>(this);
    }

    public Notification GenerateNotification(SaveEventDataModel<T> model)
    {
        var notification = new Notification();
        notification.Title = $"Updated {typeof(T).Name}";
        notification.Description = $"Updated {typeof(T).Name}";

        if(model.Entity.ID != Guid.Empty)
        {
            notification.EntityType = CoreUtils.EntityName(model.EntityType);
            notification.EntityID = model.Entity.ID;
        }
        return notification;
    }
}

public class SaveEventDataModelDefinition<T>(SaveEvent<T> ev) : IEventDataModelDefinition
    where T : Entity
{
    private IEventVariable[]? variables;

    public SaveEvent<T> Event { get; set; } = ev;

    public IEnumerable<IEventVariable> GetVariables()
    {
        if(variables is null)
        {
            variables = DatabaseSchema.AllProperties(Event.Entity).Select(x => new StandardEventVariable(x.Name, x.PropertyType)).ToArray();
            variables.SortBy(x => x.Name);
        }
        return variables;
    }

    public IEventVariable? GetVariable(string name)
    {
        if(variables is null)
        {
            var prop = DatabaseSchema.Property(Event.Entity, name);
            if(prop is null)
            {
                return null;
            }
            else
            {
                return new StandardEventVariable(prop.Name, prop.PropertyType);
            }
        }
        else
        {
            return variables.FirstOrDefault(x => x.Name == name);
        }
    }
}

public class SaveEventDataModel<T>(T entity) : IEventDataModel, ITypedEventDataModel
    where T : Entity
{
    public T Entity { get; set; } = entity;

    public Type EntityType => typeof(T);

    public bool TryGetVariable(string name, out object? value)
    {
        var prop = DatabaseSchema.Property(typeof(T), name);
        if(prop != null)
        {
            value = prop.Getter()(Entity);
            return true;
        }
        else
        {
            value = null;
            return false;
        }
    }
}

#region Triggers

public class CreatedSaveEventTrigger<T> : ITrigger<SaveEvent<T>, SaveEventDataModel<T>>
    where T : Entity
{
    public bool Check(SaveEventDataModel<T> dataModel)
    {
        return dataModel.Entity.HasOriginalValue(x => x.ID);
    }
}

public class PropertyChangedSaveEventTrigger<T> : ITrigger<SaveEvent<T>, SaveEventDataModel<T>>
    where T : Entity
{
    public IProperty? TriggerProperty { get; set; }

    public object? OldValue { get; set; }

    public object? NewValue { get; set; }

    public bool Check(SaveEventDataModel<T> dataModel)
    {
        if(TriggerProperty is null)
        {
            return false;
        }
        if (!dataModel.Entity.HasOriginalValue(TriggerProperty.Name))
        {
            return false;
        }
        if(OldValue is not null && !object.Equals(dataModel.Entity.OriginalValueList[TriggerProperty.Name], OldValue))
        {
            return false;
        }
        if(NewValue is not null && !object.Equals(TriggerProperty.Getter()(dataModel.Entity), NewValue))
        {
            return false;
        }
        return true;
    }
}

public class ScriptSaveEventTrigger<T> : ITrigger<SaveEvent<T>, SaveEventDataModel<T>>
    where T : Entity
{
    private ScriptDocument? _scriptDocument;

    private string? _script;
    public string? Script
    {
        get => _script;
        set
        {
            if(_script != value)
            {
                _script = value;
                _scriptDocument = null;
            }
        }
    }

    public string DefaultScript()
    {
        return @"
using Comal.Classes;

public class Module
{
    public bool Check(SaveEventDataModel<" + typeof(T).Name + @"> model)
    {
        // Return true if model.Entity meets the requirements for this event trigger.
        return true;
    }
}";
    }

    public bool Check(SaveEventDataModel<T> dataModel)
    {
        if (Script is null) return false;

        if(_scriptDocument is null)
        {
            _scriptDocument = new(Script);
            _scriptDocument.Compile();
        }
        return _scriptDocument.Execute(methodname: "Check", parameters: [dataModel]);
    }
}

#endregion

#region Actions

public class ScriptSaveEventAction<T> : IEventAction<SaveEvent<T>>
    where T : Entity
{
    private ScriptDocument? _scriptDocument;

    private string? _script;
    public string? Script
    {
        get => _script;
        set
        {
            if(_script != value)
            {
                _script = value;
                _scriptDocument = null;
            }
        }
    }

    public string DefaultScript()
    {
        return @"
using Comal.Classes;

public class Module
{
    public object? Result { get; set; }

    public bool Execute(SaveEventDataModel<" + typeof(T).Name + @"> model)
    {
        // Do anything you want with model.Entity, and then save return-value to 'Result', or leave it as 'null' if no return value is needed.
        return true;
    }
}";
    }


    public object? Execute(IEventDataModel dataModel)
    {
        if (Script is null) return null;

        if(_scriptDocument is null)
        {
            _scriptDocument = new(Script);
            _scriptDocument.SetValue("Result", null);
            _scriptDocument.Compile();
        }
        var model = dataModel.RootModel<SaveEventDataModel<T>>();
        if(_scriptDocument.Execute(methodname: "Execute", parameters: [model]))
        {
            return _scriptDocument.GetValue("Result");
        }
        else
        {
            return null;
        }
    }

    public IEnumerable<string> ReferencedVariables()
    {
        yield break;
    }
}

public class CreateEntityAction<T> : IEventAction<SaveEvent<T>>
    where T : Entity
{
    public Type? EntityType { get; set; }

    public List<PropertyInitializer> Initializers { get; set; } = new List<PropertyInitializer>();

    public object? Execute(IEventDataModel dataModel)
    {
        if(EntityType is null)
        {
            return null;
        }
        var entity = (Activator.CreateInstance(EntityType) as Entity)!;
        foreach(var initializer in Initializers)
        {
            initializer.Execute(entity, dataModel);
        }
        return entity;
    }

    public IEnumerable<string> ReferencedVariables()
    {
        return Initializers.SelectMany(x => x.ReferencedVariables());
    }
}

public class PropertyInitializer
{
    public IProperty Property { get; set; }

    private CoreExpression? _valueExpression;
    private CoreExpression ValueExpression
    {
        get
        {
            _valueExpression ??= new CoreExpression(Value, Property.PropertyType);
            return _valueExpression;
        }
    }

    private string _value;
    public string Value
    {
        get => _value;
        [MemberNotNull(nameof(_value))]
        set
        {
            if(value != _value)
            {
                _value = value;
                _valueExpression = null;
            }
        }
    }

    public PropertyInitializer(IProperty property, string value)
    {
        Property = property;
        Value = value;
    }

    public void Execute(Entity entity, IEventDataModel dataModel)
    {
        Property.Setter()(entity, ValueExpression.Evaluate(dataModel));
    }

    public IEnumerable<string> ReferencedVariables()
    {
        return ValueExpression.ReferencedVariables;
    }
}

#endregion