public async Task <ActionResult> Put([FromRoute] Guid plantId, Guid id, [FromBody] UpdatePlantEventViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
UpdatePlantEventModel updateEventModel = _mapper.Map <UpdatePlantEventModel>(model);
updateEventModel.Id = id;
Event @event = await _commands.Update(plantId, updateEventModel);
if (@event is null)
{
return(NotFound());
}
return(Ok(_mapper.Map <PlantEventDetailsViewModel>(@event)));
}
catch (Exception ex) when(ex is ResourceNotFoundException)
{
return(NotFound(new ErrorViewModel(ex)));
}
catch (Exception ex) when(ex is ResourceStateException)
{
return(Conflict(new ErrorViewModel(ex)));
}
}
public void UpdatePlantEventThrowsExceptionIfPlantDoesNotExist()
{
// Given
UpdatePlantEventModel model = ModelFactory.UpdateModel(Guid.NewGuid());
// When
Func <Task> updateEvent = async() => await _commands.Update(Guid.NewGuid(), model);
// Then
updateEvent.Should().Throw <PlantNotFoundException>();
}
public async Task UpdatePlantEventReturnsNullIfEventDoesNotExist()
{
// Given
Plant plant = Plants.ModelFactory.DomainModel();
Guid plantId = SeedDatabase(plant);
UpdatePlantEventModel model = ModelFactory.UpdateModel();
// When
Event @event = await _commands.Update(plantId, model);
// Then
@event.Should().BeNull();
}
public void UpdatePlantEventThrowsExceptionIfEventTypeWasChangedToAutomaticallyCreated()
{
// Given
Plant plant = Plants.ModelFactory.DomainModel();
Guid plantId = SeedDatabase(plant);
Event @event = ModelFactory.DomainModel(plant);
Guid eventId = SeedDatabase(@event);
UpdatePlantEventModel model = ModelFactory.UpdateModel(eventId, type: EventType.Start);
// When
Func <Task> updateEvent = async() => await _commands.Update(plantId, model);
// Then
updateEvent.Should().Throw <EventTypeChangedToIllegalException>();
}
public void UpdatePlantEventThrowsExceptionIfOccurenceDateIsInTheFuture()
{
// Given
Plant plant = Plants.ModelFactory.DomainModel();
Guid plantId = SeedDatabase(plant);
Event @event = ModelFactory.DomainModel(plant);
Guid eventId = SeedDatabase(@event);
UpdatePlantEventModel model = ModelFactory.UpdateModel(eventId, DateTime.Now.AddDays(1));
// When
Func <Task> updateEvent = async() => await _commands.Update(plantId, model);
// Then
updateEvent.Should().Throw <EventOccurenceDateBeforePlantDateOrInTheFutureException>();
}
public void UpdatePlantEventThrowsExceptionIfEventTypeWasChangedFromAutomaticallyCreated()
{
// Given
Plant plant = Plants.ModelFactory.DomainModel();
Event startEvent = plant.Events.First(x => x.Type == EventType.Start);
plant.Events.Add(startEvent);
Guid plantId = SeedDatabase(plant);
Guid eventId = startEvent.Id;
UpdatePlantEventModel model = ModelFactory.UpdateModel(eventId, type: EventType.Fungi);
// When
Func <Task> updateEvent = async() => await _commands.Update(plantId, model);
// Then
updateEvent.Should().Throw <EventTypeChangedFromIllegalException>();
}
public async Task UpdatePlantEventWithDifferentTypeReturnsEventOnSuccess()
{
// Given
Plant plant = Plants.ModelFactory.DomainModel();
Guid plantId = SeedDatabase(plant);
Event @event = ModelFactory.DomainModel(plant);
Guid eventId = SeedDatabase(@event);
UpdatePlantEventModel model = ModelFactory.UpdateModel(eventId);
// When
@event = await _commands.Update(plantId, model);
// Then
@event.Should().NotBeNull();
@event.Id.Should().Be(eventId);
@event.Plant.Id.Should().Be(plant.Id);
}
public async Task <Event> Update(Guid plantId, UpdatePlantEventModel model)
{
Plant plant = await _database.Plants.Include(x => x.Events)
.FirstOrDefaultAsync(x => x.Id == plantId);
if (plant is null)
{
throw new PlantNotFoundException(plantId);
}
Event @event = plant.Events.FirstOrDefault(x => x.Id == model.Id);
if (@event is null)
{
return(null);
}
if (EventOccuredBeforePlantedOrInTheFuture(plant, model.Occured))
{
throw new EventOccurenceDateBeforePlantDateOrInTheFutureException();
}
if (@event.Type != model.Type)
{
if ([email protected]())
{
throw new EventTypeChangedFromIllegalException(@event.Type);
}
if (!model.Type.IsChangeable())
{
throw new EventTypeChangedToIllegalException(model.Type);
}
}
_mapper.Map(model, @event);
@event.Plant = plant;
_database.Events.Update(@event);
await _database.SaveAsync();
return(@event);
}
