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