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