public bool isCarAvailable(ReservationDto reservation, AutoDto auto)
{
WriteActualMethod();
ReservationManager reservationManager = new ReservationManager();
return(reservationManager.IsCarAvailable(DtoConverter.ConvertToEntity(reservation), DtoConverter.ConvertToEntity(auto)));
}
public KundeDto DeleteKunde(KundeDto KundeDto)
{
WriteActualMethod();
Kunde Kunde = DtoConverter.ConvertToEntity(KundeDto);
return(DtoConverter.ConvertToDto(autoReservationBusinessComponent.DeleteKunde(Kunde)));
}
public void AddKunde(KundeDto kunde)
{
WriteActualMethod();
var kundeEntity = DtoConverter.ConvertToEntity(kunde);
kundeManager.Add(kundeEntity);
}
public AutoDto DeleteAuto(AutoDto autoDto)
{
WriteActualMethod();
Auto auto = DtoConverter.ConvertToEntity(autoDto);
return(DtoConverter.ConvertToDto(autoReservationBusinessComponent.DeleteAuto(auto)));
}
public void addRerservation(ReservationDto reservationDto)
{
WriteActualMethod();
Reservation reservation = DtoConverter.ConvertToEntity(reservationDto);
ReservationManager reservationManager = new ReservationManager();
try
{
reservationManager.addReservation(reservation);
}
catch (InvalidDateRangeException <Reservation> e)
{
InvalidDateRange fault = new InvalidDateRange();
fault.Result = false;
fault.Message = e.Message;
fault.Description = "Ungültiger Zeitraum gewählt!";
throw new FaultException <InvalidDateRange>(fault);
}
catch (AutoUnavailableException <Auto> e) {
AutoUnavailable fault = new AutoUnavailable();
fault.Result = false;
fault.Message = e.Message;
fault.Description = "Car is not available";
throw new FaultException <AutoUnavailable>(fault);
}
}
public void UpdateReservation(ReservationDto reservation)
{
WriteActualMethod();
var reservationEntity = DtoConverter.ConvertToEntity(reservation);
try {
reservationManager.Update(reservationEntity);
}
catch (OptimisticConcurrencyException <Reservation> )
{
throw new FaultException <DataManipulationFault> (new DataManipulationFault {
Message = "Die Reservation wird momentan bearbeitet."
});
}
catch (InvalidDateRangeException e)
{
throw new FaultException <InvalidDateRangeFault> (new InvalidDateRangeFault {
Message = "Ungültiger Datumsbereich eingegeben.", MessageDetails = e.Message
});
}
catch (AutoUnavailableException)
{
throw new FaultException <AutoUnavailableFault> (new AutoUnavailableFault {
Message = "Das gewählte Fahrzeug ist zur Zeit nicht verfügbar."
});
}
}
public ReservationDto UpdateReservation(ReservationDto reservation)
{
WriteActualMethod();
try
{
return(DtoConverter.ConvertToDto(reservationManager.Update(DtoConverter.ConvertToEntity(reservation))));
}
catch (OptimisticConcurrencyException <Reservation> )
{
OptimisticConcurrencyFault <ReservationDto> fault = new OptimisticConcurrencyFault <ReservationDto>
{
FaultEntity = reservation,
CurrentEntity = DtoConverter.ConvertToDto(reservationManager.GetById(reservation.ReservationsNr))
};
throw new FaultException <OptimisticConcurrencyFault <ReservationDto> >(fault);
}
catch (InvalidDateException <Reservation> )
{
DateRangeFault fault = new DateRangeFault
{
reservation = reservation
};
throw new FaultException <DateRangeFault>(fault);
}
catch (AutoUnavailableException <Reservation> )
{
AutoUnavailableFault fault = new AutoUnavailableFault
{
reservation = reservation
};
throw new FaultException <AutoUnavailableFault>(fault);
}
}
public ReservationDto DeleteReservation(ReservationDto ReservationDto)
{
WriteActualMethod();
Reservation Reservation = DtoConverter.ConvertToEntity(ReservationDto);
return(DtoConverter.ConvertToDto(autoReservationBusinessComponent.DeleteReservation(Reservation)));
}
public void AddAuto(AutoDto auto)
{
WriteActualMethod();
var autoEntity = DtoConverter.ConvertToEntity(auto);
autoManager.Add(autoEntity);
}
public void removeRerservation(ReservationDto reservationDto)
{
WriteActualMethod();
Reservation reservation = DtoConverter.ConvertToEntity(reservationDto);
ReservationManager reservationManager = new ReservationManager();
reservationManager.removeReservation(reservation);
}
public void addCustomer(KundeDto kundeDto)
{
WriteActualMethod();
Kunde kunde = DtoConverter.ConvertToEntity(kundeDto);
KundeManager kundeManager = new KundeManager();
kundeManager.addCustomer(kunde);
}
public void removeCar(AutoDto autoDto)
{
WriteActualMethod();
Auto auto = DtoConverter.ConvertToEntity(autoDto);
AutoManager autoManager = new AutoManager();
autoManager.removeCar(auto);
}
public void UpdateKunde(Common.DataTransferObjects.KundeDto originalDto, Common.DataTransferObjects.KundeDto modifiedDto)
{
try
{
businessComponent.UpdateKunde(DtoConverter.ConvertToEntity(originalDto), DtoConverter.ConvertToEntity(modifiedDto));
}
catch (LocalOptimisticConcurrencyException <Kunde> e)
{
throw new FaultException <Common.DataTransferObjects.KundeDto>(originalDto, e.Message);
}
}
public ReservationDto UpdateReservation(ReservationDto reservation)
{
WriteActualMethod();
try
{
return(DtoConverter.ConvertToDto(_businessLayer.UpdateReservation(DtoConverter.ConvertToEntity(reservation))));
}
catch (LocalOptimisticConcurrencyException <Reservation> e)
{
throw new FaultException <ReservationDto>(e.MergedEntity.ConvertToDto(), "Reservation update failed");
}
}
public AutoDto UpdateAuto(AutoDto auto)
{
WriteActualMethod();
try
{
return(DtoConverter.ConvertToDto(_businessLayer.UpdateAuto(DtoConverter.ConvertToEntity(auto))));
}
catch (LocalOptimisticConcurrencyException <Auto> )
{
throw new FaultException("Auto Update failed");
}
}
public void updateCar(AutoDto car)
{
WriteActualMethod();
try
{
Component.updateCar(DtoConverter.ConvertToEntity(car));
}
catch (LocalOptimisticConcurrencyException <Auto> ex)
{
throw new FaultException <LocalOptimisticConcurrencyException <Auto> >(ex, ex.Message);
}
}
public void updateReservation(ReservationDto reservation)
{
WriteActualMethod();
try
{
Component.updateReservation(DtoConverter.ConvertToEntity(reservation));
}
catch (LocalOptimisticConcurrencyException <Reservation> ex)
{
throw new FaultException <LocalOptimisticConcurrencyException <Reservation> >(ex, ex.Message);
}
}
public void updateCustomer(KundeDto customer)
{
WriteActualMethod();
try
{
Component.updateCustomer(DtoConverter.ConvertToEntity(customer));
}
catch (LocalOptimisticConcurrencyException <Kunde> ex)
{
throw new FaultException <LocalOptimisticConcurrencyException <Kunde> >(ex, ex.Message);
}
}
public KundeDto UpdateKunde(KundeDto kunde)
{
WriteActualMethod();
try
{
return(DtoConverter.ConvertToDto(_businessLayer.UpdateKunde(DtoConverter.ConvertToEntity(kunde))));
}
catch (LocalOptimisticConcurrencyException <Kunde> )
{
throw new FaultException("Kunde Update failed");
}
}
public AutoDto UpdateAuto(AutoDto auto)
{
try
{
WriteActualMethod();
return(DtoConverter.ConvertToDto(ServiceAuto.UpdateAuto(DtoConverter.ConvertToEntity(auto))));
}
catch (OptimisticConcurrencyException <Auto> ex)
{
throw new FaultException <AutoDto>(ex.MergedEntity.ConvertToDto(), ex.Message);
}
}
public KundeDto UpdateKunde(KundeDto kunde)
{
try
{
WriteActualMethod();
return(DtoConverter.ConvertToDto(ServiceKunde.UpdateKunde(DtoConverter.ConvertToEntity(kunde))));
}
catch (OptimisticConcurrencyException <Kunde> ex)
{
throw new FaultException <KundeDto>(ex.MergedEntity.ConvertToDto(), ex.Message);
}
}
public KundeDto UpdateKunde(KundeDto modifiedDto, KundeDto originalDto)
{
WriteActualMethod();
Kunde modified = DtoConverter.ConvertToEntity(modifiedDto);
Kunde original = DtoConverter.ConvertToEntity(originalDto);
try {
return(DtoConverter.ConvertToDto(autoReservationBusinessComponent.UpdateKunde(modified, original)));
}
catch (LocalOptimisticConcurrencyException <Kunde> e)
{
throw new FaultException <KundeDto>(modifiedDto);
}
}
public void UpdateAuto(AutoDto auto)
{
WriteActualMethod();
var autoEntity = DtoConverter.ConvertToEntity(auto);
try {
autoManager.Update(autoEntity);
}
catch (OptimisticConcurrencyException <Auto> )
{
throw new FaultException <DataManipulationFault>(new DataManipulationFault {
Message = "Das Auto wird momentan bearbeitet."
});
}
}
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 void UpdateKunde(KundeDto kunde)
{
WriteActualMethod();
var kundeEntity = DtoConverter.ConvertToEntity(kunde);
try
{
kundeManager.Update(kundeEntity);
}
catch (OptimisticConcurrencyException <Kunde> )
{
throw new FaultException <DataManipulationFault>(new DataManipulationFault {
Message = "Der Kunde wird momentan bearbeitet."
});
}
}
public KundeDto UpdateKunde(KundeDto kunde)
{
WriteActualMethod();
try
{
return(DtoConverter.ConvertToDto(kundeManager.UpdateKunde(DtoConverter.ConvertToEntity(kunde))));
}
catch (OptimisticConcurrencyException <Kunde> )
{
OptimisticConcurrencyFault <KundeDto> fault = new OptimisticConcurrencyFault <KundeDto>
{
FaultEntity = kunde,
CurrentEntity = DtoConverter.ConvertToDto(kundeManager.ReadKunde(kunde.Id))
};
throw new FaultException <OptimisticConcurrencyFault <KundeDto> >(fault);
}
}
public AutoDto UpdateAuto(AutoDto auto)
{
WriteActualMethod();
try
{
return(DtoConverter.ConvertToDto(autoManager.UpdateAuto(DtoConverter.ConvertToEntity(auto))));
}
catch (OptimisticConcurrencyException <Auto> )
{
OptimisticConcurrencyFault <AutoDto> fault = new OptimisticConcurrencyFault <AutoDto>
{
FaultEntity = auto,
CurrentEntity = DtoConverter.ConvertToDto(autoManager.ReadAuto(auto.Id))
};
throw new FaultException <OptimisticConcurrencyFault <AutoDto> >(fault);
}
}
public void modifyCar(AutoDto autoDto)
{
WriteActualMethod();
Auto auto = DtoConverter.ConvertToEntity(autoDto);
AutoManager autoManager = new AutoManager();
try
{
autoManager.modifyCar(auto);
}
catch (OptimisticConcurrencyException <Auto> e) {
OptimisticConcurrency <AutoDto> fault = new OptimisticConcurrency <AutoDto>();
fault.Result = false;
fault.Message = e.Message;
fault.Description = "Occurrency Exception!";
throw new FaultException <OptimisticConcurrency <AutoDto> >(fault);
}
}
public void modifyCustomer(KundeDto kundeDto)
{
WriteActualMethod();
Kunde kunde = DtoConverter.ConvertToEntity(kundeDto);
KundeManager kundeManager = new KundeManager();
try {
kundeManager.modifyCustomer(kunde);
}
catch (OptimisticConcurrencyException <Kunde> e)
{
OptimisticConcurrency <KundeDto> fault = new OptimisticConcurrency <KundeDto>();
fault.Result = false;
fault.Message = e.Message;
fault.Description = "Occurrency Exception!";
throw new FaultException <OptimisticConcurrency <KundeDto> >(fault);
}
}
public void modifyRerservation(ReservationDto reservationDto)
{
WriteActualMethod();
Reservation reservation = DtoConverter.ConvertToEntity(reservationDto);
ReservationManager reservationManager = new ReservationManager();
try {
reservationManager.modifyReservation(reservation);
}
catch (OptimisticConcurrencyException <Reservation> e)
{
OptimisticConcurrency <ReservationDto> fault = new OptimisticConcurrency <ReservationDto>();
fault.Result = false;
fault.Message = e.Message;
fault.Description = "Occurrency Exception!";
throw new FaultException <OptimisticConcurrency <ReservationDto> >(fault);
}
}
