public bool IsAutoAvailable(ReservationDto reservation) { { WriteActualMethod(); return(ServiceReservation.IsAutoAvailable(reservation.ConvertToEntity())); } }
public void UpdateReservation(ReservationDto reservation) { if (reservation.Auto == null || reservation.Kunde == null) { var fault = new GenericFault("Reservation muss ein Auto und ein Kunde besitzen um angepasst zu werden."); throw new FaultException <GenericFault>(fault); } if (IsCarAvailable(reservation.Auto, reservation)) { try { ReservationsManager.Update(reservation.ConvertToEntity()); } catch (DbUpdateConcurrencyException) { var fault = new GenericFault("Update Concurrency Exception"); throw new FaultException <GenericFault>(fault); } } else { var fault = new GenericFault("Das Auto ist in dieser Zeitspanne nicht verfügbar."); throw new FaultException <GenericFault>(fault); } }
public override async Task <ReservationDto> Insert(ReservationDto request, ServerCallContext context) { try { ReservationManager manager = new ReservationManager(); Reservation reservation = request.ConvertToEntity(); Reservation newreservation = await manager.Insert(reservation); return(newreservation.ConvertToDto()); } catch (InvalidDateRangeException exception) { throw new RpcException(new Status( StatusCode.FailedPrecondition, "From-To must be at least 24 hours apart" ), exception.ToString()); } catch (AutoUnavailableException exception) { throw new RpcException(new Status( StatusCode.FailedPrecondition, "Car is not available" ), exception.ToString()); } }
public void UpdateReservation(ReservationDto reservation) { WriteActualMethod(); try { _reservationManager.Update(reservation.ConvertToEntity()); } catch (OptimisticConcurrencyException <Reservation> ) { throw new FaultException <OptimisticConcurrencyFault <Reservation> >(new OptimisticConcurrencyFault <Reservation>()) { }; } catch (InvalidDateRangeException) { throw new FaultException <InvalidDateRangeFault>(new InvalidDateRangeFault()) { }; } catch (UnavailableAutoException) { throw new FaultException <UnavailableAutoFault>(new UnavailableAutoFault()) { }; } }
public void IsAutoAvailable(ReservationDto reservation) { WriteActualMethod(); IAutoReservationResultCallback cb = _createCallbackChannel(); cb.SendAutoAvailability(reservationManager.IsAutoAvailable(reservation.ConvertToEntity())); }
public void UpdateReservation(ReservationDto reservationToBeUpdated) { WriteActualMethod(); try { reservationManager.Update(reservationToBeUpdated.ConvertToEntity()); } catch (AutoUnavailableException) { AutoUnavailableFault auf = new AutoUnavailableFault { Operation = "Insert", ProblemType = "Auto is not available during this Time Range!" }; throw new FaultException <AutoUnavailableFault>(auf); } catch (InvalidDateRangeException) { InvalidDateRangeFault idf = new InvalidDateRangeFault { Operation = "Insert", ProblemType = "Date is invalid!" }; throw new FaultException <InvalidDateRangeFault>(idf); } catch (OptimisticConcurrencyException <Reservation> ) { OptimisticConcurrencyFault ocf = new OptimisticConcurrencyFault { Operation = "Update", ProblemType = "Optimstic Cocurrency Error during updating on Reservation!" }; throw new FaultException <OptimisticConcurrencyFault>(ocf); } }
public override async Task <ReservationDto> DeleteReservation(ReservationDto request, ServerCallContext context) { var reservation = request.ConvertToEntity(); var response = await reservationenManager.DeleteReservation(reservation); return(response.ConvertToDto()); }
public void UpdateReservation(ReservationDto reservation) { WriteActualMethod(); try { _reservationManager.Update(reservation.ConvertToEntity()); } catch (OptimisticConcurrencyException <Reservation> ex) { throw new FaultException <AutoReservationFault>(new AutoReservationFault { ErrorCode = AutoReservationFault.DataHasBeenModifiedInMeantime, ErrorMessage = $"Database Entity-State: {ex.MergedEntity.ConvertToDto()}" }); } catch (InvalidDateRangeException ex) { throw new FaultException <AutoReservationFault>(new AutoReservationFault { ErrorCode = AutoReservationFault.RentalPeriodNotAllowed, ErrorMessage = ex.Message }); } catch (AutoUnavailableException ex) { throw new FaultException <AutoReservationFault>(new AutoReservationFault { ErrorCode = AutoReservationFault.CarNotAvailable, ErrorMessage = ex.Message }); } }
public ReservationDto InsertReservation(ReservationDto reservationDto) { Reservation reservation = reservationDto.ConvertToEntity(); autoReservationBusinessComponent.InsertReservation(reservation); return(reservation.ConvertToDto()); }
public override async Task <ReservationDto> UpdateReservation(ReservationDto request, ServerCallContext context) { try { var reservation = request.ConvertToEntity(); var response = await reservationenManager.UpdateReservation(reservation); return(response.ConvertToDto()); } catch (Exception e) { if (e is OptimisticConcurrencyException <Reservation> specificException) { throw new RpcException(new Status(StatusCode.Aborted, e.Message), specificException.MergedEntity.ToString()); } if (e is InvalidDateRangeException) { throw new RpcException(new Status(StatusCode.OutOfRange, e.Message)); } if (e is AutoUnavailableException) { throw new RpcException(new Status(StatusCode.ResourceExhausted, e.Message)); } throw new RpcException(new Status(StatusCode.Internal, e.Message)); } }
public void CreateReservation(ReservationDto reservation) { WriteActualMethod(); try { _reservationManager.Create(reservation.ConvertToEntity()); } catch (InvalidDateRangeException ex) { throw new FaultException <AutoReservationFault>(new AutoReservationFault { ErrorCode = AutoReservationFault.RentalPeriodNotAllowed, ErrorMessage = ex.Message }); } catch (AutoUnavailableException ex) { throw new FaultException <AutoReservationFault>(new AutoReservationFault { ErrorCode = AutoReservationFault.CarNotAvailable, ErrorMessage = ex.Message }); } }
public override async Task <Empty> Update(ReservationDto request, ServerCallContext context) { try { await _reservationManager.Update(request.ConvertToEntity()); } catch (OptimisticConcurrencyException <Reservation> exception) { throw new RpcException( new Status(StatusCode.Aborted, "Concurrency exception"), exception.ToString() ); } catch (InvalidDateRangeException exception) { throw new RpcException( new Status(StatusCode.FailedPrecondition, "Reservation must be at least 24h"), exception.ToString() ); } catch (AutoUnavailableException exception) { throw new RpcException( new Status(StatusCode.FailedPrecondition, "Car is not available"), exception.ToString() ); } return(new Empty()); }
public ReservationDto DeleteReservation(ReservationDto reservationDto) { WriteActualMethod(); Reservation reservation = reservationDto.ConvertToEntity(); return(autoReservationBusinessComponent.Delete(reservation).ConvertToDto()); }
public override async Task <Empty> Delete(ReservationDto request, ServerCallContext context) { ReservationManager manager = new ReservationManager(); Reservation reservation = request.ConvertToEntity(); await manager.Delete(reservation); return(new Empty()); }
public override async Task <IsCarAvailableResponse> IsCarAvailable(ReservationDto request, ServerCallContext context) { Reservation result = request.ConvertToEntity(); return(new IsCarAvailableResponse { IsAvailable = await _reservationManager.IsCarAvailable(result) }); }
public override async Task <CheckResponse> AvailabilityCheck(ReservationDto request, ServerCallContext context) { Reservation reservation = request.ConvertToEntity(); CheckResponse response = new CheckResponse(); response.IsValid = await _reservationManager.AvailabilityCheck(reservation); return(response); }
public ReservationDto UpdateReservation(ReservationDto modified, ReservationDto original) { WriteActualMethod(); Reservation modReservation = modified.ConvertToEntity(); Reservation origReservation = original.ConvertToEntity(); return(autoReservationBusinessComponent.Update(modReservation, origReservation).ConvertToDto()); }
public override async Task <CheckAvailabilityResponse> CheckAvailability(ReservationDto request, ServerCallContext context) { var reservation = request.ConvertToEntity(); bool isAvailable = await _manager.IsAutoAvailable(reservation); return(new CheckAvailabilityResponse { AutoIsAvailable = isAvailable }); }
public override async Task <Empty> DeleteReservation(ReservationDto request, ServerCallContext context) { Reservation reservation = request.ConvertToEntity(); await _reservationManager.Delete(reservation); Empty empt = new Empty(); return(empt); }
public override async Task <GetCarAvailability> CarAvailability(ReservationDto request, ServerCallContext context) { ReservationManager manager = new ReservationManager(); var reservation = request.ConvertToEntity(); bool isReservationValid = await manager.IsReservationValid(reservation); return(new GetCarAvailability { IsAvailable = isReservationValid }); }
public ReservationDto UpdateReservation(ReservationDto reservation) { try { bc.UpdateReservation(reservation.ConvertToEntity()); } catch (LocalOptimisticConcurrencyException <Reservation> e) { throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto(), e.Message); } return(reservation); }
public void UpdateReservation(ReservationDto modified, ReservationDto original) { WriteActualMethod(); try { _businessComponent.UpdateReservation(modified.ConvertToEntity(), original.ConvertToEntity()); } catch (LocalOptimisticConcurrencyException <Reservation> e) { throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto()); } }
public ReservationDto UpdateReservation(ReservationDto reservation) { WriteActualMethod(); try { return(service.UpdateReservation(reservation.ConvertToEntity()).ConvertToDto()); } catch (LocalOptimisticConcurrencyException <Reservation> e) { throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto()); } }
public ReservationDto UpdateReservation(ReservationDto reservation) { WriteActualMethod(); try { return(_businessComponent.SaveObject(reservation.ConvertToEntity(), reservation.ReservationNo, false).ConvertToDto()); } catch (LocalOptimisticConcurrencyException <Reservation> ex) { throw new FaultException("Update Concurrency Error"); } }
public override async Task <Empty> Delete(ReservationDto request, ServerCallContext context) { try { ReservationManager manager = new ReservationManager(); await manager.Delete(request.ConvertToEntity()); return(new Empty()); } catch (OptimisticConcurrencyException <Reservation> e) { throw new RpcException(new Status(StatusCode.Aborted, e.Message)); } }
public void DeleteReservation(ReservationDto reservationToBeDeleteed) { WriteActualMethod(); try { reservationManager.Delete(reservationToBeDeleteed.ConvertToEntity()); } catch (OptimisticConcurrencyException <Reservation> ) { OptimisticConcurrencyFault ocf = new OptimisticConcurrencyFault { Operation = "Delete", ProblemType = "Optimstic Cocurrency Error during deleting on Reservation!" }; throw new FaultException <OptimisticConcurrencyFault>(ocf); } }
public override async Task <Empty> DeleteReservation(ReservationDto request, ServerCallContext context) { try { var reservation = request.ConvertToEntity(); await _manager.DeleteEntity(reservation); return(new Empty()); } catch (Exception) { throw new RpcException(new Status(StatusCode.Internal, "Internal error occured.")); } }
public void RemoveReservation(ReservationDto reservation) { WriteActualMethod(); try { _reservationManager.Remove(reservation.ConvertToEntity()); } catch (OptimisticConcurrencyException <Reservation> ) { throw new FaultException <OptimisticConcurrencyFault <Reservation> >(new OptimisticConcurrencyFault <Reservation>()) { }; } }
public ReservationDto InsertReservation(ReservationDto reservation) { WriteActualMethod(); if (reservation.Bis - reservation.Von < TimeSpan.FromHours(24)) { throw new InvalidDateRangeException(); } if (!isAvailable(reservation.Auto)) { throw new AutoUnavailableException(); } ReservationManager rm = new ReservationManager(); return(rm.Insert(reservation.ConvertToEntity()).ConvertToDto()); }
public void UpdateReservation(ReservationDto modified, ReservationDto original) { try { WriteActualMethod(); BusinessComponent.UpdateReservation(modified.ConvertToEntity(), original.ConvertToEntity()); } catch (LocalOptimisticConcurrencyException <Reservation> ex) { OptimisticConcurrencyException <ReservationDto> enThrow = new OptimisticConcurrencyException <ReservationDto>(); enThrow.Entity = ex.Entity.ConvertToDto(); throw new FaultException <OptimisticConcurrencyException <ReservationDto> >(enThrow); } }