public ReservationDto InsertReservation(ReservationDto ReservationDto) { WriteActualMethod(); Reservation Reservation = DtoConverter.ConvertToEntity(ReservationDto); return DtoConverter.ConvertToDto(autoReservationBusinessComponent.InsertReservation(Reservation)); }
public ReservationDto InsertReservation(ReservationDto reservationDto) { WriteActualMethod(); Reservation reservation = reservationDto.ConvertToEntity(); return autoReservationBusinessComponent.Insert(reservation).ConvertToDto(); }
public ReservationDto UpdateReservation(ReservationDto modified, ReservationDto original) { WriteActualMethod(); Reservation modReservation = modified.ConvertToEntity(); Reservation origReservation = original.ConvertToEntity(); return autoReservationBusinessComponent.Update(modReservation, origReservation).ConvertToDto(); }
public ReservationDto UpdateReservation(ReservationDto modifiedDto, ReservationDto originalDto) { WriteActualMethod(); Reservation modified = DtoConverter.ConvertToEntity(modifiedDto); Reservation original = DtoConverter.ConvertToEntity(originalDto); try { return DtoConverter.ConvertToDto(autoReservationBusinessComponent.UpdateReservation(modified, original)); } catch (LocalOptimisticConcurrencyException<Reservation> e) { throw new FaultException<ReservationDto>(modifiedDto); } }
public void Test_DeleteReservation() { var countOld = Target.Reservationen().Count; var res = new ReservationDto(); res.Auto = Target.getAuto(1); res.Kunde = Target.getKunde(1); res.Bis = DateTime.Now; res.Von = DateTime.Now; Target.InsertReservation(res); var newRes = Target.Reservationen()[countOld]; countOld = Target.Reservationen().Count; Target.DeleteReservation(newRes); var countNew = Target.Reservationen().Count; Assert.AreEqual(countNew, countOld - 1); }
public override bool Equals(object obj) { // If parameter is null return false. if (obj == null) { return(false); } // If parameter cannot be cast to ReservationDto return false. ReservationDto other = obj as ReservationDto; if ((System.Object)other == null) { return(false); } return(this.ReservationNr == other.ReservationNr && this.Auto == other.Auto && this.Kunde == other.Kunde && this.Von == other.Von && this.Bis == other.Bis); }
public void UpdateReservation(ReservationDto reservation, ReservationDto original) { WriteActualMethod(); Reservation reservationEntity = reservation.ConvertToEntity(); Reservation originalEntity = original.ConvertToEntity(); try { BusinessComponent.UpdateReservation(reservationEntity, originalEntity); } catch (LocalOptimisticConcurrencyException<Reservation> ex) { Reservation failed = ex.MergedEntity; throw new FaultException<ReservationDto>(failed.ConvertToDto()); } }
public void Test_InsertReservation() { AutoDto auto = Target.GetAutoById(1); KundeDto kunde = Target.GetKundeById(1); ReservationDto newReservation = new ReservationDto { Von = DateTime.Now.AddDays(-1), Bis = DateTime.Now, Kunde = kunde, Auto = auto }; int countBefore = Target.Reservationen.Count(); Target.InsertReservation(newReservation); int countAfter = Target.Reservationen.Count(); Assert.AreEqual(countBefore + 1, countAfter); }
public System.Threading.Tasks.Task <bool> isCarAvailableAsync(AutoReservation.Common.DataTransferObjects.ReservationDto reservation, AutoReservation.Common.DataTransferObjects.AutoDto auto) { return(base.Channel.isCarAvailableAsync(reservation, auto)); }
public void removeRerservation(AutoReservation.Common.DataTransferObjects.ReservationDto reservationDto) { base.Channel.removeRerservation(reservationDto); }
public void UpdateReservation(ReservationDto original, ReservationDto modified ) { WriteActualMethod(); component.UpdateReservation(original.ConvertToEntity(), modified.ConvertToEntity()); }
public ReservationFaultContract(ReservationDto original, string message) { this.Original = original; this.Message = message; }
public void DeleteReservation(ReservationDto reservation) { WriteActualMethod(); _businessComponent.DeleteReservation(reservation.ConvertToEntity()); }
protected override void Load() { Autos.Clear(); foreach (AutoDto auto in Service.GetAllAuto()) { Autos.Add(auto); } Kunden.Clear(); foreach (KundeDto kunde in Service.GetAllKunde()) { Kunden.Add(kunde); } Reservationen.Clear(); reservationenOriginal.Clear(); foreach (ReservationDto reservation in Service.GetAllReservation()) { reservation.Auto = Autos.First(a => a.Id == reservation.Auto.Id); reservation.Kunde = Kunden.First(a => a.Id == reservation.Kunde.Id); Reservationen.Add(reservation); reservationenOriginal.Add((ReservationDto)reservation.Clone()); } SelectedReservation = Reservationen.FirstOrDefault(); }
protected override void Load() { Kunden.Clear(); foreach (var kunde in Service.GetKunden()) { Kunden.Add(kunde); } Autos.Clear(); foreach (var auto in Service.GetAutos()) { Autos.Add(auto); } Reservations.Clear(); reservationOriginal.Clear(); foreach (ReservationDto reservation in Service.GetReservationen()) { Reservations.Add(reservation); reservationOriginal.Add((ReservationDto)reservation.Clone()); } SelectedReservation = Reservations.FirstOrDefault(); }
public void Test_InsertReservation() { int newresid = Target.Reservationen().Count + 1; int kundeid = Target.Kunden().Count; int autoid = Target.Autos().Count; ReservationDto res = new ReservationDto(); res.Kunde = Target.GetKunde(kundeid); res.Auto = Target.GetAuto(autoid); res.Von = new DateTime(2001, 10, 10); res.Bis = new DateTime(2002, 10, 10); Target.InsertReservation(res); ReservationDto inserted = Target.GetReservation(newresid); KundeDto kunde = Target.GetKunde(kundeid); AutoDto auto = Target.GetAuto(autoid); Assert.AreEqual(kunde.ToString(), inserted.Kunde.ToString()); Assert.AreEqual(auto.ToString(), inserted.Auto.ToString()); Assert.AreEqual(new DateTime(2001, 10, 10), inserted.Von); }
public void Test_InsertReservation() { AutoDto tempAuto = Target.FindAuto(2); KundeDto tempKunde = Target.FindKunde(3); ReservationDto newReservation = new ReservationDto() { Auto = tempAuto, Kunde = tempKunde, Bis = DateTime.Now.AddMonths(2), Von = DateTime.Now.AddMonths(1) }; ReservationDto temp = Target.InsertReservation(newReservation); ReservationDto reservation = Target.FindReservation(temp.ReservationNr); Assert.AreEqual(newReservation.Von.ToShortDateString(), reservation.Von.ToShortDateString()); Assert.AreEqual(newReservation.Bis.ToShortDateString(), reservation.Bis.ToShortDateString()); Assert.AreEqual(tempAuto.Marke, reservation.Auto.Marke); Assert.AreEqual(tempAuto.AutoKlasse, reservation.Auto.AutoKlasse); Assert.AreEqual(tempAuto.Tagestarif, reservation.Auto.Tagestarif); Assert.AreEqual(tempKunde.Nachname, reservation.Kunde.Nachname); Assert.AreEqual(tempKunde.Vorname, reservation.Kunde.Vorname); Assert.AreEqual(tempKunde.Geburtsdatum.ToShortDateString(), reservation.Kunde.Geburtsdatum.ToShortDateString()); }
public void DeleteReservation(ReservationDto reservationDto) { WriteActualMethod(); busService.DeleteReservation(DtoConverter.ConvertToEntity(reservationDto)); }
public int InsertReservation(ReservationDto reservationDto) { WriteActualMethod(); return busService.AddReservation(DtoConverter.ConvertToEntity(reservationDto)); }
public void DeleteReservation(ReservationDto selectedReservation) { WriteActualMethod(); BusinessComponent.DeleteReservation(selectedReservation.ConvertToEntity()); }
private void New() { ReservationDto reservation = new ReservationDto(); reservation.Von = DateTime.Now; reservation.Bis = DateTime.Now.AddDays(1); Reservationen.Add(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 void Test_InsertReservation() { KundeDto roman = new KundeDto { Vorname = "Roman", Nachname = "Blum", Geburtsdatum = new DateTime(1993, 1, 23) }; AutoDto yourRide = new AutoDto { Marke = "Mercedes G65 AMG", AutoKlasse = AutoKlasse.Luxusklasse, Tagestarif = 300, Basistarif = 1000 }; Target.InsertKunde(roman); Target.InsertAuto(yourRide); ReservationDto reservation = new ReservationDto { Auto = Target.GetAutos().Last(), Kunde = Target.GetKunden().Last(), Von = DateTime.Now, Bis = new DateTime(2065, 1, 23) }; Target.InsertReservation(reservation); ReservationDto inserted = Target.GetReservationen().Last(); Assert.IsTrue(inserted.Kunde.Vorname == "Roman"); Assert.IsTrue(inserted.Kunde.Nachname == "Blum"); Assert.IsTrue(inserted.Auto.Marke == "Mercedes G65 AMG"); }
public void UpdateReservationTest() { TestEnvironmentHelper.InitializeTestData(); AutoReservationBusinessComponent target = new AutoReservationBusinessComponent(); ReservationDto reservation = new ReservationDto { Auto = target.Autos[0], Kunde = target.Kunden[0], Von = DateTime.Today, Bis = DateTime.Today.AddDays(10) }; int reservationNr = target.InsertReservation(reservation); Assert.AreNotEqual(0, reservationNr); ReservationDto org = target.GetReservationByNr(reservationNr); ReservationDto mod = target.GetReservationByNr(reservationNr); mod.Von = DateTime.Today.AddYears(1); mod.Bis = DateTime.Today.AddDays(10).AddYears(1); target.UpdateReservation(mod, org); ReservationDto result = target.GetReservationByNr(reservationNr); Assert.AreEqual(mod.ReservationNr, result.ReservationNr); Assert.AreEqual(mod.Auto.Id, result.Auto.Id); Assert.AreEqual(mod.Kunde.Id, result.Kunde.Id); Assert.AreEqual(mod.Von, result.Von); Assert.AreEqual(mod.Bis, result.Bis); }
public void UpdateReservation(ReservationDto modifiedReservation, ReservationDto originalReservation) { WriteActualMethod(); autoReservation.UpdateReservation(modifiedReservation.ConvertToEntity(), originalReservation.ConvertToEntity()); }
public void InsertReservationTest() { TestEnvironmentHelper.InitializeTestData(); int count = Target.Reservationen().Count; ReservationDto reservation = new ReservationDto(); int id = 99999; reservation.ReservationNr = id; reservation.Kunde = Target.Kunden()[0]; reservation.Auto = Target.Autos()[0]; reservation.Von = System.DateTime.Today; reservation.Bis = System.DateTime.Today; Target.InsertReservation(reservation); Assert.AreEqual(count + 1, Target.Reservationen().Count); }
public System.Threading.Tasks.Task removeRerservationAsync(AutoReservation.Common.DataTransferObjects.ReservationDto reservationDto) { return(base.Channel.removeRerservationAsync(reservationDto)); }
public void InsertReservation(ReservationDto reservation) { WriteActualMethod(); component.AddReservation(reservation.ConvertToEntity()); }
public void InsertReservationTest() { List<ReservationDto> reservationen = Target.GetAllReservation(); ReservationDto reservation = new ReservationDto(); reservation.ReservationNr = 4; reservation.Kunde = Target.GetKunde(1); reservation.Auto = Target.GetAuto(1); reservation.Von = DateTime.Now; reservation.Bis = DateTime.Now.AddDays(50); Target.AddReservation(reservation); Assert.AreEqual(Target.GetAllReservation().Count, reservationen.Count + 1); }
protected override void Load() { Reservationen.Clear(); Kunden.Clear(); Autos.Clear(); foreach (KundeDto kunde in Service.GetKunden()) { Kunden.Add(kunde); } foreach (AutoDto auto in Service.GetAutos()) { Autos.Add(auto); } foreach (ReservationDto reservation in Service.GetReservationen()) { Reservationen.Add(reservation); } SelectedReservation = Reservationen.FirstOrDefault(); }
public bool isCarAvailable(AutoReservation.Common.DataTransferObjects.ReservationDto reservation, AutoReservation.Common.DataTransferObjects.AutoDto auto) { return(base.Channel.isCarAvailable(reservation, auto)); }
protected override void Load() { Reservationen.Clear(); reservationenOriginal.Clear(); Kunden.Clear(); Autos.Clear(); foreach (KundeDto kunde in Service.AllKunden()) { Kunden.Add(kunde); } foreach (AutoDto auto in Service.AllAutos()) { Autos.Add(auto); } foreach (ReservationDto reservation in Service.AllReservations()) { Reservationen.Add(reservation); reservationenOriginal.Add((ReservationDto)reservation.Clone()); } SelectedReservation = Reservationen.FirstOrDefault(); }
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 void DeleteReservation(ReservationDto reservation) { WriteActualMethod(); autoReservation.DeleteReservation(reservation.ConvertToEntity()); }
protected override void Load() { Kunden.Clear(); foreach (KundeDto kunde in Service.GetKunden()) { Kunden.Add(kunde); } Autos.Clear(); foreach (AutoDto auto in Service.GetAutos()) { Autos.Add(auto); } Reservationen.Clear(); reservationenOriginal.Clear(); foreach (ReservationDto res in Service.GetReservationen()) { Reservationen.Add(res); reservationenOriginal.Add((ReservationDto)res.Clone()); } selectedReservation = Reservationen.FirstOrDefault(); reservationen.ToList().ForEach(r => { r.Auto = Autos.ToList().Find(a => a.Id == r.Auto.Id); r.Kunde = Kunden.ToList().Find(k => k.Id == r.Kunde.Id); }); }