public void ProcessMessage(IHandlerContext <AddRoleCommand> context)
{
var message = context.Message;
if (string.IsNullOrEmpty(message.Name))
{
return;
}
using (_databaseContextFactory.Create())
{
var key = Role.Key(message.Name);
if (_keyStore.Contains(key))
{
return;
}
var id = Guid.NewGuid();
_keyStore.Add(id, key);
var role = new Role(id);
var stream = _eventStore.CreateEventStream(id);
stream.AddEvent(role.Add(message.Name));
_eventStore.Save(stream);
}
}
public void ProcessMessage(IHandlerContext <RegisterUserCommand> context)
{
var message = context.Message;
var id = Guid.NewGuid();
Registered registered;
using (_databaseContextFactory.Create())
{
var key = User.Key(message.EMail);
if (_keyStore.Contains(key))
{
if (!message.EMail.Equals("shuttle", StringComparison.InvariantCultureIgnoreCase))
{
context.Send(new SendEMailCommand
{
Body = string.Format("<p>Hello,</p><br/><p>Unfortunately e-mail '{0}' has been assigned before your user could be registered. Please register again.</p><br/><p>Regards</p>", message.EMail),
Subject = "User registration failure",
IsBodyHtml = true,
To = message.EMail
});
}
return;
}
_keyStore.Add(id, key);
var user = new User(id);
var stream = new EventStream(id);
registered = user.Register(message.EMail, message.PasswordHash, message.RegisteredBy);
stream.AddEvent(registered);
_eventStore.SaveEventStream(stream);
}
context.Publish(new UserRegisteredEvent
{
Id = id,
EMail = message.EMail,
RegisteredBy = message.RegisteredBy,
DateRegistered = registered.DateRegistered
});
}
public void ProcessMessage(IHandlerContext <RegisterUserCommand> context)
{
var message = context.Message;
if (string.IsNullOrEmpty(message.Username))
{
return;
}
if (string.IsNullOrEmpty(message.RegisteredBy))
{
return;
}
var id = Guid.NewGuid();
using (_databaseContextFactory.Create())
{
var key = User.Key(message.Username);
if (_keyStore.Contains(key))
{
return;
}
var count = _systemUserQuery.Count();
_keyStore.Add(id, key);
var user = new User(id);
var stream = _eventStore.CreateEventStream(id);
var registered = user.Register(message.Username, message.PasswordHash, message.RegisteredBy);
if (count == 0)
{
stream.AddEvent(user.AddRole("administrator"));
}
stream.AddEvent(registered);
_eventStore.Save(stream);
}
}
public void ProcessMessage(IHandlerContext <RegisterMatrixCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
Matrix matrix;
var key = Matrix.Key(message.Name);
EventStream stream;
if (message.Id.Equals(Guid.Empty))
{
stream = _eventStore.CreateEventStream();
matrix = new Matrix(stream.Id);
_keyStore.Add(matrix.Id, key);
}
else
{
stream = _eventStore.Get(message.Id);
matrix = new Matrix(stream.Id);
stream.Apply(matrix);
if (!matrix.IsNamed(message.Name) && !_keyStore.Contains(key))
{
_keyStore.Remove(Matrix.Key(message.Name));
_keyStore.Add(matrix.Id, key);
}
}
stream.AddEvent(matrix.Register(
message.Name,
message.RowArgumentId,
message.ColumnArgumentId,
message.DataTypeName));
_eventStore.Save(stream);
}
}
public void ProcessMessage(IHandlerContext <RenameArgumentCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
var key = Argument.Key(message.Name);
if (_keyStore.Contains(key))
{
return;
}
var stream = _eventStore.Get(message.ArgumentId);
if (stream.IsEmpty)
{
return;
}
var argument = new Argument(message.ArgumentId);
stream.Apply(argument);
if (argument.IsNamed(message.Name))
{
return;
}
_keyStore.Remove(Argument.Key(argument.Name));
stream.AddEvent(argument.Rename(message.Name));
_keyStore.Add(message.ArgumentId, key);
_eventStore.Save(stream);
}
}
public void ProcessMessage(IHandlerContext <RegisterTestCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
var key = Test.Key(message.Name);
if (_keyStore.Contains(key))
{
return;
}
var test = new Test(Guid.NewGuid());
var stream = _eventStore.CreateEventStream(test.Id);
stream.AddEvent(test.Register(message.Name, message.FormulaId, message.ExpectedResult,
message.ExpectedResultDataTypeName, message.Comparison));
_eventStore.Save(stream);
_keyStore.Add(test.Id, key);
}
}
public void ProcessMessage(IHandlerContext <RenameFormulaCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
var key = Formula.Key(message.Name);
if (_keyStore.Contains(key))
{
return;
}
var stream = _eventStore.Get(message.FormulaId);
if (stream.IsEmpty)
{
return;
}
var formula = new Formula(message.FormulaId);
stream.Apply(formula);
if (formula.IsNamed(message.Name))
{
return;
}
_keyStore.Remove(Formula.Key(formula.Name));
stream.AddEvent(formula.Rename(message.Name));
_eventStore.Save(stream);
_keyStore.Add(formula.Id, key);
}
}
/// <summary>
/// Configure the AES instance
/// </summary>
/// <param name="streamId">Id of the stream to obtain the encryption key for</param>
/// <param name="create">Whether to create a new key in case there is none in the key store</param>
/// <returns>The configured AES instance</returns>
private async Task <Aes> GetAes(string streamId, bool create = false)
{
var aes = new AesManaged
{
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7
};
if (!_keyCache.ContainsKey(streamId))
{
if (!await _keyStore.Contains(streamId))
{
if (create)
{
aes.GenerateKey();
await _keyStore.Add(streamId, aes.Key);
_keyCache.Add(streamId, aes.Key);
}
else
{
throw new KeyDeletedException("The encryption key has been deleted");
}
}
else
{
var value = await _keyStore.Get(streamId);
_keyCache.Add(streamId, value);
}
}
aes.Key = _keyCache[streamId];
return(aes);
}
