internal void Execute(string query)
{
using IConnectionWrapper conn = dbWrapper.CreateConnection();
conn.Open();
using ICommandWrapper comm = dbWrapper.CreateCommand(query.ToString());
comm.ExecuteNonQuery();
}
public static IEventWrapper Wrap(this IEvent @event, ICommandWrapper parent)
{
var eventWrapperGeneric = typeof(EventWrapper <>)
.GetTypeInfo()
.MakeGenericType(@event.GetType());
return(Activator.CreateInstance(eventWrapperGeneric, @event, parent) as IEventWrapper);
}
public CommandToKeyBindingItem(ICommandWrapper c, params Keys[] k)
{
if (c == null)
{
throw new ArgumentNullException();
}
keys = k;
Command = c;
}
internal List <T> ExecuteAndReadEntity <T>(string query) where T : new()
{
using IConnectionWrapper conn = dbWrapper.CreateConnection();
conn.Open();
using ICommandWrapper comm = dbWrapper.CreateCommand(query);
var entities = comm.ExecuteReaderEntity <T>();
return(entities);
}
internal List <T> ExecuteAndReadOneColumn <T>(string query)
{
using IConnectionWrapper conn = dbWrapper.CreateConnection();
conn.Open();
using ICommandWrapper comm = dbWrapper.CreateCommand(query);
var entities = comm.ExecuteReaderOneColumn <T>(0);
return(entities);
}
public async Task Fail(ICommandWrapper commandWrapper, Exception exception)
{
var commandRow = await Retrieve <CommandRow>(commandWrapper.Id.ToString());
commandRow.IsStarted = true;
commandRow.IsDone = true;
commandRow.ExecutionDate = DateTimeOffset.UtcNow;
commandRow.IsSuccessful = false;
var replaceOperation = TableOperation.Replace(commandRow);
await _commandTable.ExecuteAsync(replaceOperation);
}
public async Task Send <TCommand, TEvent>(ICommandWrapper <TCommand> parentCommand,
IReadOnlyCollection <TEvent> events) where TCommand : ICommand where TEvent : IEvent
{
var wrappedEvents = events
.Select(e => e.Wrap(parentCommand))
.ToArray();
if (parentCommand.IsLinkToJob)
{
await _jobHandler.Associate(parentCommand, wrappedEvents);
}
await _eventStore.Save(wrappedEvents);
await ProcessEvents(wrappedEvents);
}
public void Bind(ICommandWrapper cmd, Control clickable)
{
var bi = new CommandToClickCommandEnabledUpdater(cmd, clickable);
this.bindings.Add(bi);
// TODO implemen can execute changed in the same manner
clickable.Click += async(object sender, EventArgs e) =>
{
if (cmd.CanExecute(null))
{
await cmd.Execute(null);
}
};
}
public void Bind(ICommandWrapper cmd, ToolStripItem clickable)
{
var bi = new CommandToControlBindingItem(cmd, clickable);
this.bindings.Add(bi);
clickable.Enabled = cmd.CanExecute(null);
cmd.CanExecuteChanged += (object sender, EventArgs e) =>
{
clickable.Enabled = cmd.CanExecute(null);
};
clickable.Click += (object sender, EventArgs e) =>
{
if (cmd.CanExecute(null))
{
cmd.Execute(null);
}
};
}
public async Task Associate(ICommandWrapper commandParent, IReadOnlyCollection <IEventWrapper> eventWrappers)
{
var commandRow = await Retrieve <CommandRow>(commandParent.Id.ToString());
commandRow.IsStarted = true;
commandRow.ExecutionDate = DateTimeOffset.UtcNow;
commandRow.IsDone = true;
commandRow.IsSuccessful = true;
if (eventWrappers.Any())
{
commandRow.Events = _jsonConverter.Serialize(eventWrappers.Select(e => e.Id));
}
var replaceOperation = TableOperation.Replace(commandRow);
await _commandTable.ExecuteAsync(replaceOperation);
if (!eventWrappers.Any())
{
return;
}
var batchOperation = new TableBatchOperation();
foreach (var eventWrapper in eventWrappers)
{
eventWrapper.JobId = commandParent.JobId;
batchOperation.Add(TableOperation.Insert(new EventRow {
Type = eventWrapper.Event.GetType().FullName,
RowKey = eventWrapper.Id.ToString(),
PartitionKey = "Event",
ParentId = eventWrapper.ParentId,
Timestamp = DateTimeOffset.UtcNow,
IsDone = false,
IsStarted = false,
ExecutionDate = null,
IsSuccessful = false
}));
}
await _eventTable.ExecuteBatchAsync(batchOperation);
}
public async Task Process <TCommand>(ICommandWrapper <TCommand> commandWrapper) where TCommand : ICommand
{
var commandHandler = _commandHandlerFactory.Resolve <TCommand>();
IReadOnlyCollection <IEvent> events;
try {
events = await commandHandler.Handle(commandWrapper.Command);
}
catch (Exception ex) {
if (commandWrapper.IsLinkToJob)
{
await _jobHandler.Fail(commandWrapper, ex);
}
return;
}
if (events.Any())
{
await _eventDispatcher.Send(commandWrapper, events);
}
else
{
await _jobHandler.Done(commandWrapper);
}
}
public void Bind(ICommandWrapper cmd, Control cont, Mouse mouseBtn, ModifierKeys key = ModifierKeys.None)
{
ActionsPerControl o = getOrCreateActionContainer(cont);
CommandToKeyBindingItem kbi;
if (key == ModifierKeys.Control)
{
kbi = new CommandToKeyBindingItem(cmd, Keys.ControlKey);
}
else if (key == ModifierKeys.Shift)
{
kbi = new CommandToKeyBindingItem(cmd, Keys.ShiftKey);
}
else if (key == ModifierKeys.ControlShift)
{
kbi = new CommandToKeyBindingItem(cmd, Keys.ControlKey, Keys.ShiftKey);
}
else
{
kbi = new CommandToKeyBindingItem(cmd);
}
if (mouseBtn == Mouse.LeftDoubleclick)
{
o.AddOnDoubleClickAction(MouseButtons.Left, kbi, key);
}
else if (mouseBtn == Mouse.LeftDown)
{
o.AddOnClickAction(MouseButtons.Left, kbi, key);
}
else if (mouseBtn == Mouse.RightDown)
{
o.AddOnClickAction(MouseButtons.Right, kbi, key);
}
}
public async Task <IJob> Create(ICommandWrapper wrappedCommand)
{
return(await Create(new[] { wrappedCommand }));
}
public EventWrapper(TEvent @event, ICommandWrapper parent)
{
Id = Guid.NewGuid();
Event = @event;
ParentId = parent.Id;
}
public void Bind(ICommandWrapper c, params Keys[] k)
{
var bi = new CommandToKeyBindingItem(c, k);
bindings.Add(bi);
}
public void Bind(ICommandWrapper c, Keys key)
{
var bi = new CommandToKeyBindingItem(c, key);
bindings.Add(bi);
}
public CommandToClickCommandEnabledUpdater(ICommandWrapper cmd, Control c)
{
Command = cmd;
Control = c;
}
public CommandToControlBindingItem(ICommandWrapper cmd, ToolStripItem c)
{
Command = cmd;
tsi = c;
}
public CommandToControlBindingItem(ICommandWrapper cmd, Control c)
{
Command = cmd;
control = c;
}
internal MockCommandFactoryBuilder ForCommandReturn(string commandString, ICommandWrapper command)
{
_commands.Add(commandString, command);
return(this);
}
public async Task Initialize(IJob job, ICommandWrapper wrappedCommand)
{
await Initialize(job, new[] { wrappedCommand });
}
public ValuesController(IIndex <WrapperTypes, Func <ICommandWrapper <ITxnReq, ITxnRe> > > wrapperFactories)
{
_commandWrapper = wrapperFactories[WrapperTypes.DbWrapper]();
_remoteWrapper = wrapperFactories[WrapperTypes.RemoteService]();
}
public async Task Send <TCommand, TEvent>(ICommandWrapper <TCommand> parentCommand, TEvent @event)
where TCommand : ICommand where TEvent : IEvent
{
await Send <TCommand, TEvent>(parentCommand, new[] { @event });
}
