public Action(string objectName, string actionName, string id, IActionEvent started, IActionEvent ended = null)
{
ObjectName = objectName;
ActionName = actionName;
Id = id;
Started = started;
Ended = ended;
innerActions = new List <IAction>();
}
/// <summary>
/// Notifies the observer of the specified action.
/// </summary>
/// <param name="action">The action that originated this message.</param>
/// <param name="actionEvent">The action event to notify the observer.</param>
public async Task NotifyAsync(IAction action, IActionEvent actionEvent)
{
var messageTemplate = ObserverSettings.Settings.MessageTemplate(actionEvent.EventType);
if (messageTemplate != null)
{
await SendWebPostAsync(actionEvent, messageTemplate);
}
}
public void processTrigger(decimal trigger, IActionEvent evt = null)
{
EventHorizonBlazorInterop.Func <CachedEntity>(
new object[]
{
new string[] { this.___guid, "processTrigger" }, trigger, evt
}
);
}
private IActionEvent GetEndEvent(IActionEvent starttEvent, IList <IActionEvent> events, int start)
{
for (int i = start; i < events.Count(); i++)
{
IActionEvent actionEvent = events[i];
if (actionEvent.Id.Equals(starttEvent.Id))
{
return(actionEvent);
}
}
return(null);
}
public static bool TryGetFromObjEx <T>(this IActionEvent e, out T result)
{
if (e.IsError() && e.Target is ObjectException <T> ex)
{
result = ex.Target;
return(true);
}
else
{
result = default;
return(false);
}
}
public static bool TryGet <T>(this IActionEvent e, out T result)
{
if (e.IsOk() && e.Target is T r)
{
result = r;
return(true);
}
else
{
result = default;
return(false);
}
}
/// <summary>
/// Sends the web post to the configured URL.
/// </summary>
/// <param name="actionEvent">The action event.</param>
/// <param name="messageTemplate">The message template.</param>
private async Task SendWebPostAsync(IActionEvent actionEvent, string messageTemplate)
{
try
{
Logger.LogTrace($"Sending WebPost to {ObserverSettings.Settings.Url()}...");
using var request = new HttpRequestMessage(HttpMethod.Post, ObserverSettings.Settings.Url());
var message = messageTemplate.FormatWith(actionEvent);
Logger.LogTrace($"WebPost Message: {message}");
request.Content = new StringContent(message, Encoding.UTF8, ObserverSettings.Settings.ContentType());
using var response = await HttpClientFactory.GetHttpClient().SendAsync(request);
response.EnsureSuccessStatusCode();
Logger.LogTrace($"Sending WebPost to {ObserverSettings.Settings.Url()}...done");
}
catch (Exception ex)
{
Logger.LogError($"Error sending WebPost message. Exception: {ex.Message}, Ignoring.", ex);
}
}
public void SetEnded(IActionEvent ended)
{
Ended = ended;
}
public Task NotifyObserversAsync(IActionEvent actionEvent)
{
return(Task.CompletedTask);
}
// TODO linked-list
public ITimeTrackable(IActionEvent actionEvent)
{
this.actionEvent = actionEvent;
}
public static bool IsOk(this IActionEvent @event) => @event.Type == ActionEventType.EvtOk;
public static bool TrueFromObjEx <T>(this IActionEvent @event, Func <T, bool> predicate)
{
return(@event.TryGetFromObjEx <T>(out var result) && predicate(result));
}
public static bool IsRetry(this IActionEvent @event) => @event.Type == ActionEventType.EvtRetry;
public static bool IsError(this IActionEvent @event) => @event.Type == ActionEventType.EvtError;
public IList <IAction> ChronologicalListToTree(IList <IActionEvent> events)
{
if (events.Count() == 0)
{
return(null);
}
IActionEvent firstEvent = events.First();
IActionEvent lastEvent = GetEndEvent(firstEvent, events, 1);
IAction firstAction = GetNewAction(firstEvent, lastEvent);
IList <IAction> actions = new List <IAction>()
{
firstAction
};
IList <IAction> parentActions = new List <IAction>()
{
firstAction
};
for (int i = 1; i < events.Count(); i++)
{
IActionEvent actionEvent = events[i];
IAction parentAction = parentActions.LastOrDefault();
if (actionEvent == lastEvent)
{
if (parentAction != null)
{
parentActions.Remove(parentAction);
}
continue;
}
if (parentAction == null)
{
if (!actionEvent.Event.Equals(Event.Started))
{
throw new Exception();
}
firstEvent = actionEvent;
lastEvent = GetEndEvent(firstEvent, events, i);
IAction nextSibling = GetNewAction(firstEvent, lastEvent);
actions.Add(nextSibling);
parentActions = new List <IAction>()
{
nextSibling
};
continue;
}
if (actionEvent.Event.Equals(Event.Started))
{
IAction action = GetNewAction(actionEvent);
parentAction.AddActionChild(action);
parentActions.Add(action);
}
else if (actionEvent.Event.Equals(Event.Ended))
{
parentAction.SetEnded(actionEvent);
parentActions.Remove(parentAction);
}
}
return(actions);
}
private IAction GetNewAction(IActionEvent started, IActionEvent ended = null)
{
return(new Action(started.ObjectName, started.ActionName, started.Id, started, ended));
}
public static Exception GetEx(this IActionEvent @event) => @event.IsError() ? (Exception)@event.Target : null;
public static string GetExMsg(this IActionEvent @event) => @event.GetEx()?.Message;
public void AddAction(IActionEvent actionEvent)
{
actionEvent.ActivationTime += currentTime;
queuedActions.Enqueue(actionEvent);
}
