public TAggregate GetById <TAggregate>(Guid id, int version, ICorrelatedMessage source) where TAggregate : AggregateRoot, IEventSource
{
var agg = _repository.GetById <TAggregate>(id, version);
((ICorrelatedEventSource)agg).Source = source;
return(agg);
}
/// <summary>
/// Create a new client registration for identity server.
/// </summary>
public Client(
Guid id,
Guid applicationId,
string clientName,
string encryptedClientSecret,
string[] redirectUris,
string[] postLogoutRedirectUris,
string frontChannelLogoutUri,
ICorrelatedMessage source)
: base(source)
{
Ensure.NotEmptyGuid(id, nameof(id));
Ensure.NotEmptyGuid(applicationId, nameof(applicationId));
Ensure.NotNullOrEmpty(clientName, nameof(clientName));
Ensure.NotNullOrEmpty(encryptedClientSecret, nameof(encryptedClientSecret));
RegisterEvents();
Raise(new ClientCreated(
id,
applicationId,
clientName,
new[] { "client_credentials", "password", "authorization_code" },
new[] { "openid", "profile", "rd-policy", "enabled-policies" },
redirectUris,
postLogoutRedirectUris,
frontChannelLogoutUri));
Raise(new ClientSecretAdded(id, encryptedClientSecret));
}
public CorrelatedAggregate(
Guid id,
ICorrelatedMessage source) : this()
{
((ICorrelatedEventSource)this).Source = source;
Raise(new Created(id));
}
public void PostTimeoutAfter(
ICorrelatedMessage source,
Guid targetId,
long timeoutMs,
Action <TimeoutMessage> timeoutAction)
{
Ensure.NotNull(timeoutAction, "timeoutAction");
var timeoutRequest = new TimeoutRequestNode(
source,
targetId,
timeoutMs,
timeoutAction);
lock (_queueLock)
{
if (_queue.Count >= _queue.MaxSize)
{
_queue.Resize(_queue.MaxSize + 100);
}
_queue.Enqueue(timeoutRequest, timeoutMs);
}
if (_starving)
{
_msgAddEvent.Set();
}
}
/// <summary>
/// Create a new user.
/// </summary>
public User(
Guid id,
string fullName,
string givenName,
string surname,
string email,
ICorrelatedMessage source)
: this()
{
Ensure.NotEmptyGuid(id, nameof(id));
// ReSharper disable once ObjectCreationAsStatement
if (!string.IsNullOrEmpty(email))
{
new MailAddress(email); // performs validation on the provided address.
}
Ensure.NotNull(source, nameof(source));
((ICorrelatedEventSource)this).Source = source;
Raise(new UserMsgs.UserCreated(id));
Raise(new UserMsgs.Activated(id));
Raise(new UserMsgs.UserDetailsUpdated(
id,
givenName,
surname,
fullName,
email));
}
/// <summary>
/// Create a new subject for identity server.
/// </summary>
public Subject(
Guid id,
Guid userId,
string subClaim,
string authProvider,
string authDomain,
ICorrelatedMessage source)
: base(source)
{
Ensure.NotEmptyGuid(id, nameof(id));
Ensure.NotNullOrEmpty(authProvider, nameof(authProvider));
Ensure.NotNullOrEmpty(authDomain, nameof(authDomain));
Ensure.NotNullOrEmpty(subClaim, nameof(subClaim));
Ensure.NotNull(source, nameof(source));
Ensure.NotEmptyGuid(userId, nameof(userId));
Ensure.NotEmptyGuid(source.CorrelationId, nameof(source.CorrelationId));
if (source.CausationId == Guid.Empty)
{
Ensure.NotEmptyGuid(source.MsgId, nameof(source.MsgId));
}
RegisterEvents();
Raise(new SubjectMsgs.SubjectCreated(
id,
userId,
subClaim,
authProvider,
authDomain));
}
public void invalid_get_rethrows()
{
var badId = Guid.NewGuid();
ICorrelatedMessage source = MessageBuilder.New(() => new CreditAccount(_accountId, 50));
Assert.Throws <AggregateNotFoundException>(() => _correlatedRepo.GetById <Account>(badId, source));
}
public void DeserializeGenericTypeName()
{
string typeName = typeof(SendHttpRequest).AssemblyQualifiedName;
string json = @"{
""$type"": """ + typeName + @""",
""RequestData"": {
""$type"": ""System.Collections.Generic.Dictionary`2[[System.String, mscorlib,Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"",
""Id"": ""siedemnaście"",
""X"": ""323""
},
""Method"": ""GET"",
""Url"": ""http://www.onet.pl"",
""RequestEncoding"": ""UTF-8"",
""CorrelationId"": ""xyz""
}";
ICorrelatedMessage message = JsonConvert.DeserializeObject <ICorrelatedMessage>(json, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Full
});
Assert.IsInstanceOfType(typeof(SendHttpRequest), message);
SendHttpRequest request = (SendHttpRequest)message;
Assert.AreEqual("xyz", request.CorrelationId);
Assert.AreEqual(2, request.RequestData.Count);
Assert.AreEqual("siedemnaście", request.RequestData["Id"]);
}
public void can_handle_repeated_and_cross_updates()
{
var id = Guid.NewGuid();
ICorrelatedMessage source = MessageBuilder.New(() => new CreateAccount(id));
var cachedAccount = new Account(id, source);
_cachingRepo.Save(cachedAccount);
Assert.Equal(0, cachedAccount.Balance);
var uncachedAccount = _repo.GetById <Account>(id);
uncachedAccount.Credit(1);
_repo.Save(uncachedAccount);
Assert.Equal(1, uncachedAccount.Balance);
var cachedAccount2 = _cachingRepo.GetById <Account>(id);
Assert.Equal(1, cachedAccount.Balance);
Assert.Equal(1, uncachedAccount.Balance);
Assert.Equal(1, cachedAccount2.Balance);
cachedAccount2.Credit(2);
_cachingRepo.Save(cachedAccount2);
Assert.Equal(3, cachedAccount.Balance); //cachedAccount is a pointer to same object as cachedAccount2 due to cache
Assert.Equal(1, uncachedAccount.Balance); //uncachedAccount is an independent object
Assert.Equal(3, cachedAccount2.Balance);
uncachedAccount.Credit(5);
Assert.Throws <WrongExpectedVersionException>(() => _repo.Save(uncachedAccount));
Assert.Equal(3, cachedAccount.Balance); //cachedAccount is a pointer to same object as cachedAccount2 due to cache
Assert.Equal(6, uncachedAccount.Balance); //uncachedAccount is an independent object
Assert.Equal(3, cachedAccount2.Balance);
var cachedAccount3 = _cachingRepo.GetById <Account>(id);
Assert.Equal(3, cachedAccount.Balance); //cachedAccount is a pointer to same object as acct2/3 due to cache
Assert.Equal(6, uncachedAccount.Balance); //uncachedAccount is an independent object
Assert.Equal(3, cachedAccount2.Balance); //cachedAccount is a pointer to same object as acct2/3 due to cache
Assert.Equal(3, cachedAccount3.Balance); //cachedAccount is a pointer to same object as acct2/3 due to cache
cachedAccount.Credit(5);
Assert.Equal(8, cachedAccount.Balance);
_cachingRepo.Save(cachedAccount);
Assert.Equal(8, cachedAccount.Balance);
var cachedAccount4 = _cachingRepo.GetById <Account>(id);
Assert.Equal(8, cachedAccount.Balance); //cachedAccount is a pointer to same object as acct2/3/4 due to cache
Assert.Equal(6, uncachedAccount.Balance); //uncachedAccount is an independent object
Assert.Equal(8, cachedAccount2.Balance); //cachedAccount is a pointer to same object as acct2/3/4 due to cache
Assert.Equal(8, cachedAccount3.Balance); //cachedAccount is a pointer to same object as acct2/3/4 due to cache
Assert.Equal(8, cachedAccount4.Balance); //cachedAccount is a pointer to same object as acct2/3/4 due to cache
}
public void RaiseExternallyCorrelatedEvent(ICorrelatedMessage source)
{
Raise(new CorrelatedEvent()
{
CorrelationId = source.CorrelationId,
CausationId = source.MsgId
});
}
public static MessageBuilder From(ICorrelatedMessage message)
{
return(new MessageBuilder
{
Correlation = message.CorrelationId,
Causation = message.MsgId
});
}
public void try_get_does_not_throw()
{
var badId = Guid.NewGuid();
ICorrelatedMessage source = MessageBuilder.New(() => new CreditAccount(_accountId, 50));
Assert.False(_correlatedRepo.TryGetById <Account>(badId, out var retrievedAccount, source));
Assert.Null(retrievedAccount);
}
protected AggregateRoot(ICorrelatedMessage source = null)
{
if (source == null)
{
return;
}
_correlationId = source.CorrelationId;
_causationId = source.MsgId;
}
public void can_try_get_by_id()
{
ICorrelatedMessage source = MessageBuilder.New(() => new CreditAccount(_accountId, 50));
Assert.True(_correlatedRepo.TryGetById <Account>(_accountId, out var retrievedAccount, source));
Assert.NotNull(retrievedAccount);
Assert.Equal(51, retrievedAccount.Balance);
Assert.Equal(_accountId, retrievedAccount.Id);
}
public TimeoutMessage(
Guid targetId,
long timeoutMs,
ICorrelatedMessage source)
{
MsgId = Guid.NewGuid();
TargetId = targetId;
TimeoutMs = timeoutMs;
CorrelationId = source.CorrelationId;
CausationId = source.MsgId;
}
public TimeoutRequestNode(
ICorrelatedMessage source,
Guid targetId,
long timeoutMs,
Action <TimeoutMessage> timeoutAction
) : base(timeoutMs)
{
Source = source;
TargetId = targetId;
TimeoutMs = timeoutMs;
TimeoutAction = timeoutAction;
}
public void can_delete_aggregate()
{
var newAccountId = Guid.NewGuid();
ICorrelatedMessage source = MessageBuilder.New(() => new when_using_correlated_repository.CreateAccount(newAccountId));
var newAccount = new when_using_correlated_repository.Account(newAccountId, source);
_cachingRepo.Save(newAccount);
var retrievedAccount = _cachingRepo.GetById <when_using_correlated_repository.Account>(newAccountId);
_cachingRepo.Delete(retrievedAccount);
Assert.Throws <AggregateNotFoundException>(() => _cachingRepo.GetById <when_using_correlated_repository.Account>(newAccountId));
}
public void can_get_by_id_at_version()
{
ICorrelatedMessage source = MessageBuilder.New(() => new CreditAccount(_accountId, 50));
var retrievedAccount = _correlatedRepo.GetById <Account>(_accountId, 1, source);
Assert.NotNull(retrievedAccount);
Assert.Equal(0, retrievedAccount.Balance);
Assert.Equal(_accountId, retrievedAccount.Id);
retrievedAccount = _correlatedRepo.GetById <Account>(_accountId, 2, source);
Assert.NotNull(retrievedAccount);
Assert.Equal(7, retrievedAccount.Balance);
Assert.Equal(_accountId, retrievedAccount.Id);
}
public when_using_correlated_repository()
{
var mockStore = new MockStreamStoreConnection("testRepo");
mockStore.Connect();
var repo = new StreamStoreRepository(new PrefixedCamelCaseStreamNameBuilder(), mockStore, new JsonMessageSerializer());
_correlatedRepo = new CorrelatedStreamStoreRepository(repo);
ICorrelatedMessage source = MessageBuilder.New(() => new CreateAccount(_accountId));
var account = new Account(_accountId, source);
account.Credit(7);
account.Credit(13);
account.Credit(31);
repo.Save(account);
}
public void can_save_new_correlated_aggregates()
{
var newAccountId = Guid.NewGuid();
ICorrelatedMessage source = MessageBuilder.New(() => new CreateAccount(newAccountId));
var newAccount = new Account(newAccountId, source);
newAccount.Credit(7);
newAccount.Credit(13);
newAccount.Credit(31);
_correlatedRepo.Save(newAccount);
var retrievedAccount = _correlatedRepo.GetById <Account>(newAccountId, source);
Assert.NotNull(retrievedAccount);
Assert.Equal(51, retrievedAccount.Balance);
Assert.Equal(newAccountId, retrievedAccount.Id);
}
public void can_save_updated_correlated_aggregates()
{
ICorrelatedMessage source = MessageBuilder.New(() => new CreditAccount(_accountId, 50));
var retrievedAccount = _correlatedRepo.GetById <Account>(_accountId, source);
Assert.NotNull(retrievedAccount);
Assert.Equal(_accountId, retrievedAccount.Id);
retrievedAccount.Credit(50);
_correlatedRepo.Save(retrievedAccount);
var retrievedAccount2 = _correlatedRepo.GetById <Account>(_accountId, source);
Assert.NotNull(retrievedAccount2);
Assert.Equal(_accountId, retrievedAccount2.Id);
Assert.Equal(101, retrievedAccount.Balance);
}
public void updated_correlated_aggregates_inject_source_information()
{
ICorrelatedMessage source = MessageBuilder.New(() => new CreditAccount(_accountId, 50));
var retrievedAccount = _correlatedRepo.GetById <Account>(_accountId, source);
retrievedAccount.Credit(7);
retrievedAccount.Credit(13);
retrievedAccount.Credit(31);
var eventSource = (IEventSource)retrievedAccount;
var correlatedEvents = eventSource.TakeEvents().Select(evt => evt as ICorrelatedMessage).ToArray();
foreach (var evt in correlatedEvents)
{
Assert.Equal(source.MsgId, evt.CausationId);
Assert.Equal(source.CorrelationId, evt.CorrelationId);
}
}
public void new_correlated_aggregates_inject_source_information()
{
var newAccountId = Guid.NewGuid();
ICorrelatedMessage source = MessageBuilder.New(() => new CreateAccount(newAccountId));
var newAccount = new Account(newAccountId, source);
newAccount.Credit(7);
newAccount.Credit(13);
newAccount.Credit(31);
var eventSource = (IEventSource)newAccount;
var correlatedEvents = eventSource.TakeEvents().Select(evt => evt as ICorrelatedMessage).ToArray();
foreach (var evt in correlatedEvents)
{
Assert.Equal(source.MsgId, evt.CausationId);
Assert.Equal(source.CorrelationId, evt.CorrelationId);
}
}
public TAggregate GetById <TAggregate>(Guid id, int version, ICorrelatedMessage source) where TAggregate : AggregateRoot, IEventSource
{
TAggregate agg = _cache?.GetById <TAggregate>(id, version);
if (agg == null || agg.Version > version)
{
agg = _repository.GetById <TAggregate>(id, version);
if (agg != null)
{
_cache?.Save(agg);
}
}
if (agg != null)
{
((ICorrelatedEventSource)agg).Source = source;
}
return(agg);
}
//Public Methods
/// <summary>
/// Create a new Application.
/// </summary>
public SecuredApplication(
Guid id,
Guid defaultPolicyId,
string defaultClientId,
string version,
bool oneRolePerUser,
ICorrelatedMessage source)
: base(source)
{
Ensure.NotEmptyGuid(id, nameof(id));
Ensure.NotEmptyGuid(defaultPolicyId, nameof(defaultPolicyId));
Ensure.NotNullOrEmpty(defaultClientId, nameof(defaultClientId));
Ensure.NotNullOrEmpty(version, nameof(version));
Ensure.NotEmptyGuid(source.CorrelationId, nameof(source));
RegisterEvents();
Raise(new ApplicationCreated(
id,
defaultClientId,
version,
oneRolePerUser));
Raise(new PolicyCreated(defaultPolicyId, defaultClientId, id, oneRolePerUser));
}
public void can_remove_by_id_from_the_cache()
{
var id = Guid.NewGuid();
ICorrelatedMessage source = MessageBuilder.New(() => new CreateAccount(id));
var cachedAccount = new Account(id, source);
cachedAccount.Credit(5);
_cachingRepo.Save(cachedAccount); //save at 5
Assert.Equal(5, cachedAccount.Balance);
cachedAccount.Credit(7);
Assert.Equal(12, cachedAccount.Balance);
var cacheCopy = _cachingRepo.GetById <Account>(id);
Assert.Equal(12, cacheCopy.Balance);
_cachingRepo.ClearCache(id);
var persistedCopy = _cachingRepo.GetById <Account>(id);
Assert.Equal(5, persistedCopy.Balance);
}
public bool TryGetById <TAggregate>(Guid id, out TAggregate aggregate, ICorrelatedMessage source) where TAggregate : AggregateRoot, IEventSource
{
return(TryGetById(id, int.MaxValue, out aggregate, source));
}
public ProcessManager(ICorrelatedMessage source = null) : base(source)
{
Register <InputMsg>(msg => { /* input messages have no apply action, saved for audit only*/ });
}
public bool TryGetById <TAggregate>(Guid id, int version, out TAggregate aggregate, ICorrelatedMessage source) where TAggregate : AggregateRoot, IEventSource
{
try {
aggregate = GetById <TAggregate>(id, version, source);
return(true);
}
catch (Exception) {
aggregate = null;
return(false);
}
}
public TAggregate GetById <TAggregate>(Guid id, ICorrelatedMessage source) where TAggregate : AggregateRoot, IEventSource
{
return(GetById <TAggregate>(id, int.MaxValue, source));
}
