Event.cs 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810
  1. using com.sun.jmx.mbeanserver;
  2. using Comal.Classes;
  3. using Expressive;
  4. using InABox.Core;
  5. using InABox.Database;
  6. using Newtonsoft.Json;
  7. using Newtonsoft.Json.Serialization;
  8. using System;
  9. using System.Collections;
  10. using System.Collections.Generic;
  11. using System.Diagnostics.CodeAnalysis;
  12. using System.Linq;
  13. using System.Reflection;
  14. using System.Text;
  15. using System.Threading.Tasks;
  16. namespace PRS.Shared.Events;
  17. public interface IEventData
  18. {
  19. IEvent Event { get; }
  20. IEnumerable<string> ReferencedVariables { get; }
  21. }
  22. public class EventData<T, TDataModel> : IEventData
  23. where T : IEvent<TDataModel>
  24. where TDataModel : IEventDataModel
  25. {
  26. public T Event { get; set; }
  27. /// <summary>
  28. /// A list of triggers for this event. If any of the triggers match, the event runs.
  29. /// </summary>
  30. public List<IEventTrigger<T, TDataModel>> Triggers { get; set; }
  31. public List<IEventAction<T>> Actions { get; set; }
  32. IEvent IEventData.Event => Event;
  33. public IEnumerable<string> ReferencedVariables =>
  34. Triggers.SelectMany(x => x.ReferencedVariables)
  35. .Concat(Actions.SelectMany(x => x.ReferencedVariables))
  36. .Distinct();
  37. public EventData(T eventData)
  38. {
  39. Event = eventData;
  40. Triggers = new List<IEventTrigger<T, TDataModel>>();
  41. Actions = new List<IEventAction<T>>();
  42. }
  43. public Notification GenerateNotification(TDataModel model) => Event.GenerateNotification(model);
  44. }
  45. public static class EventUtils
  46. {
  47. #region Serialisation
  48. private class WritablePropertiesOnlyResolver : DefaultContractResolver
  49. {
  50. protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
  51. {
  52. IList<JsonProperty> props = base.CreateProperties(type, memberSerialization);
  53. return props.Where(p => p.Writable).ToList();
  54. }
  55. }
  56. private static JsonSerializerSettings SerializationSettings()
  57. {
  58. var settings = Serialization.CreateSerializerSettings();
  59. settings.TypeNameHandling = TypeNameHandling.Auto;
  60. settings.ContractResolver = new WritablePropertiesOnlyResolver();
  61. return settings;
  62. }
  63. public static string Serialize(IEventData data)
  64. {
  65. return JsonConvert.SerializeObject(data, typeof(IEventData), SerializationSettings());
  66. }
  67. public static IEventData Deserialize(string json)
  68. {
  69. return JsonConvert.DeserializeObject<IEventData>(json, SerializationSettings())!;
  70. }
  71. #endregion
  72. #region Event Types
  73. private static Dictionary<Type, List<Type>>? _eventTriggerTypes;
  74. private static Dictionary<Type, List<Type>>? _eventActionTypes;
  75. private static List<Type>? _standardEventActionTypes;
  76. [MemberNotNullWhen(true, nameof(_eventTriggerTypes), nameof(_eventActionTypes), nameof(_standardEventActionTypes))]
  77. private static bool _loadedTypes { get; set; }
  78. [MemberNotNull(nameof(_eventTriggerTypes), nameof(_eventActionTypes), nameof(_standardEventActionTypes))]
  79. private static void LoadTypes()
  80. {
  81. if (_loadedTypes) return;
  82. _loadedTypes = true;
  83. _eventTriggerTypes = new();
  84. _eventActionTypes = new();
  85. _standardEventActionTypes = new();
  86. foreach(var type in CoreUtils.TypeList(x => true))
  87. {
  88. if (type.GetInterfaceDefinition(typeof(IEventTrigger<,>)) is Type eventTriggerInterface)
  89. {
  90. if (type.GetConstructor([]) is not null)
  91. {
  92. var eventType = eventTriggerInterface.GenericTypeArguments[0];
  93. eventType = eventType.IsGenericType ? eventType.GetGenericTypeDefinition() : eventType;
  94. _eventTriggerTypes.GetValueOrAdd(eventType).Add(type);
  95. }
  96. }
  97. else if(type.GetInterfaceDefinition(typeof(IStandardEventAction<>)) is Type standardEventAction)
  98. {
  99. if (type.GetConstructor([]) is not null)
  100. {
  101. _standardEventActionTypes.Add(type);
  102. }
  103. }
  104. else if (type.GetInterfaceDefinition(typeof(IEventAction<>)) is Type eventActionInterface)
  105. {
  106. if (type.GetConstructor([]) is not null)
  107. {
  108. var eventType = eventActionInterface.GenericTypeArguments[0];
  109. eventType = eventType.IsGenericType ? eventType.GetGenericTypeDefinition() : eventType;
  110. _eventActionTypes.GetValueOrAdd(eventType).Add(type);
  111. }
  112. }
  113. }
  114. }
  115. public static IEnumerable<Type> GetEventTriggerTypes(Type eventType)
  116. {
  117. LoadTypes();
  118. eventType = eventType.IsGenericType ? eventType.GetGenericTypeDefinition() : eventType;
  119. return _eventTriggerTypes.GetValueOrDefault(eventType) ?? Enumerable.Empty<Type>();
  120. }
  121. public static IEnumerable<Type> GetEventActionTypes(Type eventType)
  122. {
  123. LoadTypes();
  124. eventType = eventType.IsGenericType ? eventType.GetGenericTypeDefinition() : eventType;
  125. return _eventActionTypes.GetValueOrDefault(eventType) ?? Enumerable.Empty<Type>();
  126. }
  127. public static IEnumerable<Type> GetStandardEventActionTypes()
  128. {
  129. LoadTypes();
  130. return _standardEventActionTypes;
  131. }
  132. #endregion
  133. #region Execution
  134. private static bool Check<T, TDataModel>(EventData<T, TDataModel> ev, TDataModel dataModel)
  135. where T : IEvent<TDataModel>
  136. where TDataModel : IEventDataModel
  137. {
  138. return ev.Triggers.Count == 0 || ev.Triggers.Any(x => x.Check(dataModel));
  139. }
  140. public static void Run<T, TDataModel>(IStore store, Event ev, EventData<T, TDataModel> evData, TDataModel dataModel)
  141. where T : IEvent<TDataModel>
  142. where TDataModel : IEventDataModel
  143. {
  144. if (!Check(evData, dataModel)) return;
  145. foreach(var action in evData.Actions)
  146. {
  147. IEvent.RunAction(evData.Event, dataModel, action);
  148. }
  149. NotifySubscribers(store, ev, evData, dataModel);
  150. }
  151. public static void SendNotifications(IStore store, IEnumerable<(EventSubscriberType type, Notification notification)> notifications)
  152. {
  153. var toSave = new List<Notification>();
  154. foreach(var (type, notification) in notifications)
  155. {
  156. if(type == EventSubscriberType.Notification)
  157. {
  158. toSave.Add(notification);
  159. }
  160. else if(type == EventSubscriberType.Email)
  161. {
  162. var mailer = DbFactory.Mailer;
  163. if(mailer is not null)
  164. {
  165. if (mailer.Connect())
  166. {
  167. var msg = mailer.CreateMessage();
  168. // msg.From = DbFactory.EmailAddress;
  169. msg.To = [notification.Employee.Email];
  170. msg.Subject = notification.Title;
  171. msg.Body = notification.Description;
  172. var bOK = mailer.SendMessage(msg);
  173. }
  174. }
  175. }
  176. }
  177. store.Provider.Save(toSave);
  178. }
  179. private static void NotifySubscribers<T, TDataModel>(IStore store, Event ev, EventData<T, TDataModel> evData, TDataModel dataModel)
  180. where T : IEvent<TDataModel>
  181. where TDataModel : IEventDataModel
  182. {
  183. if (!ev.NotificationsEnabled) return;
  184. string? description;
  185. if (ev.NotificationExpression.IsNullOrWhiteSpace())
  186. {
  187. description = null;
  188. }
  189. else
  190. {
  191. var descriptionExpr = new CoreExpression(ev.NotificationExpression, typeof(string));
  192. if(!descriptionExpr.TryEvaluate<string>(dataModel).Get(out description, out var error))
  193. {
  194. CoreUtils.LogException(store.UserID, error, extra: "Error notifying subscribers", store.Logger);
  195. return;
  196. }
  197. }
  198. var subscribers = store.Provider.Query(
  199. new Filter<EventSubscriber>(x => x.Event.ID).IsEqualTo(ev.ID),
  200. Columns.None<EventSubscriber>().Add(x => x.Employee.ID).Add(x => x.Employee.Email).Add(x => x.SubscriberType))
  201. .ToArray<EventSubscriber>();
  202. SendNotifications(store, subscribers.Select(x =>
  203. {
  204. var notification = evData.GenerateNotification(dataModel);
  205. notification.Employee.CopyFrom(x.Employee);
  206. if (description is not null)
  207. {
  208. notification.Description = description;
  209. }
  210. return (x.SubscriberType, notification);
  211. }));
  212. }
  213. #endregion
  214. #region Event Cache
  215. private static bool _loadedCache = false;
  216. private static Dictionary<EventType, Dictionary<Type, List<(Event Event, IEventData EventData)>>> _entityEvents = new();
  217. private static Dictionary<Guid, (EventType, Type)> _entityEventMap = new();
  218. private static Dictionary<EventType, List<(Event Event, IEventData EventData)>> _genericEvents = new();
  219. private static Dictionary<Guid, EventType> _genericEventMap = new();
  220. public static Type GetEventType(EventType type)
  221. {
  222. switch (type)
  223. {
  224. case EventType.AfterSave:
  225. return typeof(SaveEvent<>);
  226. case EventType.Scheduled:
  227. return typeof(ScheduledEvent);
  228. default:
  229. throw new Exception($"Invalid event type {type}");
  230. }
  231. }
  232. public static void ReloadCache(IProvider provider)
  233. {
  234. _loadedCache = true;
  235. _entityEvents.Clear();
  236. _entityEventMap.Clear();
  237. _genericEvents.Clear();
  238. _genericEventMap.Clear();
  239. var events = provider.Query(
  240. new Filter<Event>(x => x.Enabled).IsEqualTo(true),
  241. Columns.None<Event>().Add(x => x.ID).Add(x => x.Code).Add(x => x.EventType).Add(x => x.Data).Add(x => x.NotificationExpression).Add(x => x.NotificationsEnabled))
  242. .ToObjects<Event>();
  243. foreach(var ev in events)
  244. {
  245. AddEvent(provider, ev);
  246. }
  247. }
  248. private static void AddGenericEvent(Event ev)
  249. {
  250. if(ev.Data is not null && ev.Data.Length != 0)
  251. {
  252. var data = Deserialize(ev.Data);
  253. var list = _genericEvents.GetValueOrAdd(ev.EventType);
  254. list.RemoveAll(x => x.Event.ID == ev.ID);
  255. list.Add((ev, data));
  256. _genericEventMap[ev.ID] = ev.EventType;
  257. }
  258. }
  259. private static void RemoveGenericEvent(Event ev)
  260. {
  261. if(_genericEventMap.Remove(ev.ID, out var evType))
  262. {
  263. if(_genericEvents.TryGetValue(evType, out var eventTypeEvents))
  264. {
  265. eventTypeEvents.RemoveAll(x => x.Event.ID == ev.ID);
  266. if(eventTypeEvents.Count == 0)
  267. {
  268. _genericEvents.Remove(evType);
  269. }
  270. }
  271. }
  272. }
  273. private static void AddEntityEvent(Event ev)
  274. {
  275. if(ev.Data is not null && ev.Data.Length != 0)
  276. {
  277. var data = Deserialize(ev.Data);
  278. var entityType = data.Event.GetType().GenericTypeArguments[0];
  279. var list = _entityEvents.GetValueOrAdd(ev.EventType).GetValueOrAdd(entityType);
  280. list.RemoveAll(x => x.Event.ID == ev.ID);
  281. list.Add((ev, data));
  282. _entityEventMap[ev.ID] = (ev.EventType, entityType);
  283. }
  284. }
  285. private static void RemoveEntityEvent(Event ev)
  286. {
  287. if(_entityEventMap.TryGetValue(ev.ID, out var item))
  288. {
  289. if(_entityEvents.TryGetValue(item.Item1, out var eventTypeEvents))
  290. {
  291. if(eventTypeEvents.TryGetValue(item.Item2, out var entityEvents))
  292. {
  293. entityEvents.RemoveAll(x => x.Event.ID == ev.ID);
  294. if(entityEvents.Count == 0)
  295. {
  296. eventTypeEvents.Remove(item.Item2);
  297. }
  298. }
  299. if(eventTypeEvents.Count == 0)
  300. {
  301. _entityEvents.Remove(item.Item1);
  302. }
  303. }
  304. _entityEventMap.Remove(ev.ID);
  305. }
  306. }
  307. public static void AddEvent(IProvider provider, Event ev)
  308. {
  309. if (!_loadedCache) ReloadCache(provider);
  310. var type = GetEventType(ev.EventType);
  311. if (type.HasInterface(typeof(IEntityEvent<>)))
  312. {
  313. AddEntityEvent(ev);
  314. }
  315. else
  316. {
  317. AddGenericEvent(ev);
  318. }
  319. }
  320. public static void RemoveEvent(IProvider provider, Event ev)
  321. {
  322. if (!_loadedCache) ReloadCache(provider);
  323. var type = GetEventType(ev.EventType);
  324. if (type.HasInterface(typeof(IEntityEvent<>)))
  325. {
  326. RemoveEntityEvent(ev);
  327. }
  328. else
  329. {
  330. RemoveGenericEvent(ev);
  331. }
  332. }
  333. #endregion
  334. #region Public Event Running Interface
  335. public static void AfterSave<T>(IStore store, T entity)
  336. where T : Entity, new()
  337. {
  338. if (!_loadedCache) ReloadCache(store.Provider);
  339. var events = _entityEvents.GetValueOrDefault(EventType.AfterSave)
  340. ?.GetValueOrDefault(typeof(T));
  341. if (events is null) return;
  342. foreach(var ev in events)
  343. {
  344. var eventData = (ev.EventData as EventData<SaveEvent<T>, SaveEventDataModel<T>>)!;
  345. var model = new SaveEventDataModel<T>(entity, store);
  346. eventData.Event.Init(store, ev.Event, eventData, model);
  347. Run(store, ev.Event, eventData, model);
  348. }
  349. }
  350. private static bool CheckEventSchedule(ScheduledEvent ev)
  351. {
  352. var now = DateTime.Now;
  353. switch (ev.Properties.Period)
  354. {
  355. case SchedulePeriod.Minute:
  356. case SchedulePeriod.Hour:
  357. case SchedulePeriod.Day:
  358. var dayOfWeekSettings = ev.Properties.DayOfWeekSettings.FirstOrDefault(x => x.DayOfWeek == now.DayOfWeek);
  359. if(dayOfWeekSettings is null || !dayOfWeekSettings.Enabled)
  360. {
  361. return false;
  362. }
  363. var start = now - now.TimeOfDay + dayOfWeekSettings.StartTime;
  364. var end = now - now.TimeOfDay + dayOfWeekSettings.EndTime;
  365. if(ev.Properties.Period == SchedulePeriod.Day)
  366. {
  367. if(ev.Properties.LastExecution < start && now >= start && (now.Date - ev.Properties.LastExecution.Date).TotalDays >= ev.Properties.Frequency)
  368. {
  369. ev.Properties.LastExecution = start;
  370. return true;
  371. }
  372. else
  373. {
  374. return false;
  375. }
  376. }
  377. else if(ev.Properties.Period == SchedulePeriod.Hour)
  378. {
  379. if(start <= now && now <= end)
  380. {
  381. var nowIntervals = Math.Floor((now - start).TotalHours / ev.Properties.Frequency);
  382. var lastIntervals = Math.Floor((ev.Properties.LastExecution - start).TotalHours / ev.Properties.Frequency);
  383. if(nowIntervals > lastIntervals)
  384. {
  385. ev.Properties.LastExecution = start.AddHours(nowIntervals * ev.Properties.Frequency);
  386. }
  387. return true;
  388. }
  389. else
  390. {
  391. return false;
  392. }
  393. }
  394. else if(ev.Properties.Period == SchedulePeriod.Minute)
  395. {
  396. if (start <= now && now <= end)
  397. {
  398. var nowIntervals = Math.Floor((now - start).TotalMinutes / ev.Properties.Frequency);
  399. var lastIntervals = Math.Floor((ev.Properties.LastExecution - start).TotalMinutes / ev.Properties.Frequency);
  400. if (nowIntervals > lastIntervals)
  401. {
  402. ev.Properties.LastExecution = start.AddMinutes(nowIntervals * ev.Properties.Frequency);
  403. }
  404. return true;
  405. }
  406. else
  407. {
  408. return false;
  409. }
  410. }
  411. else
  412. {
  413. throw new Exception("Invalid state");
  414. }
  415. case SchedulePeriod.Week:
  416. if (now >= ev.Properties.NextSchedule)
  417. {
  418. while (now >= ev.Properties.NextSchedule)
  419. {
  420. ev.Properties.NextSchedule += TimeSpan.FromDays(7 * ev.Properties.Frequency);
  421. }
  422. return true;
  423. }
  424. else
  425. {
  426. return false;
  427. }
  428. case SchedulePeriod.Month:
  429. if(now >= ev.Properties.NextSchedule)
  430. {
  431. while(now >= ev.Properties.NextSchedule)
  432. {
  433. ev.Properties.NextSchedule = ev.Properties.NextSchedule.AddMonths(ev.Properties.Frequency);
  434. }
  435. return true;
  436. }
  437. else
  438. {
  439. return false;
  440. }
  441. case SchedulePeriod.Year:
  442. if(now >= ev.Properties.NextSchedule)
  443. {
  444. while(now >= ev.Properties.NextSchedule)
  445. {
  446. ev.Properties.NextSchedule = ev.Properties.NextSchedule.AddYears(ev.Properties.Frequency);
  447. }
  448. return true;
  449. }
  450. else
  451. {
  452. return false;
  453. }
  454. default:
  455. throw new Exception("Invalid state");
  456. }
  457. }
  458. public static void CheckScheduledEvents()
  459. {
  460. var store = DbFactory.FindStore<Event>(Guid.Empty, "", Platform.DatabaseEngine, CoreUtils.GetVersion(), Logger.New());
  461. if (!_loadedCache) ReloadCache(store.Provider);
  462. var events = _genericEvents.GetValueOrDefault(EventType.Scheduled);
  463. if (events is null) return;
  464. foreach(var ev in events)
  465. {
  466. var eventData = (ev.EventData as EventData<ScheduledEvent, ScheduledEventDataModel>)!;
  467. if (CheckEventSchedule(eventData.Event))
  468. {
  469. var model = new ScheduledEventDataModel(ev.Event);
  470. Run(store, ev.Event, eventData, model);
  471. ev.Event.Data = Serialize(eventData);
  472. store.Provider.Save(ev.Event);
  473. }
  474. }
  475. }
  476. #endregion
  477. }
  478. #region DataModel Definition
  479. public interface IEventVariable
  480. {
  481. string Name { get; set; }
  482. Type Type { get; set; }
  483. }
  484. public class StandardEventVariable : IEventVariable
  485. {
  486. public string Name { get; set; }
  487. public Type Type { get; set; }
  488. public StandardEventVariable(string name, Type type)
  489. {
  490. Name = name;
  491. Type = type;
  492. }
  493. }
  494. public class ListEventVariable : IEventVariable
  495. {
  496. public string Name { get; set; }
  497. public Type Type { get; set; }
  498. public ListEventVariable(string name, Type type)
  499. {
  500. Name = name;
  501. Type = type;
  502. }
  503. }
  504. public interface IEventDataModelDefinition
  505. {
  506. IEnumerable<IEventVariable> GetVariables();
  507. IEventVariable? GetVariable(string name);
  508. }
  509. #endregion
  510. #region DataModel
  511. public interface IEventDataModel : IVariableProvider
  512. {
  513. bool TryGetVariable(string name, out object? value);
  514. bool IVariableProvider.TryGetValue(string variableName, out object? value)
  515. {
  516. return TryGetVariable(variableName, out value);
  517. }
  518. T RootModel<T>()
  519. where T : IEventDataModel
  520. {
  521. if(this is IChildEventDataModel child)
  522. {
  523. return child.Parent.RootModel<T>();
  524. }
  525. else if(this is T root)
  526. {
  527. return root;
  528. }
  529. else
  530. {
  531. throw new Exception($"Root model of wrong type; expected {typeof(T).FullName}; got {GetType().FullName}");
  532. }
  533. }
  534. }
  535. public interface ITypedEventDataModel : IEventDataModel
  536. {
  537. public Type EntityType { get; }
  538. }
  539. public interface IChildEventDataModel : IEventDataModel
  540. {
  541. IEventDataModel Parent { get; }
  542. }
  543. public class ChildEventDataModel : IChildEventDataModel
  544. {
  545. public IEventDataModel Parent { get; set; }
  546. public Dictionary<string, object?> Values { get; set; } = new Dictionary<string, object?>();
  547. public ChildEventDataModel(IEventDataModel parent)
  548. {
  549. Parent = parent;
  550. }
  551. public bool TryGetVariable(string name, out object? value)
  552. {
  553. return Values.TryGetValue(name, out value)
  554. || Parent.TryGetVariable(name, out value);
  555. }
  556. public void Init(IEventData data)
  557. {
  558. }
  559. }
  560. #endregion
  561. public interface IEvent
  562. {
  563. IEventDataModelDefinition DataModelDefinition();
  564. public static void RunAction(IEvent ev, IEventDataModel model, IEventAction action)
  565. {
  566. var dataModelDef = ev.DataModelDefinition();
  567. var values = new List<(string name, object? value)[]>() { Array.Empty<(string, object?)>() };
  568. foreach(var variable in action.ReferencedVariables)
  569. {
  570. var varDef = dataModelDef.GetVariable(variable);
  571. if(varDef is ListEventVariable)
  572. {
  573. if (model.TryGetVariable(varDef.Name, out var list) && list is IEnumerable enumerable)
  574. {
  575. var oldValues = values;
  576. values = new List<(string name, object? value)[]>();
  577. foreach(var item in enumerable)
  578. {
  579. foreach(var valueList in oldValues)
  580. {
  581. values.Add(valueList.Concatenate(new (string name, object? value)[]
  582. {
  583. (varDef.Name, item)
  584. }));
  585. }
  586. }
  587. }
  588. else
  589. {
  590. values.Clear();
  591. break;
  592. }
  593. }
  594. }
  595. if(values.Count > 0 && (values.Count > 1 || values[0].Length > 0))
  596. {
  597. var subModel = new ChildEventDataModel(model);
  598. foreach(var valueSet in values)
  599. {
  600. subModel.Values.Clear();
  601. foreach(var (name, value) in valueSet)
  602. {
  603. subModel.Values[name] = value;
  604. }
  605. action.Execute(subModel);
  606. }
  607. }
  608. else
  609. {
  610. action.Execute(model);
  611. }
  612. }
  613. }
  614. /// <summary>
  615. /// Indicates that this event type has properties that can be edited; <typeparamref name="TProperties"/> is used to edit these properties
  616. /// with a dynamic editor.
  617. /// </summary>
  618. public interface IPropertiesEvent<TProperties>
  619. where TProperties : BaseObject, new()
  620. {
  621. /// <summary>
  622. /// Create the properties object for editing.
  623. /// </summary>
  624. TProperties GetProperties();
  625. /// <summary>
  626. /// Given an edited properties object, save them again.
  627. /// </summary>
  628. void SetProperties(TProperties properties);
  629. }
  630. /// <summary>
  631. /// Indicates that this event is generic for type <typeparamref name="T"/>; if this interface is implemented,
  632. /// the main type <b>must</b> be generic, with only one generic type argument.
  633. /// </summary>
  634. public interface IEntityEvent<T>
  635. where T : Entity
  636. {
  637. }
  638. public interface IEvent<TDataModel> : IEvent
  639. {
  640. Notification GenerateNotification(TDataModel model);
  641. }
  642. public interface IEventTrigger
  643. {
  644. IEnumerable<string> ReferencedVariables { get; }
  645. string Description { get; }
  646. }
  647. public interface IEventTrigger<TEvent, TDataModel> : IEventTrigger
  648. where TEvent : IEvent<TDataModel>
  649. where TDataModel : IEventDataModel
  650. {
  651. bool Check(TDataModel dataModel);
  652. }
  653. public interface IEventTriggerParent<TEvent, TDataModel> : IEventTrigger<TEvent, TDataModel>
  654. where TEvent : IEvent<TDataModel>
  655. where TDataModel : IEventDataModel
  656. {
  657. public List<IEventTrigger<TEvent, TDataModel>> ChildTriggers { get; }
  658. }
  659. public class AndTrigger<TEvent, TDataModel> : IEventTrigger<TEvent, TDataModel>, IEventTriggerParent<TEvent, TDataModel>
  660. where TEvent : IEvent<TDataModel>
  661. where TDataModel : IEventDataModel
  662. {
  663. public List<IEventTrigger<TEvent, TDataModel>> ChildTriggers { get; set; } = new();
  664. public IEnumerable<string> ReferencedVariables => ChildTriggers.SelectMany(x => x.ReferencedVariables);
  665. public string Description => "And";
  666. public bool Check(TDataModel dataModel)
  667. {
  668. return ChildTriggers.All(x => x.Check(dataModel));
  669. }
  670. }
  671. public class OrTrigger<TEvent, TDataModel> : IEventTrigger<TEvent, TDataModel>, IEventTriggerParent<TEvent, TDataModel>
  672. where TEvent : IEvent<TDataModel>
  673. where TDataModel : IEventDataModel
  674. {
  675. public List<IEventTrigger<TEvent, TDataModel>> ChildTriggers { get; set; } = new();
  676. public IEnumerable<string> ReferencedVariables => ChildTriggers.SelectMany(x => x.ReferencedVariables);
  677. public string Description => "Or";
  678. public bool Check(TDataModel dataModel)
  679. {
  680. return ChildTriggers.Any(x => x.Check(dataModel));
  681. }
  682. }
  683. public interface IEventAction
  684. {
  685. IEnumerable<string> ReferencedVariables { get; }
  686. object? Execute(IEventDataModel dataModel);
  687. string Description { get; }
  688. }
  689. public interface IEventAction<TEvent> : IEventAction
  690. where TEvent : IEvent
  691. {
  692. }
  693. /// <summary>
  694. /// Marks this event action as being applicable to any event type.
  695. /// </summary>
  696. public interface IStandardEventAction<TEvent> : IEventAction<TEvent>
  697. where TEvent : IEvent
  698. {
  699. }