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