public async Task <IActionResult> OnPostCandidateAcceptedTrainingInvitation()
{
PurgeAllErrorsExceptConcerningPostCommand(nameof(RecordAcceptedTrainingInvitationCommand));
return(await _engine.Execute(RecordAcceptedTrainingInvitationCommand)
.OnFailure(error => ModelState.AddModelErrors(error, nameof(RecordAcceptedTrainingInvitationCommand)))
.Finally(_ => RedirectToPage(Route, new { enrollmentId = RecordAcceptedTrainingInvitationCommand.EnrollmentId }).WithModelStateOf(this)));
}
public async Task <Result <Nothing, Error> > Handle(RecordAcceptedTrainingInvitation.Command request, CancellationToken cancellationToken)
{
var user = await _userAccessor.GetUser();
var enrollmentId = EnrollmentId.With(request.EnrollmentId);
var enrollmentReadModel = _enrollmentRepo.Query()
.SingleOrDefault(x => x.Id == enrollmentId);
if (enrollmentReadModel == null)
{
return(Result.Failure <Nothing, Error>(new Error.ResourceNotFound()));
}
var preferredTrainings = await _trainingRepository.GetByIds(enrollmentReadModel.PreferredTrainings.Select(x => x.ID).ToArray());
var result = await _aggregateStore.Update <EnrollmentAggregate, EnrollmentId, Result <Nothing, Error> >(
enrollmentId, CommandId.New,
(aggregate) => aggregate.RecordCandidateAcceptedTrainingInvitation(request, user, preferredTrainings, _clock.GetCurrentInstant()),
cancellationToken);
if (result.Unwrap().IsSuccess)
{
var selectedTraining = preferredTrainings.Single(x => x.ID == request.SelectedTrainingID);
_backgroundJobClient.Schedule(() => _engine.Execute(
new SendTrainingReminder.Command()
{
EnrollmentId = request.EnrollmentId, TrainingId = request.SelectedTrainingID
}),
selectedTraining.StartDateTime.Minus(NodaTime.Duration.FromHours(24)).ToDateTimeOffset());
}
return(result.Unwrap());
}
public async Task <IActionResult> OnPostAddNote()
{
await _engine.Execute(AddNoteCommand)
.OnFailure(error => ModelState.AddModelErrors(error, nameof(AddNoteCommand)));
return(await OnGet(AddNoteCommand.TrainingId));
}
public async Task <IActionResult> OnPost()
{
var result = await _engine.Execute(Command);
return(result.Match <Guid, IActionResult, Domain.Error>(
guid => RedirectToPage(DetailsModel.Route, new { schoolId = guid }),
error => Page()
));
}
public async Task <IActionResult> OnPostResignFromProject()
{
ResignCommand.CommunicationChannel = CommunicationChannel.IncomingApiRequest;
var result = await _engine.Execute(ResignCommand);
return(result.Match <Nothing, IActionResult, Error>(
success => { return RedirectToPage("/Index"); },
failure => { ModelState.AddModelError(string.Empty, failure.Message); return RedirectToPage("/Index"); }
));
}
public async Task <IActionResult> OnPostCreateRecruitmentCampaign()
{
var result = await _engine.Execute(CreateRecruitmentCampaignCommand);
if (result.IsFailure)
{
CommonPageModelExtensions.AddModelErrors(ModelState, result.Error);
}
return(await OnGet(CreateRecruitmentCampaignCommand.EditionID));
}
public async Task <IActionResult> OnPostScheduleTraining()
{
var result = await _engine.Execute(ScheduleTrainingCommand);
if (result.IsFailure)
{
ModelState.AddModelErrors(result.Error, nameof(ScheduleTrainingCommand));
}
await OnGet();
return(Page());
}
public async Task <IActionResult> OnPost()
{
var result = await _engine.Execute(Command);
if (result.IsFailure)
{
CommonPageModelExtensions.AddModelErrors(ModelState, result.Error);
return(await OnGet(CampaignID));
}
else
{
return(RedirectToPage(RecruitmentFormSubmittedModel.PageName, new { email = Command.Email.ToString() }));
}
}
public async Task <IActionResult> OnPostGrantRole()
{
await _app.Execute(GrantRoleCommand);
return(await OnGet(GrantRoleCommand.UserID));
}
public async Task <IActionResult> Create(SubmitRecruitmentForm.Command command)
{
var result = await _engine.Execute(command);
return(result.MatchToActionResult(success => Ok()));
}
public async Task <IActionResult> Create(Create.Command command)
{
var result = await _engine.Execute(command);
return(result.MatchToActionResult(v => Created(Routes.v1.RecruitmentCampaigns.DetailsFor(v.ID), null)));
}
public async Task <IActionResult> Register(RegisterSchool.Command command)
{
var result = await _engine.Execute(command);
return(result.MatchToActionResult(success => Ok(success)));
}
public async Task <IActionResult> Create(CreateUseCase.Command command)
{
var result = await _engine.Execute(command);
return(result.MatchToActionResult(s => Created(Routes.v1.Editions.DetailsFor(s.Id), null)));
}