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