public void PlanMaintenanceJob(PlanMaintenanceJob command)
{
// check business rules
command.PlannedMaintenanceJobShouldFallWithinOneBusinessDay();
this.NumberOfParallelMaintenanceJobsMustNotExceedAvailableWorkStations(command);
this.NumberOfParallelMaintenanceJobsOnAVehicleMustNotExceedOne(command);
// handle event
MaintenanceJobPlanned e = command.MapToMaintenanceJobPlanned();
RaiseEvent(e);
}
public IEnumerable <Event> PlanMaintenanceJob(PlanMaintenanceJob command)
{
// check business rules
this.PlannedMaintenanceJobShouldFallWithinOneBusinessDay(command);
this.NumberOfParallelMaintenanceJobsMustNotExceedAvailableWorkStations(command);
this.NumberOfParallelMaintenanceJobsOnAVehicleIsOne(command);
// handle event
MaintenanceJobPlanned e = Mapper.Map <MaintenanceJobPlanned>(command);
return(HandleEvent(e));
}
public PlanMaintenanceJob Build()
{
var customer = CustomerBuilder
.Build();
var vehicle = VehicleBuilder
.WithOwnerId(customer.Id)
.Build();
var job = MaintenanceJobBuilder
.WithCustomer(customer)
.WithVehicle(vehicle)
.Build();
PlanMaintenanceJob command = new PlanMaintenanceJob(
Guid.NewGuid(), job.Id, job.PlannedTimeslot.StartTime, job.PlannedTimeslot.EndTime,
(customer.Id, customer.Name, customer.TelephoneNumber),
(vehicle.Id, vehicle.Brand, vehicle.Type),
job.Description
);
return(command);
}
public async Task <IActionResult> PlanMaintenanceJobAsync(DateTime date, [FromBody] PlanMaintenanceJob command)
{
try
{
if (ModelState.IsValid)
{
// get planning
WorkshopPlanning planning = await _planningRepo.GetWorkshopPlanningAsync(date);
if (planning == null)
{
return(NotFound());
}
// handle command
try
{
IEnumerable <Event> events = planning.PlanMaintenanceJob(command);
// persist
await _planningRepo.SaveWorkshopPlanningAsync(planning, events);
// publish event
foreach (var e in events)
{
await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");
}
// return result
return(CreatedAtRoute("GetByDate", new { date = planning.Date }, planning));
}
catch (BusinessRuleViolationException ex)
{
return(StatusCode(StatusCodes.Status409Conflict, new BusinessRuleViolation {
ErrorMessage = ex.Message
}));
}
}
return(BadRequest());
}
catch (ConcurrencyException)
{
ModelState.AddModelError("ErrorMessage", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.");
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public void PlanMaintenanceJob(PlanMaintenanceJob command)
{
// check business rules
command.PlannedMaintenanceJobShouldFallWithinOneBusinessDay();
this.NumberOfParallelMaintenanceJobsMustNotExceedAvailableWorkStations(command);
this.NumberOfParallelMaintenanceJobsOnAVehicleMustNotExceedOne(command);
// handle event
MaintenanceJobPlanned e = new MaintenanceJobPlanned(command.MessageId,
command.StartTime,
command.EndTime,
command.CustomerInfo,
command.VehicleInfo,
command.Description);
RaiseEvent(e);
}
public async Task <bool> HandleCommandAsync(DateTime calendarDate, PlanMaintenanceJob command)
{
bool isJobPlannedSuccessfully = false;
// get or create workshop-Calendar
//(WorkshopCalendar existingCalendar, IEnumerable<WorkshopCalendarEvent> existingEvents)
var(existingCalendar, existingEvents) = await _calendarRepo.GetWorkshopCalendarAsync(calendarDate);
WorkshopCalendarAggregateRoot workshopCalendar;
if (existingCalendar == null)
{
workshopCalendar = WorkshopCalendarAggregateRoot.Create(calendarDate);
}
else
{
//TODO: Map existingEvents to the root event so we can check the overlapping
//var activeEvents = existingEvents?.Where(e => e.ActualEndDateTime != null)?.ToList();
//if (activeEvents.Any())
//{
// events.Concat(activeEvents);
//}
workshopCalendar = new WorkshopCalendarAggregateRoot(calendarDate, new List <Event>());
}
// handle command
//TODO while planning for a new maintenance job, system should create new GUID for the new JOB
workshopCalendar.PlanMaintenanceJob(command);
IEnumerable <Event> events = workshopCalendar.GetEvents();
// persist
//TODO we shouldn't use events while save to database events should used only between context
//we should use Aggregate root instance values while validated by business rules
isJobPlannedSuccessfully = await _calendarRepo.SaveWorkshopCalendarAsync(workshopCalendar.Id, workshopCalendar.OriginalVersion, workshopCalendar.Version, events);
// publish event
foreach (var e in events)
{
await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");
}
// return result
return(isJobPlannedSuccessfully);
}
public async Task <IActionResult> PlanMaintenanceJobAsync(DateTime planningDate, [FromBody] PlanMaintenanceJob command)
{
try
{
if (ModelState.IsValid)
{
try
{
// handle command
WorkshopPlanning planning = await
_planMaintenanceJobCommandHandler.HandleCommandAsync(planningDate, command);
// handle result
if (planning == null)
{
return(NotFound());
}
// return result
return(CreatedAtRoute("GetByDate", new { planningDate = planning.Id }, planning.MapToDTO()));
}
catch (BusinessRuleViolationException ex)
{
return(StatusCode(StatusCodes.Status409Conflict, new BusinessRuleViolation {
ErrorMessage = ex.Message
}));
}
}
return(BadRequest());
}
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", errorMessage);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public void Planning_Too_Much_MaintenanceJobs_In_Parallel_Should_Throw_Exception()
{
// arrange
DateTime date = DateTime.Today;
var initializingEvents = new Event[] {
new WorkshopPlanningCreatedEventBuilder().WithDate(date).Build()
};
WorkshopPlanning sut = new WorkshopPlanning(date, initializingEvents);
VehicleBuilder vehicleBuilder = new VehicleBuilder();
PlanMaintenanceJobCommandBuilder commandBuilder = new PlanMaintenanceJobCommandBuilder()
.WithVehicleBuilder(vehicleBuilder);
PlanMaintenanceJob command1 = commandBuilder.Build();
vehicleBuilder.WithLicenseNumber(Guid.NewGuid().ToString());
PlanMaintenanceJob command2 = commandBuilder.Build();
vehicleBuilder.WithLicenseNumber(Guid.NewGuid().ToString());
PlanMaintenanceJob command3 = commandBuilder.Build();
vehicleBuilder.WithLicenseNumber(Guid.NewGuid().ToString());
PlanMaintenanceJob command4 = commandBuilder.Build();
// act
sut.PlanMaintenanceJob(command1);
sut.PlanMaintenanceJob(command2);
sut.PlanMaintenanceJob(command3);
var thrownException = Assert.Throws <BusinessRuleViolationException>(() =>
{
sut.PlanMaintenanceJob(command4); // 4th parallel job
});
// assert
Assert.Equal("Maintenancejob overlaps with more than 3 other jobs.",
thrownException.Message);
}
public async Task PlanMaintenanceJob(string planningDate, PlanMaintenanceJob cmd)
{
await _restClient.PlanMaintenanceJob(planningDate, cmd);
}
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, PlanMaintenanceJob command)
{
List <Event> events = new List <Event>();
// get or create workshop-planning
WorkshopPlanning planning = await _planningRepo.GetWorkshopPlanningAsync(planningDate);
if (planning == null)
{
events.AddRange(WorkshopPlanning.Create(planningDate, out planning));
}
// handle command
events.AddRange(planning.PlanMaintenanceJob(command));
// persist
await _planningRepo.SaveWorkshopPlanningAsync(
planning.Id, planning.OriginalVersion, planning.Version, events);
// publish event
foreach (var e in events)
{
await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");
}
// return result
return(planning);
}
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, PlanMaintenanceJob command)
{
// get or create workshop-planning
var aggregateId = WorkshopPlanningId.Create(planningDate);
var planning = await _planningRepo.GetByIdAsync(aggregateId);
if (planning == null)
{
planning = WorkshopPlanning.Create(planningDate);
}
// handle command
planning.PlanMaintenanceJob(command);
// persist
IEnumerable <Event> events = planning.GetEvents();
await _planningRepo.SaveAsync(
planning.Id, planning.OriginalVersion, planning.Version, events);
// publish event
foreach (var e in events)
{
await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");
}
// return result
return(planning);
}
public async Task PlanMaintenanceJob(string date, PlanMaintenanceJob cmd)
{
await _client.PlanMaintenanceJob(date, cmd);
}
public async Task <IActionResult> PlanMaintenanceJobAsync(DateTime calendarDate, [FromBody] PlanMaintenanceJob command)
{
try
{
if (ModelState.IsValid)
{
try
{
// handle command
var plannedSuccessfully = await _planMaintenanceJobCommandHandler.HandleCommandAsync(calendarDate, command);
// handle result
if (!plannedSuccessfully)
{
return(NotFound());
}
// return result
return(Ok(plannedSuccessfully));
}
catch (BusinessRuleViolationException ex)
{
return(StatusCode(StatusCodes.Status409Conflict, new ViolationModel {
ErrorMessage = ex.Message
}));
}
}
return(BadRequest());
}
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", errorMessage);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, PlanMaintenanceJob command)
{
// get planning
WorkshopPlanning planning = await _planningRepo.GetWorkshopPlanningAsync(planningDate);
if (planning == null)
{
return(null);
}
// handle command
IEnumerable <Event> events = planning.PlanMaintenanceJob(command);
// persist
await _planningRepo.SaveWorkshopPlanningAsync(planning, events);
// publish event
foreach (var e in events)
{
await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");
}
// return result
return(planning);
}
