private void CheckIfRestaurantExists(RestaurantServiceModel restaurantServiceModel)
{
if (!dbContext.Restaurants.Any(restaurant => restaurant.Id == restaurantServiceModel.Id))
{
throw new ArgumentNullException(nameof(restaurantServiceModel));
}
}
public async Task <IActionResult> Create(string city, string restaurant, CreateReservationBindingModel viewModel)
{
var dateTime = DateTime.Parse(viewModel.Date + " " + viewModel.Time);
var isDateValid = await reservationsService.IsDateValid(dateTime);
if (isDateValid)
{
RestaurantServiceModel restaurantFromDb = await restaurantService.GetRestaurantByNameAndCity(city, restaurant);
ReserveTableUserServiceModel user = await usersService.GetUserByUsername(this.User.Identity.Name);
ReservationServiceModel reservation = await reservationsService.MakeReservation(viewModel, user, restaurantFromDb);
if (reservation == null)
{
ModelState.AddModelError("NoAvailableTables", "There are no available tables.");
return(this.View());
}
return(this.Redirect("/Reservations/My"));
}
else
{
ModelState.AddModelError("InvalidData", "Your date is not valid.");
}
return(this.View());
}
public async Task AddTable_WithCorrectData_ShouldCreateSucessfully()
{
var errorMessage = "Table service AddTable() method is not working correctly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.tableService = new TableService(context);
await SeedData(context);
AddTableBindingModel model = new AddTableBindingModel
{
SeatsCount = 5
};
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "Ivan Vazov",
AverageRating = 10,
Name = "Happy",
PhoneNumber = "08888888888",
Photo = "src/happy-photo.jpg",
CityId = "1"
};
var actualResult = await this.tableService.AddTable(model, restaurant);
Assert.True(actualResult, errorMessage);
}
public async Task GetRestaurantTables_WithData_ShouldReturnCorrectResults()
{
string errorMessagePrefix = "Table service GetAllProducts() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
await SeedData(context);
this.tableService = new TableService(context);
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "Ivan Vazov",
AverageRating = 10,
Name = "Happy",
PhoneNumber = "08888888888",
Photo = "src/happy-photo.jpg",
CityId = "1"
};
var tables = await this.tableService.GetRestaurantTables(restaurant);
List <TableServiceModel> actualResults = tables.ToList();
List <TableServiceModel> expectedResults = GetTableData().To <TableServiceModel>().ToList();
for (int i = 0; i < expectedResults.Count; i++)
{
var expectedEntry = expectedResults[i];
var actualEntry = actualResults[i];
Assert.True(expectedEntry.SeatsCount == actualEntry.SeatsCount, errorMessagePrefix + " " + "Seats count is not returned properly.");
Assert.True(expectedEntry.RestaurantId == actualEntry.RestaurantId, errorMessagePrefix + " " + "Restaurant Id is not returned properly.");
}
}
public async Task AddTable_InInvalidRestaurant_ShouldNotCreate()
{
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.tableService = new TableService(context);
await SeedData(context);
AddTableBindingModel model = new AddTableBindingModel
{
SeatsCount = 5
};
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "3",
Address = "Ivan Vazov",
AverageRating = 10,
Name = "Happy",
PhoneNumber = "08888888888",
Photo = "src/happy-photo.jpg",
CityId = "1"
};
await Assert.ThrowsAsync <ArgumentNullException>(() => tableService.AddTable(model, restaurant));
}
public async Task GetRestaurantById_WithData_ShouldReturnCorrectResult()
{
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.restaurantService = new RestaurantService(context);
await SeedData(context);
var restaurantId = "1";
var expectedResult = new RestaurantServiceModel
{
Id = "1",
Name = "Ego",
Address = "Egos Address",
CityId = "1",
PhoneNumber = "0888888888",
Photo = "/src/ego-photo.jpg"
};
var actualResult = await restaurantService.GetRestaurantById(restaurantId);
Assert.Equal(expectedResult.Name, actualResult.Name);
Assert.Equal(expectedResult.Address, actualResult.Address);
Assert.Equal(expectedResult.CityId, actualResult.CityId);
Assert.Equal(expectedResult.PhoneNumber, actualResult.PhoneNumber);
Assert.Equal(expectedResult.Photo, actualResult.Photo);
}
public async Task <IQueryable <TableServiceModel> > GetRestaurantTables(RestaurantServiceModel restaurant)
{
var tables = dbContext.Tables
.Where(t => t.RestaurantId == restaurant.Id)
.To <TableServiceModel>();
return(tables);
}
public async Task GetRestaurantsInCity_WithDataAlphabeticallyDescending_ShouldReturnCorrectResults()
{
string errorMessagePrefix = "CityService GetRestaurantsInCity() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
await Seed(context);
this.cityService = new CityService(context);
var restaurantInPlovdiv = new RestaurantServiceModel
{
Id = "1",
Name = "Happy",
Address = "Ivan Vazov",
AverageRating = 10,
CityId = "1",
PhoneNumber = "0888888888",
Photo = "/src/Happy.jpg"
};
var restaurantInPlovdiv2 = new RestaurantServiceModel
{
Id = "3",
Name = "KFC",
Address = "Vasil Levski",
AverageRating = 7,
CityId = "1",
PhoneNumber = "0888888899",
Photo = "/src/KFC.jpg"
};
var restaurantsInCity = await this.cityService.GetRestaurantsInCity("Plovdiv", "alphabetically-z-to-a");
List <RestaurantServiceModel> actualResults = restaurantsInCity.ToList();
List <RestaurantServiceModel> expectedResults = new List <RestaurantServiceModel>
{
restaurantInPlovdiv,
restaurantInPlovdiv2
}
.OrderByDescending(r => r.Name)
.ToList();
for (int i = 0; i < expectedResults.Count; i++)
{
var expectedEntry = expectedResults[i];
var actualEntry = actualResults[i];
Assert.True(expectedEntry.Name == actualEntry.Name, errorMessagePrefix + " " + "Name is not returned properly.");
Assert.True(expectedEntry.Address == actualEntry.Address, errorMessagePrefix + " " + "Address is not returned properly.");
Assert.True(expectedEntry.PhoneNumber == actualEntry.PhoneNumber, errorMessagePrefix + " " + "Phone Number is not returned properly.");
Assert.True(expectedEntry.CityId == actualEntry.CityId, errorMessagePrefix + " " + "City Id is not returned properly.");
Assert.True(expectedEntry.AverageRating == actualEntry.AverageRating, errorMessagePrefix + " " + "Average Rating is not returned properly.");
Assert.True(expectedEntry.Photo == actualEntry.Photo, errorMessagePrefix + " " + "Photo is not returned properly.");
}
}
public async Task <double> GetAverageRate(RestaurantServiceModel restaurantServiceModel)
{
var reviews = await dbContext.Reviews
.Where(r => r.RestaurantId == restaurantServiceModel.Id)
.ToListAsync();
double average = Math.Round((reviews.Sum(r => r.Rate)) / reviews.Count(), 1);
return(average);
}
public async Task <IActionResult> Add(string city, string restaurant, AddTableBindingModel model)
{
RestaurantServiceModel restaurantFromDb = await restaurantService.GetRestaurantByNameAndCity(city, restaurant);
if (ModelState.IsValid)
{
await tablesService.AddTable(model, restaurantFromDb);
}
return(this.Redirect($"/Tables/{city}/{restaurant}"));
}
public async Task <bool> CreateNewRestaurant(RestaurantServiceModel restaurantServiceModel)
{
Restaurant restaurant = AutoMapper.Mapper.Map <Restaurant>(restaurantServiceModel);
CheckIfCityExists(restaurant);
ValidateRestaurant(restaurant);
await dbContext.Restaurants.AddAsync(restaurant);
var result = await dbContext.SaveChangesAsync();
return(result > 0);
}
public async Task GetRestaurantByNameAndCity_WithInvalidData_ShouldReturnNull()
{
string errorMessage = "RestaurantService GetRestaurantByNameAndCity() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.restaurantService = new RestaurantService(context);
await SeedData(context);
string city = "Plovdiv";
string restaurant = "Happy";
RestaurantServiceModel actualResult = await restaurantService.GetRestaurantByNameAndCity(city, restaurant);
Assert.True(actualResult == null, errorMessage);
}
public async Task MakeReservation_WithNoAvailableTables_ShouldReturnNull()
{
string errorMessage = "ReservationService MakeReservation() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.reservationService = new ReservationService(context);
await SeedData(context);
CreateReservationBindingModel reservationBindingModel = new CreateReservationBindingModel
{
Date = "09/08/2019 20:00:00",
SeatsCount = 4,
Restaurant = "Happy"
};
ReserveTableUserServiceModel user = new ReserveTableUserServiceModel
{
Id = "1",
Email = "*****@*****.**",
UserName = "******"
};
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "New Street",
AverageRating = 10,
CityId = "1",
Name = "Happy",
PhoneNumber = "0888888888",
Photo = "/src/happy.jpg",
Tables = new List <TableServiceModel>()
{
new TableServiceModel
{
Id = "1",
SeatsCount = 2,
RestaurantId = "1",
Reservations = new List <ReservationServiceModel>()
}
}
};
var actualResult = await reservationService.MakeReservation(reservationBindingModel, user, restaurant);
Assert.True(actualResult == null, errorMessage);
}
public async Task <bool> CheckIfExists(RestaurantServiceModel restaurantServiceModel, string cityName)
{
var allRestaurants = await dbContext.Restaurants
.Include(r => r.City)
.ToListAsync();
if (allRestaurants
.Any(r => r.Name == restaurantServiceModel.Name &&
r.City.Name == cityName &&
r.Address == restaurantServiceModel.Address))
{
return(true);
}
return(false);
}
public async Task <bool> AddTable(AddTableBindingModel model, RestaurantServiceModel restaurantServiceModel)
{
var table = new Table
{
SeatsCount = model.SeatsCount,
RestaurantId = restaurantServiceModel.Id
};
ValidateTable(table);
CheckIfRestaurantExists(restaurantServiceModel);
await dbContext.Tables.AddAsync(table);
var result = await dbContext.SaveChangesAsync();
return(result > 0);
}
public async Task CreateNewRestaurant_WithInvalidAddress_ShouldThrowArgumentException(string address)
{
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.restaurantService = new RestaurantService(context);
await SeedData(context);
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Name = "Happy",
Address = address,
CityId = "1",
PhoneNumber = "08888888888",
Photo = "/src/happy.jpg"
};
await Assert.ThrowsAsync <ArgumentException>(() => this.restaurantService.CreateNewRestaurant(restaurant));
}
public async Task CreateNewRestaurant_InNotExistentCity_ShouldThrowArgumentNullException()
{
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.restaurantService = new RestaurantService(context);
await SeedData(context);
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Name = "Happy",
Address = "Center",
CityId = "2",
PhoneNumber = "08888888888",
Photo = "/src/happy.jpg"
};
await Assert.ThrowsAsync <ArgumentNullException>(() => this.restaurantService.CreateNewRestaurant(restaurant));
}
public async Task CreateNewRestaurant_WithCorrectData_ShouldCreateSucessfully()
{
string errorMessage = "RestaurantService CreateNewRestaurant() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.restaurantService = new RestaurantService(context);
await SeedData(context);
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Name = "Happy",
Address = "Center",
CityId = "1",
PhoneNumber = "08888888888",
Photo = "/src/happy.jpg"
};
bool actualResult = await this.restaurantService.CreateNewRestaurant(restaurant);
Assert.True(actualResult, errorMessage);
}
public async Task <IActionResult> My()
{
var username = this.User.Identity.Name;
IQueryable <ReservationServiceModel> reservationsServiceModel = await reservationsService.GetMyReservations(username);
var list = new List <MyReservationViewModel>();
foreach (var reservation in reservationsServiceModel)
{
RestaurantServiceModel restaurant = await restaurantService.GetRestaurantById(reservation.RestaurantId);
var reservationViewModel = AutoMapper.Mapper.Map <MyReservationViewModel>(reservation);
list.Add(reservationViewModel);
}
MyReservationsListViewModel viewModel = new MyReservationsListViewModel
{
Reservations = list.OrderBy(r => r.Date).ToList()
};
return(this.View(viewModel));
}
public async Task GetAverageRate_WithData_ShouldReturnCorrectResult()
{
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.restaurantService = new RestaurantService(context);
await SeedData(context);
var restaurant = new RestaurantServiceModel
{
Id = "1",
Name = "Ego",
Address = "Egos Address",
CityId = "1",
PhoneNumber = "0888888888",
Photo = "/src/ego-photo.jpg"
};
var reviews = context.Reviews.Where(r => r.Restaurant.Name == "Ego").ToList();
var expectedResult = (reviews.Sum(r => r.Rate)) / (reviews.Count);
var actualResult = await restaurantService.GetAverageRate(restaurant);
Assert.Equal(expectedResult, actualResult);
}
public async Task CheckIfExists_WithNotExistingRestaurant_ShouldReturnFalse()
{
string errorMessage = "RestaurantService CheckIfExists() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.restaurantService = new RestaurantService(context);
await SeedData(context);
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "1",
Name = "Mc Donalds",
Address = "Egos Address",
CityId = "1",
PhoneNumber = "0888888888",
Photo = "/src/mcd-photo.jpg"
};
string cityName = "Plovdiv";
var actualResult = await restaurantService.CheckIfExists(restaurant, cityName);
Assert.False(actualResult, errorMessage);
}
public async Task <ReservationServiceModel> MakeReservation(CreateReservationBindingModel viewModel, ReserveTableUserServiceModel user, RestaurantServiceModel restaurant)
{
var dateTime = DateTime.Parse(viewModel.Date + " " + viewModel.Time);
var tablesWithExactCountSeats = restaurant.Tables
.Where(t => t.SeatsCount == viewModel.SeatsCount)
.ToList();
var tablesWithSeatsCountPlusOne = restaurant.Tables
.Where(t => t.SeatsCount == viewModel.SeatsCount + 1)
.ToList();
ReservationServiceModel reservationServiceModel = new ReservationServiceModel();
if (tablesWithExactCountSeats.Any())
{
foreach (var table in tablesWithExactCountSeats)
{
return(await FindTable(viewModel, user, restaurant, dateTime, reservationServiceModel, table));
}
}
else if (tablesWithSeatsCountPlusOne.Any())
{
foreach (var biggerTable in tablesWithSeatsCountPlusOne)
{
return(await FindTable(viewModel, user, restaurant, dateTime, reservationServiceModel, biggerTable));
}
}
return(null);
}
private static void InitializeReservation(CreateReservationBindingModel viewModel, ReserveTableUserServiceModel user, RestaurantServiceModel restaurant, DateTime dateTime, ReservationServiceModel reservationServiceModel, TableServiceModel table)
{
reservationServiceModel.ForDate = dateTime;
reservationServiceModel.SeatsCount = viewModel.SeatsCount;
reservationServiceModel.UserId = user.Id;
reservationServiceModel.TableId = table.Id;
reservationServiceModel.RestaurantId = restaurant.Id;
}
private async Task <ReservationServiceModel> FindTable(CreateReservationBindingModel viewModel, ReserveTableUserServiceModel user, RestaurantServiceModel restaurant, DateTime dateTime, ReservationServiceModel reservationServiceModel, TableServiceModel table)
{
if (table.Reservations.Any(t => (dateTime > t.ForDate && dateTime < t.EndOfReservation) && t.IsCancelled == false))
{
return(null);
}
else
{
InitializeReservation(viewModel, user, restaurant, dateTime, reservationServiceModel, table);
var reservation = AutoMapper.Mapper.Map <Reservation>(reservationServiceModel);
await dbContext.Reservations.AddAsync(reservation);
await dbContext.SaveChangesAsync();
return(reservationServiceModel);
}
}
public async Task MakeReservation_WithCorrectData_ShouldCreateSucessfully(int seats)
{
string errorMessage = "ReservationService MakeReservation() method does not work properly.";
var context = ReserveTableDbContextInMemoryFactory.InitializeContext();
this.reservationService = new ReservationService(context);
await SeedData(context);
CreateReservationBindingModel reservationBindingModel = new CreateReservationBindingModel
{
Date = "09/08/2019 20:00:00",
SeatsCount = seats,
Restaurant = "Happy"
};
ReserveTableUserServiceModel user = new ReserveTableUserServiceModel
{
Id = "1",
Email = "*****@*****.**",
UserName = "******"
};
RestaurantServiceModel restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "New Street",
AverageRating = 10,
CityId = "1",
Name = "Happy",
PhoneNumber = "0888888888",
Photo = "/src/happy.jpg",
Tables = new List <TableServiceModel>()
{
new TableServiceModel
{
Id = "1",
SeatsCount = 2,
RestaurantId = "1",
Reservations = new List <ReservationServiceModel>()
}
}
};
var expectedResult = new ReservationServiceModel
{
ForDate = new DateTime(2019, 08, 09, 20, 0, 0),
Restaurant = new RestaurantServiceModel
{
Id = "1",
Address = "New Street",
AverageRating = 10,
CityId = "1",
Name = "Happy",
PhoneNumber = "0888888888",
Photo = "/src/happy.jpg",
Tables = new List <TableServiceModel>()
{
new TableServiceModel
{
Id = "1",
SeatsCount = 2,
RestaurantId = "1",
Reservations = new List <ReservationServiceModel>()
}
}
},
SeatsCount = seats,
UserId = "1"
};
var actualResult = await reservationService.MakeReservation(reservationBindingModel, user, restaurant);
Assert.True(expectedResult.SeatsCount == actualResult.SeatsCount, errorMessage + " " + "Seats Count is not returned properly");
Assert.True(expectedResult.ForDate == actualResult.ForDate, errorMessage + " " + "For Date is not returned properly");
Assert.True(expectedResult.UserId == actualResult.UserId, errorMessage + " " + "User Id is not returned properly");
}
