public AdditionalCommandEditViewModel(INavigator navigator, AdditionalApplicationModel model, Action <AdditionalApplicationModel> onSaved)
{
if (model != null)
{
IsNameChanged = true;
Name = model.Name;
Path = model.Path;
Arguments = model.Arguments;
HotKey = model.HotKey == Key.None
? null
: new KeyViewModel(model.HotKey, ModifierKeys.None);
}
saveCommand = new SaveApplicationCommand(this, model, onSaved, true);
}
public AdditionalApplicationEditViewModel(INavigator navigator, AdditionalApplicationModel model, Action <AdditionalApplicationModel> onSaved)
{
Commands = new ObservableCollection <AdditionalApplicationListViewModel>();
if (model != null)
{
IsNameChanged = true;
Name = model.Name;
Path = model.Path;
Arguments = model.Arguments;
HotKey = model.HotKey == Key.None
? null
: new KeyViewModel(model.HotKey, ModifierKeys.None);
Commands.AddRange(model.Commands.Select(m => new AdditionalApplicationListViewModel(m)));
}
saveCommand = new SaveApplicationCommand(this, model, onSaved);
EditAdditionalApplicationCommand = new EditAdditionalCommandCommand(this, navigator);
RemoveAdditionalApplicationCommand = new RemoveAdditionalCommandCommand(this);
CreateCommand = new CreateAdditionalCommandCommand(this, navigator);
}
public async Task RunOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context,
[DurableClient] IDurableOrchestrationClient processStarter,
ILogger log)
{
log.LogInformation($"Starting orchestration of application process with instance id: {context.InstanceId}");
var beginProcessCommand = this.BuildBeginProcessCommand(context);
await context.CallActivityAsync <Task>(nameof(StatusTracker), beginProcessCommand);
var command = context.GetInput <RegisterApplicationCommand>();
var uploadCvCommand = new UploadCvCommand(
command.Cv.File,
command.Cv.ContentType,
command.Cv.Extension);
var uploadPhotoCommand = new UploadPhotoCommand(
command.Photo.File,
command.Photo.ContentType,
command.Photo.Extension);
await Task.WhenAll(
context.CallActivityAsync <Task>(nameof(CvUploader), uploadCvCommand),
context.CallActivityAsync <Task>(nameof(PhotoUploader), uploadPhotoCommand));
var cvUploadedEventTask = context.WaitForExternalEvent <CvUploadedInternalFunctionEvent>(nameof(CvUploadedInternalFunctionEvent));
var cvUploadFailedEventTask = context.WaitForExternalEvent <CvUploadFailedInternalFunctionEvent>(nameof(CvUploadFailedInternalFunctionEvent));
var photoUploadedEventTask = context.WaitForExternalEvent <PhotoUploadedInternalFunctionEvent>(nameof(PhotoUploadedInternalFunctionEvent));
var photoUploadFailedEventTask = context.WaitForExternalEvent <PhotoUploadFailedInternalFunctionEvent>(nameof(PhotoUploadFailedInternalFunctionEvent));
var cvUploadEventTask = await Task.WhenAny(cvUploadedEventTask, cvUploadFailedEventTask);
var photoUploadEventTask = await Task.WhenAny(photoUploadedEventTask, photoUploadFailedEventTask);
var cvUploadedSuccessfully = cvUploadEventTask == cvUploadedEventTask;
var photoUploadedSuccessfully = photoUploadEventTask == photoUploadedEventTask;
if (!cvUploadedSuccessfully || !photoUploadedSuccessfully)
{
await this.HandleUploadFilesFailure(
context,
processStarter,
log,
photoUploadFailedEventTask,
cvUploadFailedEventTask,
command);
return;
}
log.LogInformation($"Finished the files uploading in instanceId: {context.InstanceId}");
var cvUri = cvUploadedEventTask.Result.CvUri;
var photoUri = photoUploadedEventTask.Result.PhotoUri;
var saveApplicationCommand = new SaveApplicationCommand(
context.InstanceId,
command.Candidate.FirstName,
command.Candidate.LastName,
photoUri,
cvUri,
command.Candidate.Category,
command.CreationTime,
command.Candidate.EducationLevel,
command.Candidate.Address,
command.Candidate.FinishedSchools,
command.Candidate.ConfirmedSkills,
command.Candidate.WorkExperiences);
await context.CallActivityAsync <Task>(nameof(ApplicationSaver), saveApplicationCommand);
var applicationSavedEvent = context.WaitForExternalEvent <ApplicationSavedInternalFunctionEvent>(nameof(ApplicationSavedInternalFunctionEvent));
var applicationSaveFailed = context.WaitForExternalEvent <ApplicationSaveFailedInternalFunctionEvent>(nameof(ApplicationSaveFailedInternalFunctionEvent));
var applicationSaveEvent = await Task.WhenAny(applicationSavedEvent, applicationSaveFailed);
var applicationSavedSuccessfully = applicationSaveEvent == applicationSavedEvent;
if (!applicationSavedSuccessfully)
{
log.LogError($"Storing application failed with instance id: {context.InstanceId}");
var failedProcessCommand = this.BuildFailedProcessCommand(context, applicationSaveFailed.Result.Errors);
await context.CallActivityAsync <Task>(nameof(StatusTracker), failedProcessCommand);
await this.StartRecompensateProcess(processStarter, context, command, log);
return;
}
var finishProcessCommand = this.BuildFinishedProcessCommand(context);
await context.CallActivityAsync <Task>(nameof(StatusTracker), finishProcessCommand);
log.LogInformation($"Application process finished: {context.InstanceId}");
await context.CallActivityAsync <Task>(nameof(ApplicationProcessFinishedEventPublisher), saveApplicationCommand);
}
