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); }