public virtual RuleJob CreateJob(Rule rule, Envelope <IEvent> @event)
{
Guard.NotNull(rule, nameof(rule));
Guard.NotNull(@event, nameof(@event));
if (!(@event.Payload is AppEvent appEvent))
{
return(null);
}
var actionType = rule.Action.GetType();
if (!ruleTriggerHandlers.TryGetValue(rule.Trigger.GetType(), out var triggerHandler))
{
return(null);
}
if (!ruleActionHandlers.TryGetValue(actionType, out var actionHandler))
{
return(null);
}
var appEventEnvelope = @event.To <AppEvent>();
if (!triggerHandler.Triggers(appEventEnvelope, rule.Trigger))
{
return(null);
}
var eventName = CreateEventName(appEvent);
var now = clock.GetCurrentInstant();
var actionName = typeNameRegistry.GetName(actionType);
var actionData = actionHandler.CreateJob(appEventEnvelope, eventName, rule.Action);
var eventTime =
@event.Headers.Contains(CommonHeaders.Timestamp) ?
@event.Headers.Timestamp() :
now;
var job = new RuleJob
{
JobId = Guid.NewGuid(),
ActionName = actionName,
ActionData = actionData.Data,
AppId = appEvent.AppId.Id,
Created = now,
EventName = eventName,
Expires = eventTime.Plus(Constants.ExpirationTime),
Description = actionData.Description
};
if (job.Expires < now)
{
return(null);
}
return(job);
}
public void Should_handle_delete_event()
{
var storedEvent =
new StoredEvent("stream", "1", 1,
new EventData(typeNameRegistry.GetName <AppDeleted>(), new EnvelopeHeaders(), "payload"));
Assert.True(sut.Handles(storedEvent));
}
public MongoContentRepository(IMongoDatabase database, IAppProvider appProvider, IJsonSerializer serializer, ITextIndexer indexer, TypeNameRegistry typeNameRegistry)
{
Guard.NotNull(appProvider, nameof(appProvider));
Guard.NotNull(serializer, nameof(serializer));
Guard.NotNull(indexer, nameof(indexer));
Guard.NotNull(typeNameRegistry, nameof(typeNameRegistry));
this.appProvider = appProvider;
this.indexer = indexer;
this.serializer = serializer;
typeAssetDeleted = typeNameRegistry.GetName <AssetDeleted>();
typeContentDeleted = typeNameRegistry.GetName <ContentDeleted>();
contents = new MongoContentCollection(database, serializer, appProvider);
}
private JObject CreatePayload(Envelope <IEvent> @event)
{
return(new JObject(
new JProperty("type", typeNameRegistry.GetName(@event.Payload.GetType())),
new JProperty("payload", JObject.FromObject(@event.Payload, webhookSerializer)),
new JProperty("timestamp", @event.Headers.Timestamp().ToString())));
}
public Registered(FactoryFunction fieldFactory, Type propertiesType, TypeNameRegistry typeNameRegistry)
{
typeName = typeNameRegistry.GetName(propertiesType);
this.fieldFactory = fieldFactory;
this.propertiesType = propertiesType;
}
public virtual EventData ToEventData(Envelope <IEvent> envelope, Guid commitId)
{
var eventType = typeNameRegistry.GetName(envelope.Payload.GetType());
envelope.SetCommitId(commitId);
var headers = WriteJson(envelope.Headers);
var content = WriteJson(envelope.Payload);
return(new EventData {
EventId = envelope.Headers.EventId(), Type = eventType, Payload = content, Metadata = headers
});
}
public override void BindToName(Type serializedType, out string assemblyName, out string typeName)
{
assemblyName = null;
var name = typeNameRegistry.GetName(serializedType);
if (name != null)
{
typeName = name;
}
else
{
base.BindToName(serializedType, out assemblyName, out typeName);
}
}
public EventData ToEventData(Envelope <IEvent> envelope, Guid commitId, bool migrate = true)
{
var eventPayload = envelope.Payload;
if (migrate && eventPayload is IMigratedEvent migratedEvent)
{
eventPayload = migratedEvent.Migrate();
}
var payloadType = typeNameRegistry.GetName(eventPayload.GetType());
var payloadJson = serializer.Serialize(envelope.Payload);
envelope.SetCommitId(commitId);
return(new EventData(payloadType, envelope.Headers, payloadJson));
}
public Task SendAsync(string recipient, object message)
{
Guard.NotNullOrEmpty(recipient, nameof(recipient));
Guard.NotNull(message, nameof(message));
var messageType = typeNameRegistry.GetName(message.GetType());
var messageBody = WriteJson(message);
var envelope = new Envelope {
Recipient = recipient, Payload = messageBody, PayloadType = messageType
};
pubSub.Publish(ChannelName, JsonConvert.SerializeObject(envelope), true);
return(TaskHelper.Done);
}
public RecursiveDeleter(
ICommandBus commandBus,
IAssetRepository assetRepository,
IAssetFolderRepository assetFolderRepository,
TypeNameRegistry typeNameRegistry,
ISemanticLog log)
{
Guard.NotNull(commandBus, nameof(commandBus));
Guard.NotNull(assetRepository, nameof(assetRepository));
Guard.NotNull(assetFolderRepository, nameof(assetFolderRepository));
Guard.NotNull(typeNameRegistry, nameof(typeNameRegistry));
Guard.NotNull(log, nameof(log));
this.commandBus = commandBus;
this.assetRepository = assetRepository;
this.assetFolderRepository = assetFolderRepository;
this.log = log;
folderDeletedType = typeNameRegistry.GetName <AssetFolderDeleted>();
}
public virtual EventData ToEventData(Envelope <IEvent> envelope, Guid commitId, bool migrate = true)
{
var eventPayload = envelope.Payload;
if (migrate && eventPayload is IMigratedEvent migratedEvent)
{
eventPayload = migratedEvent.Migrate();
}
var eventType = typeNameRegistry.GetName(eventPayload.GetType());
envelope.SetCommitId(commitId);
var headers = WriteJson(envelope.Headers);
var content = WriteJson(envelope.Payload);
return(new EventData {
EventId = envelope.Headers.EventId(), Type = eventType, Payload = content, Metadata = headers
});
}
public EventData ToEventData(Envelope <IEvent> envelope, Guid commitId, bool migrate = true)
{
var eventPayload = envelope.Payload;
if (migrate && eventPayload is IMigratedEvent migratedEvent)
{
eventPayload = migratedEvent.Migrate();
}
var eventType = typeNameRegistry.GetName(eventPayload.GetType());
envelope.SetCommitId(commitId);
var headers = JToken.FromObject(envelope.Headers, serializer);
var content = JToken.FromObject(envelope.Payload, serializer);
return(new EventData {
Type = eventType, Payload = content, Metadata = headers
});
}
public EventData ToEventData(Envelope <IEvent> envelope, Guid commitId, bool migrate = true)
{
var eventPayload = envelope.Payload;
if (migrate && eventPayload is IMigrated <IEvent> migratedEvent)
{
eventPayload = migratedEvent.Migrate();
if (ReferenceEquals(migratedEvent, eventPayload))
{
Debug.WriteLine("Migration should return new event.");
}
}
var payloadType = typeNameRegistry.GetName(eventPayload.GetType());
var payloadJson = serializer.Serialize(envelope.Payload);
envelope.SetCommitId(commitId);
return(new EventData(payloadType, envelope.Headers, payloadJson));
}
private async Task <JobResult> CreateJobAsync(IRuleActionHandler actionHandler, EnrichedEvent enrichedEvent, RuleContext context, Instant now)
{
var actionName = typeNameRegistry.GetName(context.Rule.Action.GetType());
var expires = now.Plus(Constants.ExpirationTime);
var job = new RuleJob
{
Id = DomainId.NewGuid(),
ActionData = string.Empty,
ActionName = actionName,
AppId = enrichedEvent.AppId.Id,
Created = now,
EventName = enrichedEvent.Name,
ExecutionPartition = enrichedEvent.Partition,
Expires = expires,
RuleId = context.RuleId
};
try
{
var(description, data) = await actionHandler.CreateJobAsync(enrichedEvent, context.Rule.Action);
var json = jsonSerializer.Serialize(data);
job.ActionData = json;
job.ActionName = actionName;
job.Description = description;
return(new JobResult {
Job = job, EnrichedEvent = enrichedEvent
});
}
catch (Exception ex)
{
job.Description = "Failed to create job";
return(JobResult.Failed(ex, enrichedEvent, job));
}
}
private async Task <(RuleJob, Exception?)> CreateJobAsync(Rule rule, DomainId ruleId, IRuleActionHandler actionHandler, Instant now, EnrichedEvent enrichedEvent)
{
var actionName = typeNameRegistry.GetName(rule.Action.GetType());
var expires = now.Plus(Constants.ExpirationTime);
var job = new RuleJob
{
Id = DomainId.NewGuid(),
ActionData = string.Empty,
ActionName = actionName,
AppId = enrichedEvent.AppId.Id,
Created = now,
EventName = enrichedEvent.Name,
ExecutionPartition = enrichedEvent.Partition,
Expires = expires,
RuleId = ruleId
};
try
{
var(description, data) = await actionHandler.CreateJobAsync(enrichedEvent, rule.Action);
var json = jsonSerializer.Serialize(data);
job.ActionData = json;
job.ActionName = actionName;
job.Description = description;
return(job, null);
}
catch (Exception ex)
{
job.Description = "Failed to create job";
return(job, ex);
}
}
public async Task On(Envelope <IEvent> @event)
{
if (@event.Payload is ContentEvent contentEvent)
{
var eventType = typeNameRegistry.GetName(@event.Payload.GetType());
var webhooks = await webhookRepository.QueryUrlsBySchemaAsync(contentEvent.AppId.Id, contentEvent.SchemaId.Id);
if (webhooks.Count > 0)
{
var now = clock.GetCurrentInstant();
var payload = CreatePayload(@event, eventType);
var eventName = $"{contentEvent.SchemaId.Name.ToPascalCase()}{CreateContentEventName(eventType)}";
foreach (var webhook in webhooks)
{
await EnqueueJobAsync(payload, webhook, contentEvent, eventName, now);
}
}
}
}
public async Task On(Envelope <IEvent> @event)
{
if (@event.Payload is ContentEvent contentEvent)
{
var eventType = typeNameRegistry.GetName(@event.Payload.GetType());
var webhooks = await webhookRepository.QueryByAppAsync(contentEvent.AppId.Id);
var matchingWebhooks = webhooks.Where(w => w.Schemas.Any(s => Matchs(s, contentEvent))).ToList();
if (matchingWebhooks.Count > 0)
{
var now = clock.GetCurrentInstant();
var eventPayload = CreatePayload(@event, eventType);
var eventName = $"{contentEvent.SchemaId.Name.ToPascalCase()}{CreateContentEventName(eventType)}";
foreach (var webhook in matchingWebhooks)
{
await EnqueueJobAsync(eventPayload, webhook, contentEvent, eventName, now);
}
}
}
}
public virtual async Task <RuleJob> CreateJobAsync(Rule rule, Envelope <IEvent> @event)
{
Guard.NotNull(rule, nameof(rule));
Guard.NotNull(@event, nameof(@event));
if (!rule.IsEnabled)
{
return(null);
}
if (!(@event.Payload is AppEvent appEvent))
{
return(null);
}
var actionType = rule.Action.GetType();
if (!ruleTriggerHandlers.TryGetValue(rule.Trigger.GetType(), out var triggerHandler))
{
return(null);
}
if (!ruleActionHandlers.TryGetValue(actionType, out var actionHandler))
{
return(null);
}
var appEventEnvelope = @event.To <AppEvent>();
if (!triggerHandler.Triggers(appEventEnvelope, rule.Trigger))
{
return(null);
}
var now = clock.GetCurrentInstant();
var eventTime =
@event.Headers.ContainsKey(CommonHeaders.Timestamp) ?
@event.Headers.Timestamp() :
now;
var expires = eventTime.Plus(Constants.ExpirationTime);
if (expires < now)
{
return(null);
}
var enrichedEvent = await eventEnricher.EnrichAsync(appEventEnvelope);
var actionName = typeNameRegistry.GetName(actionType);
var actionData = await actionHandler.CreateJobAsync(enrichedEvent, rule.Action);
var json = jsonSerializer.Serialize(actionData.Data);
var job = new RuleJob
{
JobId = Guid.NewGuid(),
ActionName = actionName,
ActionData = json,
AggregateId = enrichedEvent.AggregateId,
AppId = appEvent.AppId.Id,
Created = now,
EventName = enrichedEvent.Name,
Expires = expires,
Description = actionData.Description
};
return(job);
}
public virtual async Task <RuleJob> CreateJobAsync(Rule rule, Guid ruleId, Envelope <IEvent> @event)
{
Guard.NotNull(rule, nameof(rule));
Guard.NotNull(@event, nameof(@event));
try
{
if (!rule.IsEnabled)
{
return(null);
}
if (!(@event.Payload is AppEvent))
{
return(null);
}
var typed = @event.To <AppEvent>();
var actionType = rule.Action.GetType();
if (!ruleTriggerHandlers.TryGetValue(rule.Trigger.GetType(), out var triggerHandler))
{
return(null);
}
if (!ruleActionHandlers.TryGetValue(actionType, out var actionHandler))
{
return(null);
}
var now = clock.GetCurrentInstant();
var eventTime =
@event.Headers.ContainsKey(CommonHeaders.Timestamp) ?
@event.Headers.Timestamp() :
now;
var expires = eventTime.Plus(Constants.ExpirationTime);
if (expires < now)
{
return(null);
}
if (!triggerHandler.Trigger(typed.Payload, rule.Trigger, ruleId))
{
return(null);
}
var appEventEnvelope = @event.To <AppEvent>();
var enrichedEvent = await triggerHandler.CreateEnrichedEventAsync(appEventEnvelope);
if (enrichedEvent == null)
{
return(null);
}
await eventEnricher.EnrichAsync(enrichedEvent, typed);
if (!triggerHandler.Trigger(enrichedEvent, rule.Trigger))
{
return(null);
}
var actionName = typeNameRegistry.GetName(actionType);
var actionData = await actionHandler.CreateJobAsync(enrichedEvent, rule.Action);
var json = jsonSerializer.Serialize(actionData.Data);
var job = new RuleJob
{
JobId = Guid.NewGuid(),
ActionName = actionName,
ActionData = json,
AppId = enrichedEvent.AppId.Id,
Created = now,
EventName = enrichedEvent.Name,
ExecutionPartition = enrichedEvent.Partition,
Expires = expires,
Description = actionData.Description
};
return(job);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "createRuleJob")
.WriteProperty("status", "Failed"));
return(null);
}
}
protected void AddEventMessage <TEvent>(string message) where TEvent : IEvent
{
Guard.NotNullOrEmpty(message, nameof(message));
texts[typeNameRegistry.GetName <TEvent>()] = message;
}
public virtual async Task <JobList> CreateJobsAsync(Rule rule, DomainId ruleId, Envelope <IEvent> @event, bool ignoreStale = true)
{
Guard.NotNull(rule, nameof(rule));
Guard.NotNull(@event, nameof(@event));
var result = new JobList();
try
{
if (!rule.IsEnabled)
{
return(result);
}
if (!(@event.Payload is AppEvent))
{
return(result);
}
var typed = @event.To <AppEvent>();
if (typed.Payload.FromRule)
{
return(result);
}
var actionType = rule.Action.GetType();
if (!ruleTriggerHandlers.TryGetValue(rule.Trigger.GetType(), out var triggerHandler))
{
return(result);
}
if (!ruleActionHandlers.TryGetValue(actionType, out var actionHandler))
{
return(result);
}
var now = clock.GetCurrentInstant();
var eventTime =
@event.Headers.ContainsKey(CommonHeaders.Timestamp) ?
@event.Headers.Timestamp() :
now;
if (ignoreStale && eventTime.Plus(Constants.StaleTime) < now)
{
return(result);
}
var expires = now.Plus(Constants.ExpirationTime);
if (!triggerHandler.Trigger(typed.Payload, rule.Trigger, ruleId))
{
return(result);
}
var appEventEnvelope = @event.To <AppEvent>();
var enrichedEvents = await triggerHandler.CreateEnrichedEventsAsync(appEventEnvelope);
foreach (var enrichedEvent in enrichedEvents)
{
try
{
await eventEnricher.EnrichAsync(enrichedEvent, typed);
if (!triggerHandler.Trigger(enrichedEvent, rule.Trigger))
{
continue;
}
var actionName = typeNameRegistry.GetName(actionType);
var job = new RuleJob
{
Id = DomainId.NewGuid(),
ActionData = string.Empty,
ActionName = actionName,
AppId = enrichedEvent.AppId.Id,
Created = now,
EventName = enrichedEvent.Name,
ExecutionPartition = enrichedEvent.Partition,
Expires = expires,
RuleId = ruleId
};
try
{
var(description, data) = await actionHandler.CreateJobAsync(enrichedEvent, rule.Action);
var json = jsonSerializer.Serialize(data);
job.ActionData = json;
job.ActionName = actionName;
job.Description = description;
result.Add((job, null));
}
catch (Exception ex)
{
job.Description = "Failed to create job";
result.Add((job, ex));
}
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "createRuleJobFromEvent")
.WriteProperty("status", "Failed"));
}
}
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "createRuleJob")
.WriteProperty("status", "Failed"));
}
return(result);
}
