public async Task CreateAsync_ShouldSuccessfullyAddToDatabase()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var hotelRepository = new EfDeletableEntityRepository <Hotel>(context);
var service = new HotelsService(hotelRepository);
var inputModel = new HotelInputModel();
inputModel.Name = "HotelName";
inputModel.ImageUrl = "ImageUrl";
inputModel.Description = "Description";
inputModel.Address = "Adress";
inputModel.DestinationId = 1;
inputModel.PricePerNightPerPerson = 0;
inputModel.Stars = 1;
inputModel.AvailableRooms = 1;
inputModel.FeedingType = FeedingType.Breakfast;
inputModel.ReservationType = ReservationType.Hotel;
var expectedResult = 1;
// Act
await service.CreateAsync(inputModel);
var actualResult = hotelRepository.All().Count();
// Assert
Assert.True(expectedResult == actualResult);
}
public HotelSearchVm()
{
FilterBtn = new RelayCommand <string>(FilterToggle);
Filters = new Dictionary <string, object>();
this._service = new HotelsService();
var GetHotelResult = Task.Run(() => HotelsService.GetHotels()).Result;
if (GetHotelResult == null)
{
_hotels = new ObservableCollection <Hotel>();
}
else
{
_hotels = Task.Run(() => HotelsService.GetHotels()).Result;
}
if (GetHotelResult == null)
{
TempHotel = new ObservableCollection <Hotel>();
}
else
{
TempHotel = Task.Run(() => HotelsService.GetHotels()).Result;
}
DistansToBeach = 50;
DistansToCenter = 50;
}
private void ConfirmBookingBtn_Click(object sender, RoutedEventArgs e)
{
inputNummer = TeleNummer.Text;
inputAdress = Adress.Text;
Task.Run(() => HotelsService.PostBooking(bookingPageViewModel._selectedRooms, FrontPageSearchViewModel.Search.StartDate, FrontPageSearchViewModel.Search.EndDate, inputNummer, inputAdress));
bookingPageViewModel.bookingMessage();
Frame.Navigate(typeof(FrontPageSearch));
}
public async Task EditAsync_ShouldWorkCorrectly()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var seeder = new HotelsServiceTestsSeeder();
await seeder.SeedHotelAsync(context);
var hotelRepository = new EfDeletableEntityRepository <Hotel>(context);
var service = new HotelsService(hotelRepository);
var hotel = hotelRepository.All().First();
var model = new HotelViewModel
{
Id = hotel.Id,
Name = hotel.Name,
ImageUrl = hotel.ImageUrl,
Description = hotel.Description,
Address = hotel.Address,
DestinationId = hotel.DestinationId,
PricePerNightPerPerson = hotel.PricePerNightPerPerson,
Stars = hotel.Stars,
AvailableRooms = hotel.AvailableRooms,
FeedingType = hotel.FeedingType,
ReservationType = hotel.ReservationType,
};
model.Name = "EditedHotelName";
model.ImageUrl = "EditedImageUrl";
model.PricePerNightPerPerson = 50;
model.ReservationType = ReservationType.Hotel;
model.Description = "EditedDescription";
model.Address = "EditedAddress";
model.DestinationId = 1;
model.Stars = 1;
model.AvailableRooms = 2;
model.FeedingType = FeedingType.HalfBoard;
// Act
await service.EditAsync(model.Id, model);
var actualResult = hotelRepository.All().First();
var expectedResult = model;
// Assert
Assert.True(expectedResult.Name == actualResult.Name);
Assert.True(expectedResult.ImageUrl == actualResult.ImageUrl);
Assert.True(expectedResult.Description == actualResult.Description);
Assert.True(expectedResult.ReservationType == actualResult.ReservationType);
Assert.True(expectedResult.PricePerNightPerPerson == actualResult.PricePerNightPerPerson);
Assert.True(expectedResult.Address == actualResult.Address);
Assert.True(expectedResult.AvailableRooms == actualResult.AvailableRooms);
Assert.True(expectedResult.Stars == actualResult.Stars);
Assert.True(expectedResult.FeedingType == actualResult.FeedingType);
Assert.True(expectedResult.DestinationId == actualResult.DestinationId);
}
public IActionResult Select(int?id)
{
if (id == null)
{
return(NotFound());
}
hotelsService = new HotelsService();
Hotels hotel = hotelsService.Get(Convert.ToInt16(id));
return(View());
}
public async Task TestCreateHotel()
{
var hotels = new List <Hotel>();
var mockHotelRepo = new Mock <IDeletableEntityRepository <Hotel> >();
mockHotelRepo.Setup(x => x.All()).Returns(hotels.AsQueryable());
mockHotelRepo.Setup(x => x.AddAsync(It.IsAny <Hotel>())).Callback(
(Hotel hotel) => hotels.Add(hotel));
var service = new HotelsService(mockHotelRepo.Object);
await service.CreateAsync("Test Name", 1, "Test Address", 1, 2, null);
Assert.Single(hotels);
}
private async void AddUserButton_OnClick(object sender, RoutedEventArgs e)
{
var users = RegistrationPageViewModel.Users;
var user = new User
{
FirstName = FirstNameField.Text,
LastName = LastNameField.Text,
Email = EmailField.Text,
Password = PasswordField.Text
};
users.Add(user);
user = await HotelsService.AddUsersAsync(user);
this.Frame.Navigate(typeof(FrontPageSearch));
}
public ActionResult Index()
{
HotelsService hotels = ServiceFactory.GetHotelsService();
IndexViewModel model = new IndexViewModel();
foreach (Hotel hotel in hotels.GetAllHotels())
{
HotelViewModel hotelVM = new HotelViewModel
{
Name = hotel.Name,
Address = hotel.Address,
Stars = hotel.Stars
};
model.Hotels.Add(hotelVM);
}
return(View(model));
}
public async Task IsExistingMethod_ShouldReturnFalseIfFlightNotExists()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var seeder = new HotelsServiceTestsSeeder();
await seeder.SeedHotelAsync(context);
var hotelRepository = new EfDeletableEntityRepository <Hotel>(context);
var service = new HotelsService(hotelRepository);
// Act
var actualResult = service.Exists(2);
var expectedResult = false;
// Assert
Assert.True(actualResult == expectedResult);
}
public async Task TestUpdateHotel()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var hotelRepository = new EfDeletableEntityRepository <Hotel>(new ApplicationDbContext(options.Options));
await hotelRepository.AddAsync(new Hotel { Id = 1, Name = "Test Hotel Name One" });
await hotelRepository.SaveChangesAsync();
var hotelsService = new HotelsService(hotelRepository);
await hotelsService.UpdateAsync(1, "Test Hotel", 1, null, 1, 1);
var result = hotelRepository.All().FirstOrDefault();
Assert.Equal("Test Hotel", result.Name);
}
private void ContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
if (inputAdress.Text != "" && inputPhoneNumber.Text != "")
{
tempBooking.Adress = inputAdress.Text;
tempBooking.PhoneNumber = inputPhoneNumber.Text;
Task.Run(() => HotelsService.UpdateBooking(tempBooking));
}
else if (inputAdress.Text != "")
{
tempBooking.Adress = inputAdress.Text;
Task.Run(() => HotelsService.UpdateBooking(tempBooking));
}
else if (inputPhoneNumber.Text != "")
{
tempBooking.PhoneNumber = inputPhoneNumber.Text;
Task.Run(() => HotelsService.UpdateBooking(tempBooking));
}
}
public async Task TestGetHotelByIdWithDeletedRoom()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var hotelRepository = new EfDeletableEntityRepository <Hotel>(new ApplicationDbContext(options.Options));
var hotel = new Hotel
{
Id = 1,
Name = "Test Hotel",
};
var roomOne = new Room
{
Id = 1,
Number = "100",
IsDeleted = true,
};
var roomTwo = new Room
{
Id = 2,
Number = "200",
IsDeleted = false,
};
hotel.Rooms.Add(roomOne);
hotel.Rooms.Add(roomTwo);
await hotelRepository.AddAsync(hotel);
await hotelRepository.SaveChangesAsync();
var hotelsService = new HotelsService(hotelRepository);
AutoMapperConfig.RegisterMappings(typeof(MyTestHotel).Assembly);
var result = await hotelsService.GetByIdWithDeletedAsync <MyTestHotel>(1);
Assert.Equal(2, result.Rooms.Count());
}
public async Task TestGetHotelById()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var hotelRepository = new EfDeletableEntityRepository <Hotel>(new ApplicationDbContext(options.Options));
await hotelRepository.AddAsync(new Hotel { Id = 1, Name = "Test Hotel Name One" });
await hotelRepository.AddAsync(new Hotel { Id = 2, Name = "Test Hotel Name Two" });
await hotelRepository.SaveChangesAsync();
var hotelsService = new HotelsService(hotelRepository);
AutoMapperConfig.RegisterMappings(typeof(MyTestHotel).Assembly);
var result = await hotelsService.GetByIdAsync <MyTestHotel>(1);
Assert.Equal("Test Hotel Name One", result.Name);
}
public async Task DeleteAsync_ShouldSuccessfullyDelete()
{
// Arrange
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var seeder = new HotelsServiceTestsSeeder();
await seeder.SeedHotelAsync(context);
var hotelRepository = new EfDeletableEntityRepository <Hotel>(context);
var service = new HotelsService(hotelRepository);
var hotelId = hotelRepository.All().First().Id;
// Act
var hotelsCount = hotelRepository.All().Count();
await service.DeleteAsync(hotelId);
var actualResult = hotelRepository.All().Count();
var expectedResult = hotelsCount - 1;
// Assert
Assert.True(actualResult == expectedResult);
}
public void ReturnsAnInstance_WhenAllParametersAreNotNull()
{
// Arrange
var hotelRepoMock = new Mock <IEfRepository <Hotel> >();
var countriesServiceMock = new Mock <ICountriesService>();
var citiesServiceMock = new Mock <ICitiesService>();
var userServiceMock = new Mock <IUserService>();
var countriesRepoMock = new Mock <IEfRepository <Country> >();
var dbContextMock = new Mock <ISaveContext>();
// Act
HotelsService hotelsService = new HotelsService(
hotelRepoMock.Object,
countriesServiceMock.Object,
citiesServiceMock.Object,
userServiceMock.Object,
countriesRepoMock.Object,
dbContextMock.Object
);
// Assert
Assert.IsNotNull(hotelsService);
}
public async void SearchButton_OnClick(object sender, RoutedEventArgs e)
{
//GetAllCitiesInRegions();
FrontPageSearchViewModel.TempCity.Clear();
var regions = await HotelsService.GetAllRegionsAsync();
var cities = FrontPageSearchViewModel.Cities;
var tempCity = FrontPageSearchViewModel.TempCity;
var searchString = SearchField.Text;
var endDate = EndDate.MaxDate;
var startDate = StartDate.MinDate;
foreach (Regions r in regions)
{
if (searchString.ToLower() == r.NameOfRegion.ToLower())
{
Region = r;
foreach (City city in r.Cities)
{
tempCity.Add(city);
}
break;
//TODO add get method for cities and dates
//TODO check number of rooms at get. If rooms < 3 don't show
}
}
if (!tempCity.Any())
{
IfNotFoundLabel.Text = "Tyvärr, vi hittade inget som matchade din sökning.";
}
else
{
IfNotFoundLabel.Text = ($"Vi hittade ({tempCity.Count()}) hotell.");
}
}
public void GetUserBookings()
{
_newBookings = Task.Run(() => HotelsService.GetNewBookings(LogInViewModel.User.ID)).Result;
_oldBookings = Task.Run(() => HotelsService.GetOldBookings(LogInViewModel.User.ID)).Result;
}
private HotelsService GetHotelsService(EfDeletableEntityRepository <HotelData> hotelRepository)
{
var hotelService = new HotelsService(hotelRepository);
return(hotelService);
}
public BookingPageViewModel()
{
this.hotelServiceDal = new HotelsService();
}
public HomeController()
{
userService = new UserService();
hotelsService = new HotelsService();
}
public IActionResult Payment(List <CartVM> cart)
{
string userID = User.FindFirst(ClaimTypes.NameIdentifier).Value;
HotelsService hotelsService = new HotelsService();
StatusService statusService = new StatusService();
AspNetUsersService klantService = new AspNetUsersService();
StedenService stedenService = new StedenService();
OrderService orderService = new OrderService();
KlasseService klasseService = new KlasseService();
TicketService ticketService = new TicketService();
try
{
var id = 0;
Order geboekteOrder = new Order();
foreach (CartVM c in cart)
{
Order order = new Order();
order.Klant = klantService.Get(userID);
order.KlantId = userID;
order.AantalTickets = c.AantalTickets;
order.Klasse = klasseService.GetKlasseVanId(c.Klasse);
order.Prijs = (decimal)c.Prijs;
order.Status = statusService.Get(1);
order.StatusId = 1;
order.Boekingsdatum = DateTime.UtcNow;
order.TrajectId = c.TrajectId;
order.Aankomstdatum = c.Aankomstdatum;
order.Vertrekdatum = c.Vertrekdatum;
orderService.Create(order);
geboekteOrder = orderService.Get(order.OrderId);
id = geboekteOrder.OrderId;
RittenService rittenService = new RittenService();
IEnumerable <Ritten> reisMogelijkheden = rittenService.GetRittenVanTrajectId(c.TrajectId);
ReisMogelijkhedenService reisMogelijkhedenService = new ReisMogelijkhedenService();
//aanmaken van tickets
for (int i = 0; i < c.AantalTickets; i++)
{
foreach (var item in reisMogelijkheden)
{
Ticket ticket = new Ticket();
ticket.OrderId = id;
ticket.Zetelnummer = ticketService.GetAantalPlaatsenGereserveerd(item.ReisMogelijkhedenId, c.Vertrekdatum, c.Klasse) + 1;
ticket.VoornaamPassagier = c.Voornamen.ElementAt(i);
ticket.AchternaamPassagier = c.Achternamen.ElementAt(i);
ticket.ReismogelijkhedenId = item.ReisMogelijkhedenId;
ticket.Reismogelijkheden = reisMogelijkhedenService.Get(item.ReisMogelijkhedenId);
ticketService.Create(ticket);
}
}
Delete(c.TrajectId);
}
return(RedirectToAction("Validation"));
}
catch (DataException ex)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
catch (Exception ex)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "call system administrator.");
}
return(View("Index"));
}
public void GetUser(string email, string password)
{
User = Task.Run(() => HotelsService.GetUser(email, password)).Result;
}
public RoomSelectionVm()
{
this.Vm = new HotelsService();
_roomBasket = new ObservableCollection <Room>();
_rooms = Task.Run(() => HotelsService.GetRooms(HotelsService.SelectedHotel.HotelID)).Result;
}
public void DeleteBooking(Booking booking)
{
Task.Run(() => HotelsService.DeleteBooking(booking));
}
