protected override async Task SaveInternal(AggregateRoot aggregateRoot)
{
var streamName = aggregateRoot.GetId();
var events = await Save(aggregateRoot, streamName, null);
await PublishEndpoint.Publish(events);
}
public override Task SendConnectionAsync(string connectionId, string methodName, object[] args, CancellationToken cancellationToken = default)
{
if (connectionId == null)
{
throw new ArgumentNullException(nameof(connectionId));
}
// If the connection is local we can skip sending the message through the bus since we require sticky connections.
// This also saves serializing and deserializing the message!
var connection = Connections[connectionId];
if (connection != null)
{
// Connection is local, so we can skip publish
return(connection.WriteAsync(new InvocationMessage(methodName, args)).AsTask());
}
LogContext.Info?.Log("Publishing Connection<THub> message to MassTransit.");
return(PublishEndpoint.Publish <Connection <THub> >(new
{
ConnectionId = connectionId,
Messages = Protocols.ToProtocolDictionary(methodName, args)
},
cancellationToken));
}
public override Task SendUsersAsync(IReadOnlyList <string> userIds, string methodName, object[] args, CancellationToken cancellationToken = default)
{
if (userIds == null)
{
throw new ArgumentNullException(nameof(userIds));
}
if (userIds.Count > 0)
{
IDictionary <string, byte[]> protocolDictionary = Protocols.ToProtocolDictionary(methodName, args);
var publishTasks = new List <Task>(userIds.Count);
foreach (var userId in userIds)
{
publishTasks.Add(PublishEndpoint.Publish <User <THub> >(new
{
UserId = userId,
Messages = protocolDictionary
}, cancellationToken));
}
LogContext.Info?.Log("Publishing multiple User<THub> messages to MassTransit.");
return(Task.WhenAll(publishTasks));
}
return(Task.CompletedTask);
}
public override Task SendGroupsAsync(IReadOnlyList <string> groupNames, string methodName, object[] args, CancellationToken cancellationToken = default)
{
if (groupNames == null)
{
throw new ArgumentNullException(nameof(groupNames));
}
if (groupNames.Count > 0)
{
IDictionary <string, byte[]> protocolDictionary = Protocols.ToProtocolDictionary(methodName, args);
var publishTasks = new List <Task>(groupNames.Count);
foreach (var groupName in groupNames)
{
if (!string.IsNullOrEmpty(groupName))
{
publishTasks.Add(PublishEndpoint.Publish <Group <THub> >(new
{
GroupName = groupName,
Messages = protocolDictionary
}, cancellationToken));
}
}
LogContext.Info?.Log("Publishing multiple Group<THub> messages to MassTransit.");
return(Task.WhenAll(publishTasks));
}
return(Task.CompletedTask);
}
protected override Task SaveInternal(AggregateRoot aggregateRoot)
{
var aggregateId = aggregateRoot.GetId();
var uncommittedEvents = aggregateRoot.GetUncommittedChanges();
var eventsToSave = uncommittedEvents
.Select(e => {
var doc = LiteDb.Mapper.ToDocument(e.GetType(), e);
if (doc.ContainsKey("_id"))
{
doc["_EventId"] = doc["_id"];
doc.Remove("_id"); // always use autoid to keep order
}
doc["_EventType"] = e.GetType().AssemblyQualifiedName;
doc["_AggregateId"] = aggregateId;
return(doc);
})
.ToList();
if (!eventsToSave.Any())
{
return(Task.CompletedTask);
}
var userEventCollection = LiteDb.GetCollection("AllEvents");
userEventCollection.EnsureIndex("_AggregateId");
userEventCollection.InsertBulk(eventsToSave);
PublishEndpoint.Publish(uncommittedEvents);
aggregateRoot.ClearUncommittedChanges();
return(Task.CompletedTask);
}
public override async Task SendConnectionsAsync(IReadOnlyList <string> connectionIds, string methodName, object[] args,
CancellationToken cancellationToken = default)
{
if (connectionIds == null)
{
throw new ArgumentNullException(nameof(connectionIds));
}
if (connectionIds.Count > 0)
{
var protocolDictionary = Protocols.ToProtocolDictionary(methodName, args);
var publishTasks = new List <Task>(connectionIds.Count);
foreach (var connectionId in connectionIds)
{
publishTasks.Add(PublishEndpoint.Publish <Connection <THub> >(new
{
ConnectionId = connectionId,
Messages = await protocolDictionary.ToMessageData(_repository)
},
cancellationToken));
}
LogContext.Info?.Log("Publishing multiple Connection<THub> messages to MassTransit.");
await Task.WhenAll(publishTasks);
}
}
public override Task SendUserAsync(string userId, string methodName, object[] args, CancellationToken cancellationToken = default)
{
LogContext.Info?.Log("Publishing User<THub> message to MassTransit.");
return(PublishEndpoint.Publish <User <THub> >(new
{
UserId = userId,
Messages = Protocols.ToProtocolDictionary(methodName, args)
}, cancellationToken));
}
public override async Task SendUserAsync(string userId, string methodName, object[] args, CancellationToken cancellationToken = default)
{
LogContext.Info?.Log("Publishing User<THub> message to MassTransit.");
await PublishEndpoint.Publish <UserMessageData <THub> >(new
{
UserId = userId,
Messages = await Protocols.ToProtocolDictionary(methodName, args).ToMessageData(_repository)
}, cancellationToken);
}
public override Task SendAllExceptAsync(string methodName, object[] args, IReadOnlyList <string> excludedConnectionIds,
CancellationToken cancellationToken = default)
{
LogContext.Info?.Log("Publishing All<THub> message to MassTransit, with exceptions.");
return(PublishEndpoint.Publish <All <THub> >(
new
{
Messages = Protocols.ToProtocolDictionary(methodName, args),
ExcludedConnectionIds = excludedConnectionIds.ToArray()
}, cancellationToken));
}
public override Task SendGroupAsync(string groupName, string methodName, object[] args, CancellationToken cancellationToken = default)
{
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
LogContext.Info?.Log("Publishing Group<THub> message to MassTransit.");
return(PublishEndpoint.Publish <Group <THub> >(new
{
GroupName = groupName,
Messages = Protocols.ToProtocolDictionary(methodName, args)
},
cancellationToken));
}
public async Task <ActionResult> CreateAsync([FromBody] TenantInputDto tenantInput)
{
var tenant = Mapper.Map <Tenant>(tenantInput);
await CustomerLogic.CreateTenantAsync(tenant);
var errorResult = CheckProblems();
if (errorResult != null)
{
return(errorResult);
}
await PublishEndpoint.Publish <ITenantCreatedEvent>(new { Tenant = tenant });
return(CreatedAtAction(
Url.Action(nameof(GetAsync)), new { id = tenant.Id }, tenant));
}
public async Task <ActionResult> CreateAsync([FromBody] PersonInputDto personInput)
{
var person = Mapper.Map <Person>(personInput);
await CustomerLogic.CreatePersonAsync(person);
var errorResult = CheckProblems();
if (errorResult != null)
{
return(errorResult);
}
await PublishEndpoint.Publish <IPersonCreatedEvent>(new { Person = person });
return(CreatedAtAction(
Url.Action(nameof(GetAsync)), new { id = person.Id }, person));
}
public override async Task SendGroupExceptAsync(string groupName, string methodName, object[] args, IReadOnlyList <string> excludedConnectionIds,
CancellationToken cancellationToken = default)
{
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
LogContext.Info?.Log("Publishing Group<THub> message to MassTransit, with exceptions.");
await PublishEndpoint.Publish <GroupMessageData <THub> >(
new
{
GroupName = groupName,
Messages = await Protocols.ToProtocolDictionary(methodName, args).ToMessageData(_repository),
ExcludedConnectionIds = excludedConnectionIds.ToArray()
}, cancellationToken);
}
