public TaskExecutionViewModel(TaskExecutionDto execution)
{
TaskExecutionId = execution.TaskExecutionId;
TaskSessionId = execution.TaskSessionId;
TargetId = execution.TargetId;
CreatedOn = execution.CreatedOn;
}
private async Task ExecuteAttender(TargetId id, IServiceProvider services, CancellationToken cancellationToken)
{
var execution = new TaskExecutionDto
{
TaskExecutionId = Guid.NewGuid(),
TaskSessionId = _taskSession.TaskSessionId,
TargetId = id.IsServer ? (int?)null : id.ClientId,
CreatedOn = DateTimeOffset.UtcNow,
TaskReferenceId = _mazeTask.Id
};
if (!await _taskResultStorage.CreateTaskExecution(execution))
{
return;
}
await _hubContext.Clients.All.SendAsync(HubEventNames.TaskExecutionCreated, execution, cancellationToken);
var machineStatus = _activeTasksManager.ActiveCommands.GetOrAdd(id, _ => new TasksMachineStatus());
foreach (var commandInfo in _mazeTask.Commands)
{
await ExecuteCommand(id, services, commandInfo, machineStatus, execution.TaskExecutionId, cancellationToken);
}
}
private void OnTaskExecutionCreated(TaskExecutionDto obj)
{
if (obj.TaskReferenceId != _taskId)
{
return;
}
_dispatcher.Current.BeginInvoke(new Action(() =>
{
if (!_sessions.TryGetValue(obj.TaskSessionId, out var taskSession))
{
return;
}
if (taskSession.Executions == null)
{
taskSession.Executions = new ObservableCollection <TaskExecutionViewModel>();
}
var execution = new TaskExecutionViewModel(obj);
_executions.Add(execution.TaskExecutionId, execution);
taskSession.Executions.Add(execution);
}));
}
Task <bool> ITaskResultStorage.CreateTaskExecution(TaskExecutionDto taskExecution)
{
lock (_executionsLock)
{
Executions.Add(taskExecution);
}
return(Task.FromResult(true));
}
public async Task <IActionResult> CreateExecution([FromBody] TaskExecutionDto taskExecutionDto, [FromServices] ICreateTaskExecutionAction action)
{
taskExecutionDto.TargetId = User.GetClientId();
await action.BizActionAsync(taskExecutionDto);
return(await BizActionStatus(action, async() =>
{
await _hubContext.Clients.All.SendAsync(HubEventNames.TaskExecutionCreated, taskExecutionDto);
return Ok();
}));
}
public async Task <bool> CreateTaskExecution(TaskExecutionDto taskExecution)
{
var action = _serviceProvider.GetRequiredService <ICreateTaskExecutionAction>();
await action.BizActionAsync(taskExecution);
if (action.HasErrors)
{
_logger.LogError("An error occurred when trying to execute {action}: {error}", action.GetType().Name,
action.Errors.First().ErrorMessage);
return(false);
}
return(true);
}
private void AddExecution(TaskExecutionDto taskExecutionDto, TargetId targetId)
{
if (taskExecutionDto.Validate(new ValidationContext(taskExecutionDto)).Any())
{
return;
}
if (taskExecutionDto.TaskReferenceId != _taskId)
{
return;
}
taskExecutionDto.TargetId = targetId.IsServer ? (int?)null : targetId.ClientId;
if (_executions.TryAdd(taskExecutionDto.TaskExecutionId, taskExecutionDto))
{
TaskExecutionAdded?.Invoke(this, taskExecutionDto);
}
}
private void BuilderOnTaskExecutionAdded(object sender, TaskExecutionDto e)
{
_hubContext.Clients.All.SendAsync(HubEventNames.TaskExecutionCreated, e);
}
public async Task <TaskExecution> BizActionAsync(TaskExecutionDto inputData)
{
if (ValidateModelFailed(inputData))
{
return(default);
