public override async Task <ICommandResult> Handle(UpdateClientCommand command)
{
var aggregate = await Get(command.Id);
var employeeUpdatedEvent = new ClientUpdatedEvent(command.FirstName, command.LastName, command.Email);
aggregate.Update(employeeUpdatedEvent);
return(await SaveAndCommit(aggregate));
}
private void HandleClientUpdatedEvent(ClientUpdatedEvent e)
{
ClientState cs = e.ResultClientState;
ClientListItem newClientListItem = ClientListItem.GenerateClientListItemFromClientState(cs);
ClientListUpdateCommand newCLUC = new ClientListUpdateCommand(newClientListItem, e.User, e.ConnectionId);
_logger.Info($"Updating client list Id:{cs.Id} UserName:{cs.Name}.");
Persist <ClientListUpdateCommand>(newCLUC, postClientListItemUpdateHandler);
}
public void Handle(ClientUpdatedEvent message)
{
if (!string.IsNullOrEmpty(message.FirstName))
{
AggregateRoot.FirstName = message.FirstName;
}
if (!string.IsNullOrEmpty(message.LastName))
{
AggregateRoot.LastName = message.LastName;
}
if (!string.IsNullOrEmpty(message.Email))
{
AggregateRoot.Email = message.Email;
}
}
private void PostUpdateHandler(ClientUpdateCommand c)
{
// Update updatable fields
_ActorState.Update(c.ClientStateData);
AutoSaveSnashot(false);
_logger.Debug($"User:{c.User} updated client id:{_ActorState.Id}.");
// Update whoever requested it with the new state
ClientUpdatedEvent message = new ClientUpdatedEvent(_ActorState.Clone(), c.User, c.ConnectionId);
Sender.Tell(message, Self);
// Notify interested actors on the update
NotifyCommandEventSubscribers(message);
}
public bool TranslateAkkaUpsertEventToExternalMessage(CommandEventMessage internalCommandEvent)
{
ClientUpdatedEvent e = internalCommandEvent as ClientUpdatedEvent;
HTTPExternalInterface.HandleEDStateMessage(
new HTTPDestinedCommandStateEvent(
MicroServices.ProcessingStatus.Processed,
e.Message,
new HTTPSourcedCommand(
e.CommandType.ToString(),
e.Area.ToString(),
null,
e.ResultClientState,
e.User,
e.ConnectionId,
e.Id
)
),
false //User only?
);
return(true);
}
public override void Initialize()
{
//init updater
_updateNotifier = new UpdateNotifier();
_updateNotifier.PropertyChanged += (sender, args) => OnPropertyChanged(nameof(VersionStatus));
//forward signalr manager
_signalrmanager = new SignalRManager();
_signalrmanager.NewClientEvent += delegate(Client client) { NewClientEvent?.Invoke(client); };
_signalrmanager.ClientDisconnectedEvent += delegate(Client client) { ClientDisconnectedEvent?.Invoke(client); };
_signalrmanager.ClientUpdatedEvent += delegate(Client client) { ClientUpdatedEvent?.Invoke(client); };
_signalrmanager.NewLogMessageEvent += NotifyNewLogMessageEvent;
_signalrmanager.NewConsoleLogMessage += delegate(Client pClient, string message) { NewConsoleLogMessage?.Invoke(pClient, message); };
_signalrmanager.WorkRequestedEvent += SignalrmanagerOnWorkRequestedEvent;
_signalrmanager.ResultsReceivedEvent += SignalrmanagerOnResultsReceivedEvent;
_signalrmanager.Initialize();
//create command manager
_commandManager = new CommandManager();
_commandManager.NewLogMessageEvent += NotifyNewLogMessageEvent;
_commandManager.Initialize();
base.Initialize();
}
public void Handle(ClientUpdatedEvent message)
{
mailProvider.SendMailAsync("Subject", "Content", "*****@*****.**", "Sender", message.Email);
}
public override void Initialize()
{
//get frontend target
var predictionTarget = GetPredictionTarget();
//init fs manager
_filesystemManager = new FilesystemManager();
_filesystemManager.NewLogMessageEvent += CoreNotifyLogMessage;
_filesystemManager.Initialize();
//configuration manager
_configManager = new ConfigurationManager(_filesystemManager);
_configManager.NewLogMessageEvent += CoreNotifyLogMessage;
_configManager.Initialize();
//forward signalr manager
_signalrservermanager = new SignalRServerManager();
_signalrservermanager.NewClientEvent += delegate(WorkerClient client) { NewClientEvent?.Invoke(client); ClientsUpdated(_signalrservermanager.ConnectedClients.Count); };
_signalrservermanager.ClientDisconnectedEvent += delegate(WorkerClient client) { ClientDisconnectedEvent?.Invoke(client); ClientsUpdated(_signalrservermanager.ConnectedClients.Count); };
_signalrservermanager.ClientUpdatedEvent += delegate(WorkerClient client) { ClientUpdatedEvent?.Invoke(client); };
_signalrservermanager.NewLogMessageEvent += CoreNotifyLogMessage;
_signalrservermanager.NewConsoleLogMessage += delegate(WorkerClient pClient, string message) { NewConsoleLogMessage?.Invoke(pClient, message); };
_signalrservermanager.NewClientErrorMessageEvent += delegate(WorkerClient pClient, String pErrorMessage, List <String> pErrorLog, WorkPackage pWorkPackage) { _commandManager?.ReceiveErrorFromWorker(pErrorLog, pWorkPackage); };
_signalrservermanager.WorkRequestedEvent += SignalrmanagerOnWorkRequestedEvent;
_signalrservermanager.TrainingResultsReceivedEvent += SignalrmanagerOnTrainingResultsReceivedEvent;
_signalrservermanager.PredictionResultsReceivedEvent += SignalrmanagerOnPredictionResultsReceivedEvent;
_signalrservermanager.Initialize();
//frontend signalr manager
_signalrclientmanager = new SignalRClientManager();
_signalrclientmanager.NewLogMessageEvent += CoreNotifyLogMessage;
_signalrclientmanager.PredictionRequestedEvent += _signalrclientmanager_PredictionRequestedEvent;
_signalrclientmanager.ConfigurationUpdatedEvent += delegate(ConductorConfiguration pConfiguration) { this._commandManager.UpdateConfiguration(pConfiguration); };
_signalrclientmanager.ConnectedEvent += delegate() { _commandManager.ReportConfiguration(); };
if (!String.IsNullOrWhiteSpace(predictionTarget))
{ //only connect to frontend if a target is specified
_signalrclientmanager.Initialize($"{predictionTarget}/server/rnn");
_signalrclientmanager.ConnectAsync()
.ContinueWith(t =>
{
this.ClientsUpdated(_signalrservermanager.ConnectedClients.Count);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
}
else
{
this.CoreNotifyLogMessage("SignalRClientManager will not attempt to connect to a frontend because none was specified.");
}
//create command manager
_commandManager = new CommandManager(_configManager, _filesystemManager, _signalrservermanager.ConnectedClients);
_commandManager.NewLogMessageEvent += CoreNotifyLogMessage;
_commandManager.PredictionFinishedEvent += _commandManager_PredictionFinishedEvent;
_commandManager.StatusChangedEvent += _commandManager_StatusChangedEvent;
_commandManager.Initialize();
base.Initialize();
}
private void NotifyClientUpdatedEvent(WorkerClient pClient)
{
ClientUpdatedEvent?.Invoke(pClient);
//NotifyNewLogMessageEvent($"CONNECT: {pClient.ID}");
}
public void Update(ClientUpdatedEvent message)
{
ApplyChange(message);
}
public void Apply(ClientUpdatedEvent @event)
{
Name = @event.Data.Name;
Email = @event.Data.Email;
}
public Task Handle(ClientUpdatedEvent @event, CancellationToken cancellationToken = default(CancellationToken))
{
Save(@event.Id, @event);
return(Task.CompletedTask);
}
public Task Handle(ClientUpdatedEvent notification, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
