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