public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Restaurants = new RestaurantRepository(context);
Dishes = new DishRepository(context);
Basket = new BasketItemRepository(context);
}
public ReviewsIndexVM(ReviewRepository newReviewRepository, RestaurantRepository newRestaurantRepository)
{
reviewRepository = newReviewRepository;
restaurantRepository = newRestaurantRepository;
MyReviews = reviewRepository.GetAll().Reverse(); // Most recently created first
MyRestaurants = restaurantRepository.GetAll();
}
public ActionResult Search(string searchVal)
{
RestaurantRepository restaurantRepository = new RestaurantRepository();
// just in case prevent NullPointerException
if (searchVal == null)
{
searchVal = string.Empty;
}
// compare all words to lower case
searchVal = searchVal.ToLower();
// use lambda expression to filter the matched objects
List <Restaurant> foundRestarants = restaurantRepository.GetAll()
.Where(c => c.Name.ToLower().Contains(searchVal) ||
c.Description.ToLower().Contains(searchVal))
.ToList();
// convert the DB objects to ViewModel objects
List <SearchViewModel> model = new List <SearchViewModel>();
foreach (Restaurant dbRestaurant in foundRestarants)
{
SearchViewModel modelItem = new SearchViewModel(dbRestaurant);
model.Add(modelItem);
}
return(View(model));
}
public async void AddNewBtn_Clicked(object sender, EventArgs e)
{
Restaurant restaurant = new Restaurant()
{
ID = 0,
Name = txtName.Text,
Address = txtAddress.Text,
OpenAt = dtOpenAt.Time,
CloseAt = dtCloseAt.Time,
Delivery = chkDeliver.IsChecked,
Dining = chkDining.IsChecked,
TakeAway = chkTakeAway.IsChecked,
Phone = txtPhone.Text,
Website = txtWebsite.Text
};
RestaurantRepository repository = new RestaurantRepository();
if (await repository.AddRestaurent(restaurant))
{
if (await DisplayAlert("Notify", "Entity added successfull", "Done", "Add More"))
{
await Navigation.PopAsync(true);
}
}
}
public void DeleteRestaurant()
{
try
{
// Arrange
var restaurantRepository = new RestaurantRepository(RestaurantReviewsContext);
var newRestaurant = new Restaurant
{
Address = "10 Leninskiy Rayon",
City = "Novosibirsk",
Country = "Russian Federation",
EmailAddress = "*****@*****.**",
IsConfirmed = true,
Name = "Novosibirsk Eats 3",
Phone = "+7 961 222-87-45",
PostalCode = "630001",
State = "Siberia",
WebsiteUrl = "www.novosibirskeats.com"
};
restaurantRepository.CreateRestaurant(newRestaurant).Wait();
var savedRestaurant = restaurantRepository.GetRestaurantById(newRestaurant.Id).Result;
Assert.IsNotNull(savedRestaurant, string.Format("Restaurant {0} was not saved in the database", newRestaurant.Id));
Assert.IsTrue(savedRestaurant.Name == newRestaurant.Name, string.Format("Restaurant({0}).Name was not saved in the database", newRestaurant.Id));
// Act
restaurantRepository.DeleteRestaurant(savedRestaurant).Wait();
// Assert
var shouldBeDeletedRestaurant = restaurantRepository.GetRestaurantById(newRestaurant.Id).Result;
Assert.IsTrue(shouldBeDeletedRestaurant.IsEmptyObject(), string.Format("Restaurant({0}) was not deleted from the database", newRestaurant.Id));
}
catch (Exception ex)
{
Assert.Fail(string.Format("An unexpected exception occurred in DeleteRestaurant {0}", ex.Message));
}
}
public ActionResult Edit(int id = 0)
{
// add the Cities to the Viewbag
CityRepository cityRepository = new CityRepository();
List <City> allCities = cityRepository.GetAll();
ViewBag.AllCities = new SelectList(allCities, "ID", "Name");
// add the Categories to the Viewbag
CategoryRepository categoryRepository = new CategoryRepository();
List <Category> allCategories = categoryRepository.GetAll();
ViewBag.AllCategories = new SelectList(allCategories, "ID", "Name");
// create the viewmodel, based on the Restaurant from the database
RestaurantViewModel model = new RestaurantViewModel();
RestaurantRepository restaurantRepository = new RestaurantRepository();
Restaurant dbRestaurant = restaurantRepository.GetByID(id);
if (dbRestaurant != null)
{
model = new RestaurantViewModel(dbRestaurant);
}
return(View(model));
}
public UnitOfWork(CMMIContext context)
{
this.context = context;
Restaurants = new RestaurantRepository(context);
Reviews = new ReviewRepository(context);
Users = new UserRepository(context);
}
public AddRestaurantForm()
{
InitializeComponent();
_restaurantRepository = new RestaurantRepository();
_kitchenRepository = new KitchenRepository();
KitchenModelComboBox.SelectedIndex = 0;
}
public IActionResult SearchRestaurants([FromQuery] SearchRestaurantModel ratingFilter)
{
if (!ratingFilter.IsNameExist &&
!ratingFilter.IsMenuItemExist &&
!ratingFilter.IsAddressExist &&
!ratingFilter.IsLocationExist &&
!ratingFilter.IsSortApplied)
{
return(BadRequest("Invalid search, please provide search criteria"));
}
List <Restaurant> result = null;
var error = string.Empty;
RestaurantRepository repository = new RestaurantRepository();
try
{
result = repository.SearchRestaurants(ratingFilter);
}
catch (System.Exception ex)
{
error = ex.Message;
}
if (result != null)
{
return(Ok(result));
}
else
{
return(BadRequest(error));
}
}
public IActionResult RateTheRestaurant(RatingModel rating)
{
string fault = IsValidRating(rating);
if (!string.IsNullOrEmpty(fault))
{
return(BadRequest(fault));
}
var result = false;
var error = string.Empty;
RestaurantRepository repository = new RestaurantRepository();
try
{
result = repository.UpdateRestaurantOrMenuItemRating(rating);
}
catch (System.Exception ex)
{
error = ex.Message;
}
if (result)
{
return(Ok());
}
else
{
return(BadRequest(error));
}
}
public VoteController(RestaurantRepository restaurantRepository, VoteRepository voteRepository, UsersRepository usersRepository, Services services)
{
this.restaurantRepository = restaurantRepository;
this.voteRepository = voteRepository;
this.usersRepository = usersRepository;
this.services = services;
}
public RestaurantsController(RestaurantRepository newRestaurantRepository,
ReviewRepository newReviewRepository)
{
log = LogManager.GetLogger("file");
restaurantRepository = newRestaurantRepository;
reviewRepository = newReviewRepository;
}
public FCDatabaseContext(SqlConnection connection)
{
_connection = connection;
_products = new ProductRepository(connection);
_restaurants = new RestaurantRepository(connection);
_reviews = new ReviewRepository(connection);
}
private void RestaurantRepositoryAddMethodShouldHaveReceived(Restaurant restaurant)
{
RestaurantRepository.Received().Add(Arg.Is <Restaurant>(x => x.Id == restaurant.Id));
RestaurantRepository.Received().Add(Arg.Is <Restaurant>(x => x.City == restaurant.City));
RestaurantRepository.Received().Add(Arg.Is <Restaurant>(x => x.Country == restaurant.Country));
RestaurantRepository.Received().Add(Arg.Is <Restaurant>(x => x.Name == restaurant.Name));
}
public void GetRestaurantDetails()
{
var data = new List <Restaurant>
{
new Restaurant {
name = "Subway", address = "123 Revature Street", phone = "1234561234"
},
new Restaurant {
name = "Qdoba"
},
new Restaurant {
name = "Wingstop"
}
}.AsQueryable();
var mockSet = new Mock <DbSet <RestaurantReviewsData.Restaurant> >();
mockSet.As <IQueryable <Restaurant> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Restaurant> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Restaurant> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Restaurant> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <RestaurantReviewsEntities>();
mockContext.Setup(c => c.Restaurants).Returns(mockSet.Object);
var service = new RestaurantRepository(mockContext.Object);
var rest = service.GetDetails("Subway");
//mockSet.Verify(m => m.Add(It.IsAny<Restaurant>()), Times.Once());
//mockContext.Verify(m => m.SaveChanges(), Times.Once());
Assert.AreEqual("Subway", rest.Name);
Assert.AreEqual("123 Revature Street", rest.Address);
Assert.AreEqual("1234561234", rest.Phone);
}
public async void GetRestaurantById(Guid restaurantId)
{
try
{
using (var dbCon = PostgresConn.GetConn())
{
var restaurantAsDBEntity = new RestaurantRepository().GetById(dbCon, restaurantId);
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var json = JsonConvert.SerializeObject(restaurantAsDBEntity, serializerSettings);
if (!Response.HasStarted)
{
Response.StatusCode = 200;
}
if (json.Contains("[null]"))
{
await Response.Body.WriteAsync(new byte[] { });
}
else
{
await Response.Body.WriteAsync(Encoding.UTF8.GetBytes(json));
}
var restaurant = restaurantAsDBEntity as Restaurant;
var filePath = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..\\..\\..\\")) + $"Images\\MAP{restaurant.Id}.jpg";
await Response.SendFileAsync(filePath);
}
}
catch (Exception e)
{
//if (!Response.HasStarted) Response.StatusCode = 400; //кидало ошибку, поэтому закомментил
//await Response.Body.WriteAsync(Encoding.UTF8.GetBytes(e.Message));
}
}
public async void GetAllRestaurants()
{
try
{
using (var dbCon = PostgresConn.GetConn())
{
var restaurants = new RestaurantRepository().GetAllRestaurants(dbCon);
var serializerSettings = new JsonSerializerSettings();
serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var json = JsonConvert.SerializeObject(restaurants, serializerSettings);
if (!Response.HasStarted)
{
Response.StatusCode = 200;
}
if (json.Contains("[null]"))
{
await Response.Body.WriteAsync(new byte[] { });
}
else
{
await Response.Body.WriteAsync(Encoding.UTF8.GetBytes(json));
}
}
}
catch (Exception e)
{
if (!Response.HasStarted)
{
Response.StatusCode = 400;
}
await Response.Body.WriteAsync(Encoding.UTF8.GetBytes(e.Message));
}
}
public void InitializeTests()
{
AppDataContext _context = new AppDataContext();
IRestaurantRepository _repository = new RestaurantRepository(_context);
_service = new RestaurantService(_repository);
}
public void Can_Get_RestaurantDTO()
{
var context = TestingSetup.GetContext();
IRestaurantRepository repo = new RestaurantRepository(context);
var restaurant = new Restaurant()
{
ExternalId = "31e045af-cc46-4e28-a783-71d456d86400",
Name = "New Restaurant"
};
context.Restaurants.Add(restaurant);
context.SaveChanges();
var svc = new RestaurantService(repo);
Task task = svc.GetRestaurantByIdAsync("31e045af-cc46-4e28-a783-71d456d86400")
.ContinueWith(innerTask =>
{
var result = innerTask.Result;
Assert.IsType <RestaurantDTO>(result);
Assert.Equal("America/New York", result.TimeZone);
Assert.Equal("New Restaurant", result.Name);
});
}
public void GetRestaurantsAsync_Test()
{
var restaurantDataManager = new Mock <IRestaurantDataManager>();
var expected = new Restaurant[] {
new Restaurant {
Name = "seafood and such",
Address = "123 bay street",
City = "seaside",
Id = 4556
},
new Restaurant
{
Name = "donuts r better",
Address = "0 icing circle",
City = "seaside",
Id = 4557
}
}.ToList();
var expectedPage = 1;
var expectedPageSize = 20;
var expectedDbFilter = new DbFilter <Restaurant> {
Field = "City", Operator = OperatorEnum.Like, Value = "sea%"
};
restaurantDataManager.Setup(x => x.GetRestaurantsAsync(expectedPage, expectedPageSize, expectedDbFilter)).Returns(Task.FromResult <IEnumerable <Restaurant> >(expected));
var restaurantRepo = new RestaurantRepository(restaurantDataManager.Object);
var actual = restaurantRepo.GetRestaurantsAsync(expectedPage, expectedPageSize, expectedDbFilter).Result;
restaurantDataManager.VerifyAll();
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual);
}
public void GetRestaurantByIdShouldReturnResult()
{
// arrange
var options = new DbContextOptionsBuilder <RestaurantReviewsDbContext>()
.UseInMemoryDatabase("GetRestaurantByIdShouldReturnResult")
.Options;
using var arrangeContext = new RestaurantReviewsDbContext(options);
var id = 5;
arrangeContext.Restaurant.Add(new Restaurant {
Id = id, Name = "Abc"
});
arrangeContext.SaveChanges();
using var actContext = new RestaurantReviewsDbContext(options);
var repo = new RestaurantRepository(actContext, new NullLogger <RestaurantRepository>());
// act
var result = repo.GetRestaurantById(id);
// assert
// if I needed to check the actual database here, i would use a separate assertContext as well.
Assert.NotNull(result);
}
public RestaurantController()
{
restauntRepository = new RestaurantRepository();
cityRepository = new CityRepository();
countryRepository = new CountryRepository();
ref_Types_Of_KitchenRepository = new Ref_Types_of_KitchenRepository();
}
public static IRestaurantApplication CreateRestaurantApplication()
{
var(connection, mapper) = LoadDependencies();
var repository = new RestaurantRepository(connection);
return(new RestaurantApplication(connection, mapper, repository, new RestaurantValidationBeforePersist(repository)));
}
public FormRestaurant(RestaurantRepository repository)
{
InitializeComponent();
this.repository = repository;
RefreshControls();
}
public EditRestaurantForm(string selectedRestaurantName)
{
InitializeComponent();
_restaurantRepository = new RestaurantRepository();
_restaurantToEditName = selectedRestaurantName;
EditRestaurantTextBox.Text = selectedRestaurantName;
KitchenModelComboBox.SelectedIndex = 0;
}
public IRestaurant AddRestaurant(Restaurant restaurant)
{
var restaurantId = this.GetRestaurants().Max(r => r.Id) + 1;
restaurant.Id = restaurantId;
RestaurantRepository.AddRestaurant(restaurant);
return(GetRestaurant(restaurantId));
}
protected BaseService(AppDbContext dbContext, People logedInPerson)
{
this.LogedInPerson = logedInPerson;
this.RestaurantRepo = new RestaurantRepository(dbContext);
this.EmployersRepo = new EmployersRepository(dbContext);
this.EmployerRestaurantRepo = new EmployersRestaurantsRepository(dbContext);
}
public ActionResult Delete(RestaurantsDeleteViewModel model)
{
RestaurantRepository repository = new RestaurantRepository();
repository.Delete(model.ID);
return(RedirectToAction("Index"));
}
public ReviewsEditVM(int reviewID, ReviewRepository newReviewRepository,
RestaurantRepository newRestaurantRepository)
{
restaurantRepository = newRestaurantRepository;
reviewRepository = newReviewRepository;
MyReview = reviewRepository.GetById(reviewID);
MyRestaurants = restaurantRepository.GetAll();
}
public DataLayerService()
{
config = new LocalConfig();
pictureRepository = new PictureRepository(config);
foodRepository = new FoodRepository(config);
userRepository = new UserRepository(config);
restaurantRepository = new RestaurantRepository(config);
}
public async Task <Restaurant> AddNewRestaurant(Restaurant restaurant)
{
var entity = await RestaurantRepository.Add(restaurant);
await RestaurantRepository.Commit();
return(entity);
}
public RestaurantService()
{
restaurantRepository = new RestaurantRepository();
}
