public async Task HandleAsync(ReserveResource command)
{
var identity = _appContext.Identity;
if (identity.IsAuthenticated && identity.Id != command.CustomerId && !identity.IsAdmin)
{
throw new UnauthorizedResourceAccessException(command.ResourceId, identity.Id);
}
var resource = await _repository.GetAsync(command.ResourceId);
if (resource is null)
{
throw new ResourceNotFoundException(command.ResourceId);
}
var customerState = await _customersServiceClient.GetStateAsync(command.CustomerId);
if (customerState is null)
{
throw new CustomerNotFoundException(command.CustomerId);
}
if (!customerState.IsValid)
{
throw new InvalidCustomerStateException(command.ResourceId, customerState?.State);
}
var reservation = new Reservation(command.DateTime, command.Priority);
resource.AddReservation(reservation);
await _repository.UpdateAsync(resource);
await _eventProcessor.ProcessAsync(resource.Events);
}
public async Task HandleAsync(AddResource command)
{
if (await _repository.ExistsAsync(command.ResourceId))
{
throw new ResourceAlreadyExistsException(command.ResourceId);
}
var resource = Resource.Create(command.ResourceId, command.Tags);
await _repository.AddAsync(resource);
await _eventProcessor.ProcessAsync(resource.Events);
}
public async Task <Unit> Handle(CreateStockItemCommand request, CancellationToken cancellationToken)
{
if (await _repository.ExistsAsync(request.Id))
{
throw new ItemAlreadyExistsException(request.Id);
}
var item = Domain.Entities.Item.Create(request.Id, request.Amount);
await _repository.AddAsync(item);
await _eventProcessor.ProcessAsync(item.Events);
return(Unit.Value);
}
public async Task HandleAsync(AddTrip command)
{
if (await _tripRepository.ExistsAsync(command.TripId))
{
throw new TripAlreadyExistsException(command.TripId);
}
var trip = Core.Entities.Trip.Create(command.TripId, command.Destination, command.Date,
command.DifficultyLevel);
await _tripRepository.AddAsync(trip);
await _eventProcessor.ProcessAsync(trip.Events);
}
public async Task HandleAsync(JoinToTrip command)
{
var trip = await _tripRepository.GetAsync(command.TripId);
var participant = new Participant(command.UserId);
trip.AddParticipant(participant);
await _tripRepository.UpdateAsync(trip);
var trip2 = await _tripRepository.GetAsync(command.TripId);
await _eventProcessor.ProcessAsync(trip.Events);
}
private async Task ChangeReservationStatus(Guid id, ReservationStatus status)
{
var reservation = await _repository.GetAsync(id);
if (reservation is null)
{
throw new ReservationNotFoundException(id);
}
reservation.ChangeStatus(status);
await _repository.UpdateAsync(reservation);
await _processor.ProcessAsync(reservation.DomainEvents);
}
public async Task HandleAsync(CreateScheduleSchema command)
{
var alreadyExists = await _repository.ExistsAsync(command.CinemaId);
if (alreadyExists)
{
throw new ScheduleSchemaAlreadyExistsException(command.CinemaId);
}
var scheduleSchema = ScheduleSchema.Create(command.Id, command.CinemaId, command.Times.AsScheduleSchemaTimes());
await _repository.AddAsync(scheduleSchema);
await _processor.ProcessAsync(scheduleSchema.DomainEvents);
}
public async Task <Unit> Handle(CreateItemCommand request, CancellationToken cancellationToken)
{
if (await _repository.ExistsAsync(request.Id))
{
throw new ItemAlreadyExistsException(request.Id);
}
request.Id = request.Id == Guid.Empty ? Guid.NewGuid() : request.Id;
var item = Item.Create(request.Id, request.Category, request.Name, request.Description, request.Tags, request.UnitPrice);
await _repository.AddAsync(item);
await _eventProcessor.ProcessAsync(item.Events);
return(Unit.Value);
}
public async Task HandleAsync(DeleteResource command)
{
var resource = await _repository.GetAsync(command.ResourceId);
if (resource is null)
{
throw new ResourceNotFoundException(command.ResourceId);
}
resource.Delete();
await _repository.DeleteAsync(resource.Id);
await _eventProcessor.ProcessAsync(resource.Events);
}
public async Task <Unit> Handle(DeleteStockItemCommand request, CancellationToken cancellationToken)
{
var item = await _repository.GetAsync(request.Id);
if (item is null)
{
throw new ItemNotFoundException(request.Id);
}
item.Delete(item);
await _repository.DeleteAsync(item.Id);
await _eventProcessor.ProcessAsync(item.Events);
return(Unit.Value);
}
public async Task <Unit> Handle(StockItemStockDownCommand request, CancellationToken cancellationToken)
{
var item = await _repository.GetAsync(request.Id);
if (item is null)
{
throw new ItemNotFoundException(request.Id);
}
var updatedItem = Domain.Entities.Item.Pop(item, request.Amount);
await _repository.UpdateAsync(updatedItem);
await _eventProcessor.ProcessAsync(updatedItem.Events);
return(Unit.Value);
}
public async Task <Unit> Handle(UpdateItemCommand request, CancellationToken cancellationToken)
{
var item = await _repository.GetAsync(request.Id);
if (item is null)
{
throw new ItemNotFoundException(request.Id);
}
var updatedItem = Item.Update(item, request.Category, request.Name, request.Description, request.Tags, request.UnitPrice);
await _repository.UpdateAsync(updatedItem);
await _eventProcessor.ProcessAsync(updatedItem.Events);
return(Unit.Value);
}
public async Task HandleAsync(UpdateScheduleSchema command)
{
var schema = await _repository.GetAsync(command.Id);
if (schema is null)
{
throw new ScheduleSchemaNotFoundException(command.Id);
}
schema.ChangeTimes(command.Times.AsScheduleSchemaTimes());
await _repository.UpdateAsync(schema);
await _processor.ProcessAsync(schema.DomainEvents);
}
public async Task HandleAsync(ReleaseResourceReservation command)
{
var resource = await _repository.GetAsync(command.ResourceId);
if (resource is null)
{
throw new ResourceNotFoundException(command.ResourceId);
}
var reservation = resource.Reservations.FirstOrDefault(r => r.DateTime.Date == command.DateTime.Date);
resource.ReleaseReservation(reservation);
await _repository.UpdateAsync(resource);
await _eventProcessor.ProcessAsync(resource.Events);
}
public async Task HandleAsync(CreateReservation command)
{
if (await _repository.ExistsAsync(command.Id))
{
throw new ReservationAlreadyExistsException(command.Id);
}
var seats = command.Seats.AsValueObjects();
var reservee = command.Reservee.AsValueObject();
var reservation = await _factory.CreateAsync(command.Id, command.CinemaId, command.MovieId, command.HallId,
command.CustomerId, command.DateTime, command.IsPaymentUponArrival, seats, reservee);
await _repository.AddAsync(reservation);
await _processor.ProcessAsync(reservation.DomainEvents);
}
public async Task HandleAsync(GenerateSchedule command)
{
var alreadyExists = await _repository.ExistsAsync(command.CinemaId, command.MovieId);
if (alreadyExists)
{
throw new ScheduleAlreadyExistsException(command.CinemaId, command.MovieId);
}
var movie = await _client.GetAsync(command.MovieId);
if (movie is null)
{
throw new MovieNotFoundException(command.MovieId);
}
var schedule = await _policy.GenerateScheduleAsync(command.Id, command.CinemaId, command.MovieId,
command.From, command.To, movie.AgeRestriction);
await _repository.AddAsync(schedule);
await _processor.ProcessAsync(schedule.DomainEvents);
}
private Task ProcessEventAsync <TEvent>(TEvent @event, ConceptContext context) where TEvent : EventBase => _eventProcessor.ProcessAsync(@event);