private void SaveData() { foreach (ReservationDto reservation in Reservationen) { if (reservation.ReservationNr == default(int)) { Service.InsertReservation(reservation); } else { ReservationDto original = reservationenOriginal.Where(ao => ao.ReservationNr == reservation.ReservationNr).FirstOrDefault(); Service.UpdateReservation(reservation, original); } } Load(); }
public void InsertReservationWithInvalidDateRangeTest() { DateTime von = new DateTime(2018, 1, 20); DateTime bis = new DateTime(2018, 1, 19); ReservationDto reservation = new ReservationDto { ReservationsNr = 200, Von = von, Bis = bis, Auto = Target.GetAuto(1), Kunde = Target.GetKunde(1) }; Target.AddReservation(reservation); }
public async Task <IActionResult> Put(int id, [FromBody] ReservationDto reservation) { if (reservation == null || reservation.ID != id) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await reservationService.Update(id, reservation); return(NoContent()); }
public void DeleteReservation(ReservationDto reservation) { WriteActualMethod(); var reservationEntity = DtoConverter.ConvertToEntity(reservation); try { reservationManager.Delete(reservationEntity); } catch (OptimisticConcurrencyException <Reservation> ) { throw new FaultException <DataManipulationFault>(new DataManipulationFault { Message = "Die Reservation wird momentan bearbeitet." }); } }
public ReservationDto UpdateReservation(ReservationDto reservationDto) { try { Reservation reservation = reservationDto.ConvertToEntity(); return(autoReservationBusinessComponent.UpdateReservation(reservation).ConvertToDto()); } catch (LocalOptimisticConcurrencyException <Reservation> ex) { OptimisticConcurrencyFaultContract ocfc = new OptimisticConcurrencyFaultContract { Operation = "UpdateReservation", Message = ex.Message }; throw new FaultException <OptimisticConcurrencyFaultContract>(ocfc); } }
public async Task <IActionResult> Post([FromBody] ReservationDto reservation) { if (reservation == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await reservationService.Insert(reservation); return(Ok()); }
public async Task UpdateReservationWithAutoNotAvailableTest() { // arrange ReservationRequest existingRequest = new ReservationRequest { Id = 1 }; ReservationDto existingDto = _target.Get(existingRequest); ReservationDto reservationInvalid = new ReservationDto { Auto = existingDto.Auto, Kunde = existingDto.Kunde, Von = existingDto.Von, Bis = existingDto.Bis }; // assert Assert.Throws <RpcException>(() => _target.Insert(reservationInvalid)); }
public void UpdateReservation(ReservationDto original, ReservationDto modified) { WriteActualMethod(); try { _businessComponent.UpdateReservation(original.ConvertToEntity(), modified.ConvertToEntity()); } catch (LocalOptimisticConcurrencyException <Reservation> e) { var fault = new LocalOptimisticConcurrencyFault() { Message = e.Message }; throw new FaultException <LocalOptimisticConcurrencyFault>(fault); } }
public Property InvalidDate(string date) { Action prop = () => { var dto = new ReservationDto { Date = date }; var actual = Validator.Validate(dto); Assert.NotEmpty(actual); }; return(prop.When(!DateTime.TryParse(date, out _))); }
public async Task UpdateReservationWithInvalidDateRangeTest() { // arrange ReservationRequest existingRequest = new ReservationRequest { Id = 1 }; ReservationDto existingDto = _target.Get(existingRequest); Timestamp von = existingDto.Bis; Timestamp bis = existingDto.Von; existingDto.Von = von; existingDto.Bis = bis; // assert Assert.Throws <RpcException>(() => _target.Update(existingDto)); }
public async Task CreateReservation(ReservationDto reservationDto) { var reservation = new Reservation { UserId = reservationDto.UserId, AddressId = reservationDto.AddressId, VehicleModelId = reservationDto.VehicleModelId, PickUpTime = reservationDto.PickUpTime, DropOffTime = reservationDto.DropOffTime, Price = reservationDto.Price, State = Reservation.ReservationStates.Undecieded }; _dbContext.Reservations.Add(reservation); await _dbContext.SaveChangesAsync(); }
public async Task UpdateReservationWithInvalidDateRangeTest() { // arrange ReservationDto reservationUpdate = _target.Get(new ReservationRequest { Id = 3 }); reservationUpdate.Von = Timestamp.FromDateTime(new DateTime(2020, 10, 04, 12, 00, 00, DateTimeKind.Utc)); reservationUpdate.Bis = Timestamp.FromDateTime(new DateTime(2020, 10, 05, 11, 59, 59, DateTimeKind.Utc)); // act - assert RpcException exception = Assert.Throws <RpcException>(() => _target.Update(reservationUpdate)); Assert.Equal(StatusCode.FailedPrecondition, exception.StatusCode); Assert.Equal("Status(StatusCode=FailedPrecondition, Detail=\"From-To must be at least 24 hours apart\")", exception.Message); }
public void UpdateReservation(ReservationDto reservation) { WriteActualMethod(); IAutoReservationResultCallback cb = _createCallbackChannel(); try { cb.SendReservation(reservationManager.Update(reservation.ConvertToEntity()).ConvertToDto()); } catch (Exception ex) { cb.SendFault(new CommunicationFault { Exception = ex.Message }); } }
public void UpdateReservation(ReservationDto modified, ReservationDto original) { try { WriteActualMethod(); BusinessComponent.UpdateReservation(modified.ConvertToEntity(), original.ConvertToEntity()); } catch (LocalOptimisticConcurrencyException <Reservation> ex) { var enThrow = new OptimisticConcurrencyException <ReservationDto> { Entity = ex.Entity.ConvertToDto() }; throw new FaultException <OptimisticConcurrencyException <ReservationDto> >(enThrow); } }
public async Task UpdateReservationTest() { // arrange ReservationRequest toUpdate = new ReservationRequest { Id = 1 }; ReservationDto reservation = _target.Get(toUpdate); DateTime bis = reservation.Bis.ToDateTime(); // act reservation.Bis = bis.AddDays(1).ToTimestamp(); _target.Update(reservation); // assert Assert.Equal(bis.AddDays(1).ToTimestamp(), _target.Get(toUpdate).Bis); }
private void ReservationSelectedListBox_OnMouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e) { try { ReservationDto selectedRes = GetSelectedReservation(); loadIntoReservationForm(selectedRes); } catch (FieldAccessException ex) { MessageBox.Show(ex.Message, "Fehler", MessageBoxButton.OK); } catch (FaultException <OptimisticConcurrencyFault> ex) { MessageBox.Show(ex.Detail.Message, "Fehler", MessageBoxButton.OK); } }
public void InsertReservationTest() { var reservation = new ReservationDto { Bis = new DateTime(2017, 09, 27), Von = new DateTime(2017, 08, 27), Auto = Target.GetAuto(1), Kunde = Target.GetKunde(1) }; Target.AddReservation(reservation); var res = Target.GetReservation(4); Assert.AreEqual(res.Bis, reservation.Bis); Assert.AreEqual(res.Von, reservation.Von); }
public string UpdateReservation(int reservationId, ReservationDto resDto) { Reservation reservation = _context.Reservations.FirstOrDefault(r => r.ReservationID == reservationId); IQueryable <UserReservation> userReservations = _context.UserReservations.Where(r => r.ReservationID == reservationId); //Update reservation if (reservation == null) { return("Reservation with Id " + reservationId.ToString() + " not found to update"); } else { reservation.FloorID = resDto.FloorID; reservation.Date = resDto.Date; _context.SaveChanges(); foreach (int userId in resDto.UserIds) { //Check if a new user is added bool ifUserExist = userReservations.Any(item => item.UserID.Equals(userId)); if (!ifUserExist) { UserReservation ur = new UserReservation() { ReservationID = reservationId, UserID = userId, Timestamp = DateTime.Now }; _context.UserReservations.Add(ur); _context.SaveChanges(); } } //check if user needs to be deleted List <UserReservation> toBeDeleted = userReservations.Where(userRes => !resDto.UserIds.Any(mancerId => userRes.UserID == mancerId)).ToList(); foreach (UserReservation userToDelete in toBeDeleted) { _context.UserReservations.Remove(userToDelete); _context.SaveChanges(); } return("Reservation with Id " + reservationId.ToString() + " updated"); } }
// TODO: 1 - Create a channel factory for the Frequent Flyer service public string CreateReservation(ReservationDto request) { // Verify the flight is valid if (request.DepartureFlight == null) { throw new FaultException <ReservationCreationFault>( new ReservationCreationFault { Description = "Reservation must include a departure flight", ReservationDate = request.ReservationDate }, "Invalid flight info"); } // Create reservation object with trips var reservation = new Reservation { TravelerId = request.TravelerId, ReservationDate = request.ReservationDate, DepartureFlight = new Trip { Class = request.DepartureFlight.Class, Status = request.DepartureFlight.Status, FlightScheduleID = request.DepartureFlight.FlightScheduleID } }; if (request.ReturnFlight != null) { reservation.ReturnFlight = new Trip { Class = request.ReturnFlight.Class, Status = request.ReturnFlight.Status, FlightScheduleID = request.ReturnFlight.FlightScheduleID }; } using (IReservationRepository reservationRepository = new ReservationRepository(ConnectionName)) { reservation.ConfirmationCode = ReservationUtils.GenerateConfirmationCode(reservationRepository); reservationRepository.Add(reservation); reservationRepository.Save(); return(reservation.ConfirmationCode); } }
private string CreateReservationOnBackendSystem(Reservation reservation) { IBookingService proxy = factory.CreateChannel(); try { (proxy as ICommunicationObject).Open(); TripDto departureFlight = new TripDto { FlightScheduleID = reservation.DepartureFlight.FlightScheduleID, Class = reservation.DepartureFlight.Class, Status = reservation.DepartureFlight.Status }; TripDto returnFlight = null; if (reservation.ReturnFlight != null) { returnFlight = new TripDto { FlightScheduleID = reservation.ReturnFlight.FlightScheduleID, Class = reservation.ReturnFlight.Class, Status = reservation.ReturnFlight.Status }; } ReservationDto request = new ReservationDto() { DepartureFlight = departureFlight, ReturnFlight = null, ReservationDate = reservation.ReservationDate, TravelerId = reservation.TravelerId }; string confirmationCode = proxy.CreateReservation(request); (proxy as ICommunicationObject).Close(); return(confirmationCode); } catch (Exception) { (proxy as ICommunicationObject).Abort(); throw; } }
public async Task <ReservationDto> GetReservationAsync(string id) { var reservation = await _repositoryReservation.GetAll().FirstOrDefaultAsync(r => r.Id == id); if (reservation is null) { throw new KeyNotFoundException(ErrorResource.ReservationNotFound); } var reservationDto = new ReservationDto { CheckIn = reservation.CheckIn, CheckOut = reservation.CheckOut }; return(reservationDto); }
public async Task CreateReservation_WhenReservationDtoIsValid_ReturnsReservationDto() { var client = GetHttpClient(); ReservationDto reservationDto = null; var reservationToCreate = new Reservation { RoomId = 4, StartDate = DateTime.Today, EndDate = DateTime.Today.AddDays(3) }; var response = await client.PostAsJsonAsync("api/reservations", Mapper.Map <Reservation, ReservationDto>(reservationToCreate)); if (response.IsSuccessStatusCode) { reservationDto = await response.Content.ReadAsAsync <ReservationDto>(); } Assert.IsNotNull(reservationDto); Assert.IsInstanceOfType(reservationDto, typeof(ReservationDto), "Reservation successfully added"); }
public void DeleteReservation(ReservationDto reservation) { WriteActualMethod(); try { _reservationManager.Delete(reservation.ConvertToEntity()); } catch (OptimisticConcurrencyException <Reservation> ex) { throw new FaultException <AutoReservationFault>(new AutoReservationFault { ErrorCode = AutoReservationFault.DataHasBeenModifiedInMeantime, ErrorMessage = $"Database Entity-State: {ex.MergedEntity.ConvertToDto()}" }); } }
public async Task InsertReservationWithAutoNotAvailableTest() { AutoDto autoDto = await _autoClient.GetByIdAsync(new GetAutoByIdRequest { Id = 1 }); KundeDto kundeDto = await _kundeClient.GetByIdAsync(new GetKundeByIdRequest { Id = 1 }); ReservationDto reservationDto = new ReservationDto { Von = new DateTime(2020, 1, 11, 0, 0, 0, DateTimeKind.Utc).ToTimestamp(), Bis = new DateTime(2020, 1, 28, 0, 0, 0, DateTimeKind.Utc).ToTimestamp(), RowVersion = Google.Protobuf.ByteString.CopyFromUtf8(""), Auto = autoDto, Kunde = kundeDto }; Assert.Throws <RpcException>(() => _target.Insert(reservationDto)); }
public async Task CheckAvailabilityIsFalseTest() { AutoDto autoDto = await _autoClient.GetByIdAsync(new GetAutoByIdRequest { Id = 1 }); KundeDto kundeDto = await _kundeClient.GetByIdAsync(new GetKundeByIdRequest { Id = 1 }); ReservationDto reservationDto = new ReservationDto { Von = new DateTime(2020, 1, 30, 0, 0, 0, DateTimeKind.Utc).ToTimestamp(), Bis = new DateTime(2020, 1, 20, 0, 0, 0, DateTimeKind.Utc).ToTimestamp(), RowVersion = Google.Protobuf.ByteString.CopyFromUtf8(""), Auto = autoDto, Kunde = kundeDto }; Assert.False(_target.CarAvailability(reservationDto).IsAvailable); }
public void UpdateReservationWithInvalidDateRangeTest() { Target.GetReservation(1); CallbackSpy.WaitForAnswer(); ReservationDto reservation = CallbackSpy.ReservationSpy.First(); CallbackSpy.ReservationSpy.Clear(); reservation.Von = reservation.Bis; Target.UpdateReservation(reservation); CallbackSpy.WaitForAnswer(); string ex = CallbackSpy.ExceptionSpy; Assert.AreEqual("Reservation must be at 24 hours long", ex); CallbackSpy.ExceptionSpy = null; }
public async Task <bool> DeleteReservationAsync(ReservationDto reservation) { ValidateNull(Logger, reservation); var result = true; var seatReservations = (await _unitOfWork.RepositoryTicket.GetSeatReservationsByReservationIdAsync(reservation.Id)).ToList(); if (!ValidateSeatReservations(seatReservations)) { return(false); } await _unitOfWork.Transaction().PerformBlock(async() => { result = result && await DeleteAllReservationsAsync(seatReservations); }).Commit(); return(result); }
public async Task UpdateReservationWithAutoNotAvailableTest() { GetReservationRequest requestId = new GetReservationRequest { IdFilter = 2 }; ReservationDto toUpdate = _target.GetReservation(requestId); DateTime from = new DateTime(2020, 1, 19, 0, 0, 0, DateTimeKind.Utc); DateTime to = new DateTime(2020, 1, 22, 0, 0, 0, DateTimeKind.Utc); //act toUpdate.From = from.ToTimestamp(); toUpdate.To = to.ToTimestamp(); // assert Assert.Throws <RpcException>(() => _target.UpdateReservation(toUpdate)); }
public async Task UpdateReservationWithInvalidDateRangeTest() { GetReservationRequest requestId = new GetReservationRequest { IdFilter = 1 }; ReservationDto toUpdate = _target.GetReservation(requestId); DateTime from = new DateTime(2020, 12, 1, 0, 0, 0, DateTimeKind.Utc); DateTime to = new DateTime(2020, 12, 3, 0, 0, 0, DateTimeKind.Utc); //act toUpdate.From = to.ToTimestamp(); toUpdate.To = from.ToTimestamp(); // assert Assert.Throws <RpcException>(() => _target.UpdateReservation(toUpdate)); }
public async Task CheckAvailabilityIsTrueTest() { var reservationToCheck = new ReservationDto { Von = DateTime.UtcNow.ToTimestamp(), Bis = DateTime.UtcNow.AddHours(1).ToTimestamp(), Auto = new AutoDto { Id = 3 }, Kunde = new KundeDto { Id = 4 } }; var result = await _target.CheckAvailabilityAsync(reservationToCheck); Assert.True(result.IsAvailable); }