public async Task <ClassTypeDto> Handle(DeleteClassTypeCommand request, CancellationToken cancellationToken)
{
var classTypeEntity = await _dbContext
.ClassTypes
.SingleOrDefaultAsync(m => m.ClassTypeId == request.ClassTypeId, cancellationToken);
classTypeEntity.IsDeleted = true;
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var timetablesList = await _dbContext
.Timetables
.Where(x => x.ClassTypeId == request.ClassTypeId && x.EndingDate > DateTime.Today)
.ToListAsync(cancellationToken);
var classGenerator = new ClassGenerator(_dbContext);
foreach (var timetable in timetablesList)
{
await classGenerator.DeleteAllFutureClassesByTimetableIdAsync(timetable, cancellationToken);
timetable.EndingDate = DateTime.Today;
}
await _dbContext.SaveChangesAsync(cancellationToken);
var classTypeDto = classTypeEntity.Adapt <ClassTypeDto>();
return(classTypeDto);
}
public async Task <CalendarEntrie> AddEntrieAsync(CalendarEntrie entrie)
{
var entityEntry = await _dbContext.calendarEntries.AddAsync(entrie);
await _dbContext.SaveChangesAsync();
return(entityEntry.Entity);
}
public async Task <IActionResult> Create([Bind("Id,Title,StartDate,EndDate")] Calendar calendar)
{
if (ModelState.IsValid)
{
_context.Add(calendar);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(calendar));
}
public async Task <TimetableDto> Handle(AddTimetableCommand request, CancellationToken cancellationToken)
{
var timetableEntity = request.NewTimetableDto.Adapt <Timetable>();
_ = await _dbContext.AddAsync(timetableEntity, cancellationToken);
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var newTimetable = _dbContext
.Timetables
.Where(m => m.ClassTypeId == request.NewTimetableDto.ClassTypeId)
.AsEnumerable()
.LastOrDefault();
if (newTimetable is null)
{
throw new NullReferenceException("Failed to add timetable. Try again");
}
var classGenerator = new ClassGenerator(_dbContext);
await classGenerator.AddClassesForTimetableAsync(timetableEntity, cancellationToken);
var newTimetableDto = newTimetable.Adapt <TimetableDto>();
return(newTimetableDto);
}
public async Task Handle_RemoveCalendarEvent_WhenItExists()
{
var calendarEvent = new CalendarEvent(
"Music fetival",
DateTimeOffset.Now.ToUnixTimeSeconds(),
"Oosterpark, Amsterdam ",
"Rafael Caviquioli"
);
calendarEvent.AddMember("Aleida");
_context.Add(calendarEvent);
await _context.SaveChangesAsync();
_context.DetachAllEntities();
var command = new RemoveCalendarEventCommand(calendarEvent.Id);
var handler = new RemoveCalendarEventCommandHandler(_calendarEventRepository);
await handler.Handle(command, CancellationToken.None);
var calendarEventExpected = await _context.CalendarEvents
.FirstOrDefaultAsync(ce => ce.Id == calendarEvent.Id);
calendarEventExpected
.Should().BeNull("Because calendar event was removed from database");
}
public async Task <ReservationDtoSetter> Handle(SignUpForClassCommand request, CancellationToken cancellationToken)
{
var reservationEntity = request.Reservation.Adapt <Reservation>();
if (await IsLimitExceeded(reservationEntity, cancellationToken))
{
throw new ArgumentException(
$"Limit of participants for this classes has been exceeded [Limit: {_classTypeParticipantsLimit}]");
}
_ = await _dbContext.AddAsync(reservationEntity, cancellationToken);
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var newReservation = await _dbContext
.Reservations
.SingleOrDefaultAsync(
m => m.ClassId == reservationEntity.ClassId && m.MemberId == reservationEntity.MemberId,
cancellationToken);
if (newReservation is null)
{
throw new NullReferenceException("Failed to sign in for classes. Try again");
}
_signUpForClassSender.AddReservation(newReservation);
var newReservationDto = newReservation.Adapt <ReservationDtoSetter>();
return(newReservationDto);
}
public async Task Save(CalendarEvent calendarEvent)
{
var entity = await _context.CalendarEvents
.AsNoTracking()
.FirstOrDefaultAsync(u => u.Id == calendarEvent.Id);
var entityAlreadyExists = entity != null;
if (entityAlreadyExists)
{
_context.Update(calendarEvent);
}
else
{
_context.Add(calendarEvent);
}
await _context.SaveChangesAsync();
}
public async Task AddClassesForTimetableAsync(Timetable timetable, CancellationToken cancellationToken = default)
{
var timetableStartingDate = timetable.StartingDate;
var classTypeEntity = await _dbContext
.ClassTypes
.SingleOrDefaultAsync(m => m.ClassTypeId == timetable.ClassTypeId, cancellationToken);
var classesStartingTime = timetable.ClassesStartingTime;
var classDate = timetableStartingDate;
var classesDto = new CalendarClassDto {
Date = classDate
};
while (classDate >= timetableStartingDate && classDate <= timetable.EndingDate)
{
if (classDate == timetableStartingDate)
{
classesDto.ClassName = classTypeEntity.Name;
classesDto.ClassTypeId = timetable.ClassTypeId;
classesDto.StartingTime = classesStartingTime;
classesDto.EndingTime = classesStartingTime.AddMinutes(classTypeEntity.Duration);
classesDto.TimetableId = timetable.TimetableId;
}
else
{
classesDto.Date = classDate;
}
var classEntity = classesDto.Adapt <CalendarClass>();
_ = await _dbContext.AddAsync(classEntity, cancellationToken);
classDate = CalculateNextClassDate(classDate, timetable);
}
_ = await _dbContext.SaveChangesAsync(cancellationToken);
}
public async Task <CalendarClassDto> Handle(DeleteClassByIdCommand request, CancellationToken cancellationToken)
{
var classEntity = await _dbContext
.Classes
.SingleOrDefaultAsync(m => m.ClassId == request.ClassId, cancellationToken);
_dbContext.Remove(classEntity);
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var deletedReservationsForClass = await _dbContext.Reservations
.Where(x => x.ClassId == request.ClassId)
.ToListAsync(cancellationToken);
foreach (var reservation in deletedReservationsForClass)
{
_ = _dbContext.Remove(reservation);
}
_ = _dbContext.SaveChangesAsync(cancellationToken);
var classDto = classEntity.Adapt <CalendarClassDto>();
return(classDto);
}
public async Task <ReservationDtoSetter> Handle(SignOutOfClassCommand request, CancellationToken cancellationToken)
{
var reservationEntity = await _dbContext
.Reservations
.SingleOrDefaultAsync(m => m.ReservationId == request.ReservationId, cancellationToken);
_ = _dbContext.Remove(reservationEntity);
_ = await _dbContext.SaveChangesAsync(cancellationToken);
_signOutOfClassSender.DeleteReservation(reservationEntity.ReservationId);
var reservationDto = reservationEntity.Adapt <ReservationDtoSetter>();
return(reservationDto);
}
public async Task Handle_ShouldEditCalendarEventDataInDatabase()
{
var calendarEvent = new CalendarEvent(
"Music fetival",
DateTimeOffset.Now.ToUnixTimeSeconds(),
"Oosterpark, Amsterdam ",
"Rafael Caviquioli"
);
calendarEvent.AddMember("Aleida");
calendarEvent.AddMember("Vans Martin");
_context.Add(calendarEvent);
await _context.SaveChangesAsync();
_context.DetachAllEntities();
var command = new EditCalendarEventCommand()
{
Id = calendarEvent.Id,
Name = "Football Challenge",
Time = DateTimeOffset.Now.AddDays(10).ToUnixTimeSeconds(),
Location = "Brussels, Belgian",
EventOrganizer = "Elisabeth",
Members = new string[] { "Gabriel", "Anna", "Aleida", "Felipe" }
};
var handler = new EditCalendarEventCommandHandler(_calendarEventRepository);
await handler.Handle(command, CancellationToken.None);
var updatedCalendarEvent = await _context.CalendarEvents
.Include(ce => ce.Members)
.FirstOrDefaultAsync(ce => ce.Id == calendarEvent.Id);
updatedCalendarEvent.Name.Should().Be(command.Name);
updatedCalendarEvent.Location.Should().Be(command.Location);
updatedCalendarEvent.Time.Should().Be(command.Time);
updatedCalendarEvent.Organizer.Should().Be(command.EventOrganizer);
updatedCalendarEvent.Members.Should().HaveCount(4);
var members = updatedCalendarEvent.Members
.Select(m => m.Name)
.ToList();
members.Should().Contain("Gabriel");
members.Should().Contain("Anna");
members.Should().Contain("Aleida");
members.Should().Contain("Felipe");
members.Should().NotContain("Vans Martin");
}
public async Task <TimetableDto> Handle(DeleteTimetableByIdCommand request, CancellationToken cancellationToken)
{
var timetableEntity = await _dbContext
.Timetables
.SingleOrDefaultAsync(m => m.TimetableId == request.TimetableId, cancellationToken);
var classGenerator = new ClassGenerator(_dbContext);
await classGenerator.DeleteAllClassesByTimetableIdAsync(timetableEntity, cancellationToken);
_dbContext.Remove(timetableEntity);
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var timetableDto = timetableEntity.Adapt <TimetableDto>();
return(timetableDto);
}
public async Task CreateRequestForCommandAsync <T>(Guid id)
{
var exists = await ExistAsync(id);
var request = exists ?
throw new CalendarDomainException($"Request with {id} already exists") :
new ClientRequest()
{
Id = id,
Name = typeof(T).Name,
Time = DateTime.UtcNow
};
_context.Add(request);
await _context.SaveChangesAsync();
}
public async Task <ClassTypeDto> Handle(EditClassTypeCommand request, CancellationToken cancellationToken)
{
var classTypeEntity = await _dbContext
.ClassTypes
.SingleOrDefaultAsync(m => m.ClassTypeId == request.ClassTypeId, cancellationToken);
if (classTypeEntity is null)
{
throw new NullReferenceException($"ClassType [classTypeId: {request.ClassTypeId}] not found");
}
var editedClassType = request.NewClassTypeEntity;
var nameBeforeChange = classTypeEntity.Name;
editedClassType.ApplyTo(classTypeEntity, ModelState);
var nameAfterChange = classTypeEntity.Name;
// var validator =
// new ClassTypeValidator(_dbContext, new Tuple<string, string>(nameBeforeChange, nameAfterChange));
// var validationResult = await validator.ValidateAsync(classTypeEntity, cancellationToken);
//
// if (!validationResult.IsValid)
// throw new ValidationException(validationResult.Errors.ToList());
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var patchedClassTypeEntity = await _dbContext
.ClassTypes
.SingleOrDefaultAsync(m => m.ClassTypeId == request.ClassTypeId, cancellationToken);
if (patchedClassTypeEntity is null)
{
throw new NullReferenceException(
$"Failed to fetch patched class type [ClassTypeId: {request.ClassTypeId}]");
}
var patchedClassTypeDto = patchedClassTypeEntity.Adapt <ClassTypeDto>();
return(patchedClassTypeDto);
}
public async Task <ClassTypeDto> Handle(AddClassTypeCommand request, CancellationToken cancellationToken)
{
var name = request.NewClassType.Name;
var classTypeEntity = request.NewClassType.Adapt <ClassType>();
_ = await _dbContext.AddAsync(classTypeEntity, cancellationToken);
_ = await _dbContext.SaveChangesAsync(cancellationToken);
var newClassTypeEntity = await _dbContext
.ClassTypes
.SingleOrDefaultAsync(m => m.Name == name, cancellationToken);
if (newClassTypeEntity is null)
{
throw new NullReferenceException("Failed to add class type. Try again");
}
var newClassTypeDto = newClassTypeEntity.Adapt <ClassTypeDto>();
return(newClassTypeDto);
}
public async Task SaveChanges()
{
await db.SaveChangesAsync();
}
