public IEnumerable <Event> RegisterPlanning(RegisterPlanning cmd)
{
List <Event> events = new List <Event>();
WorkshopPlanningCreated e = new WorkshopPlanningCreated(Guid.NewGuid(), Date = cmd.PlanningDate);
events.AddRange(Handle(e));
return(events);
}
public async Task <IActionResult> RegisterMaintenanceJob([FromForm] WorkshopManagementNewViewModel inputModel)
{
if (ModelState.IsValid)
{
return(await _resiliencyHelper.ExecuteResilient(async() =>
{
string dateStr = inputModel.Date.ToString("yyyy-MM-dd");
try
{
// get or create planning for date
var planning = await _workshopManagementAPI.GetWorkshopPlanning(dateStr);
if (planning == null)
{
// create planning for date
RegisterPlanning registerPlanningCommand =
new RegisterPlanning(Guid.NewGuid(), inputModel.Date);
await _workshopManagementAPI.RegisterPlanning(dateStr, registerPlanningCommand);
}
// register maintenance job
DateTime startTime = inputModel.Date.Add(inputModel.StartTime.TimeOfDay);
DateTime endTime = inputModel.Date.Add(inputModel.EndTime.TimeOfDay);
Vehicle vehicle = await _workshopManagementAPI.GetVehicleByLicenseNumber(inputModel.SelectedVehicleLicenseNumber);
Customer customer = await _workshopManagementAPI.GetCustomerById(vehicle.OwnerId);
PlanMaintenanceJob planMaintenanceJobCommand = new PlanMaintenanceJob(Guid.NewGuid(), Guid.NewGuid(), startTime, endTime,
(customer.CustomerId, customer.Name, customer.TelephoneNumber),
(vehicle.LicenseNumber, vehicle.Brand, vehicle.Type), inputModel.Description);
await _workshopManagementAPI.PlanMaintenanceJob(dateStr, planMaintenanceJobCommand);
}
catch (ApiException ex)
{
if (ex.StatusCode == HttpStatusCode.Conflict)
{
// add errormessage from API exception to model
var content = ex.GetContentAs <BusinessRuleViolation>();
inputModel.Error = content.ErrorMessage;
// repopulate list of available vehicles in the model
inputModel.Vehicles = await GetAvailableVehiclesList();
// back to New view
return View("New", inputModel);
}
}
return RedirectToAction("Index", new { planningDate = dateStr });
}, View("Offline", new WorkshopManagementOfflineViewModel())));
}
else
{
inputModel.Vehicles = await GetAvailableVehiclesList();
return(View("New", inputModel));
}
}
public async Task RegisterPlanning(string planningDate, RegisterPlanning cmd)
{
await _restClient.RegisterPlanning(planningDate, cmd);
}
public async Task <IActionResult> RegisterPlanningAsync(DateTime planningDate, [FromBody] RegisterPlanning cmd)
{
try
{
// handle command
WorkshopPlanning planning = await
_serviceProvider.GetRequiredService <IRegisterPlanningCommandHandler>()
.HandleCommandAsync(planningDate, cmd);
// return result
return(CreatedAtRoute("GetByDate", new { planningDate = planning.Date }, planning));
}
catch (ConcurrencyException)
{
string errorMessage = "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.";
Log.Error(errorMessage);
ModelState.AddModelError("", errorMessage);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, RegisterPlanning command)
{
WorkshopPlanning planning = new WorkshopPlanning();
// handle command
IEnumerable <Event> events = planning.RegisterPlanning(command);
// persist
await _planningRepo.SaveWorkshopPlanningAsync(planning, events);
// publish event
foreach (var e in events)
{
await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");
}
// return result
return(planning);
}
