public async Task <ActionResult> Edit(int id, RestaurantViewModel model)
{
try
{
if (Session["roleId"] == null)
{
return(RedirectToAction("Index", "Home"));
}
if (Session["roleId"].ToString() != "1")
{
return(RedirectToAction("Index", "Home"));
}
var res = model.Restaurant;
res.Id = id;
res.Category = await _proxy.GetRestaurantCategoryAsync(model.SelectedCategoryId);
await _proxy.UpdateRestaurantAsync(res);
return(RedirectToAction("Index"));
}
catch
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
}
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(RecordNotFound());
}
var getOperation = await _bo.ReadAsync((Guid)id);
if (!getOperation.Success)
{
return(OperationErrorBackToIndex(getOperation.Exception));
}
if (getOperation.Result == null)
{
return(RecordNotFound());
}
var vm = RestaurantViewModel.Parse(getOperation.Result);
ViewData["Title"] = "Restaurant";
var crumbs = GetCrumbs();
crumbs.Add(new BreadCrumb()
{
Action = "New", Controller = "Restaurants", Icon = "fa-search", Text = "Detail"
});
ViewData["BreadCrumbs"] = crumbs;
return(View(vm));
}
public ActionResult RestaurantEdit(int id)
{
using (var lunchContext = new LunchContext())
{
ViewBag.Cuisines = lunchContext.Cuisines.Select(c => new SelectListItem
{
Value = c.CuisineId.ToString(),
Text = c.Name
}).ToList();
var restaurant = lunchContext.Restaurants.SingleOrDefault(p => p.RestaurantId == id);
if (restaurant != null)
{
var restaurantViewModel = new RestaurantViewModel
{
RestaurantId = restaurant.RestaurantId,
Name = restaurant.Name,
Cuisine = new CuisineViewModel
{
CuisineId = restaurant.CuisineId,
Name = restaurant.Cuisine.Name
}
};
return(View("AddEditRestaurant", restaurantViewModel));
}
}
return(new HttpNotFoundResult());
}
public ActionResult AddRestaurant(RestaurantViewModel model)
{
try
{
RestaurantModel addRestaurant = new RestaurantModel
{
name = model.name,
priceRange = model.priceRange
};
if (model.menuImage.ContentLength > 0)
{
string _FileName = Path.GetFileName(model.menuImage.FileName);
string _path = Path.Combine(Server.MapPath("~/Content/Images/Restaurants"), _FileName);
model.menuImage.SaveAs(_path);
addRestaurant.menuImage = _path;
}
db.RestaurantModels.Add(addRestaurant);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Edit(Guid id, RestaurantViewModel vm)
{
if (ModelState.IsValid)
{
var getOperation = await _bo.ReadAsync(id);
if (!getOperation.Success)
{
return(OperationErrorBackToIndex(getOperation.Exception));
}
if (getOperation.Result == null)
{
return(RecordNotFound());
}
var result = getOperation.Result;
if (!vm.CompareToModel(result))
{
result = vm.ToModel(result);
var updateOperation = await _bo.UpdateAsync(result);
if (!updateOperation.Success)
{
TempData["Alert"] = AlertFactory.GenerateAlert(NotificationType.Danger, updateOperation.Exception);
return(View(vm));
}
else
{
return(OperationSuccess("The record was successfuly updated"));
}
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task EditRestaurantAsync(int id, RestaurantViewModel model)
{
try
{
var restaurant = this.restaurantRepository.All().FirstOrDefault(e => e.Id == id);
if (restaurant == null)
{
throw new ApplicationException(string.Format(ErrorMessages.RestaurantDoesNotExist, id));
}
restaurant.Name = model.Name;
restaurant.Address = model.Address;
this.restaurantRepository.Update(restaurant);
await this.restaurantRepository.SaveChangesAsync();
this.logger.LogInformation(string.Format(LogMessages.RestaurantUpdated, restaurant.Id));
}
catch (Exception e)
{
throw new ApplicationException(e.Message);
}
}
public void AddItem_Click(object sender, RoutedEventArgs e)
{
try
{
if (foodnametxt.Text == "" || Descriptiontxt.Text == "" || pricetxt.Text == "")
{
status.Foreground = Brushes.Red;
status.Content = "Усі поля обов'язкові.";
}
else
{
_rVmObj = new RestaurantViewModel();
FoodItems fooditem = new FoodItems();
fooditem.FoodName = foodnametxt.Text;
fooditem.Description = Descriptiontxt.Text;
fooditem.fPrice = Convert.ToInt32(pricetxt.Text.ToString());
_rVmObj.AddFoodItem(fooditem);
DataContext = new RestaurantViewModel();
status.Foreground = Brushes.Green;
status.Content = "Страва успішно додана.";
}
}
catch (Exception exp)
{
status.Foreground = Brushes.Red;
status.Content = "Введіть значення.";
}
}
public async Task <IActionResult> Edit(RestaurantViewModel restaurant)
{
try
{
if (restaurant is null)
{
ViewBag.Message = "Objeto user esta nulo.";
return(View());
}
if (!ValidationRestaurant(restaurant))
{
ViewBag.Message = "Missing fields to be filled";
return(View());
}
var result = await RestService.For <IAPIVotingSystemRestaurant>("https://localhost:44381/APISystemVoting/").UpdateRestaurantAsync(restaurant);
ViewBag.Message = result;
}
catch (Exception ex)
{
ViewBag.Message = ex.Message;
}
return(View());
}
public IActionResult Get(int id)
{
try
{
var restaurant = _repository.GetRestaurantById(id);
if (restaurant == null)
{
return(NotFound());
}
var vm = new RestaurantViewModel
{
Id = restaurant.Id,
Name = restaurant.Name,
Cuisine = restaurant.Cuisine
};
return(Ok(vm));
}
catch (Exception ex)
{
_logger.LogError($"Failed to get restaurants: {ex}");
return(BadRequest($"Failed to get restaurant with id: {id}"));
}
}
public void MapAction(object sender, EventArgs args)
{
Label label = (Label)sender;
RestaurantViewModel restaurant = ((TapGestureRecognizer)label.GestureRecognizers[0]).CommandParameter as RestaurantViewModel;
Navigation.PushAsync(new MapView(restaurant));
}
public ListRestaurantView()
{
InitializeComponent();
RestaurantViewModel restaurants = new RestaurantViewModel();
List.ItemsSource = restaurants.GetRestaurants();
}
private void AddItem_Click(object sender, RoutedEventArgs e)
{
try
{
if (foodnametxt.Text == "" || descriptiontxt.Text == "" || pricetxt.Text == "")
{
status.Foreground = Brushes.Red;
status.Content = "Alanlar boş bırakılamaz";
}
else
{
_rVmObj = new RestaurantViewModel();
FoodItems fooditem = new FoodItems();
fooditem.FoodName = foodnametxt.Text;
fooditem.Description = descriptiontxt.Text;
fooditem.fPrice = Convert.ToInt32(pricetxt.Text.ToString());
_rVmObj.AddFoodItem(fooditem);
DataContext = new RestaurantViewModel();
status.Foreground = Brushes.Green;
status.Content = "Ürün başarılı bir şekilde eklendi.";
}
}
catch (Exception exp)
{
status.Foreground = Brushes.Red;
status.Content = "Girilen değerleri kontrol ediniz.";
}
}
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 ActionResult Create([FromBody] RestaurantViewModel vm)
{
var r = vm.ToRestaurant();
var res = _bo.Create(r);
return(StatusCode(res.Success ? (int)HttpStatusCode.OK : (int)HttpStatusCode.InternalServerError));
}
public ActionResult AddRestaurant(RestaurantViewModel restaurantViewModel)
{
if (!ModelState.IsValid)
{
using (var lunchContext = new LunchContext())
{
ViewBag.Cuisines = lunchContext.Cuisines.Select(c => new SelectListItem
{
Value = c.CuisineId.ToString(),
Text = c.Name
}).ToList();
return(View("AddEditRestaurant", restaurantViewModel));
}
}
using (var lunchContext = new LunchContext())
{
var restaurant = new Restaurant
{
Name = restaurantViewModel.Name,
CuisineId = restaurantViewModel.Cuisine.CuisineId.Value
};
lunchContext.Restaurants.Add(restaurant);
lunchContext.SaveChanges();
}
return(RedirectToAction("Index"));
}
public IActionResult Post([FromBody] RestaurantViewModel model)
{
// add it to the db
try
{
if (ModelState.IsValid)
{
var newRestaurant = new Restaurant
{
Name = model.Name,
Cuisine = model.Cuisine
};
_repository.AddEntity(newRestaurant);
var vm = new RestaurantViewModel
{
Name = newRestaurant.Name,
Cuisine = newRestaurant.Cuisine
};
if (_repository.SaveAll())
{
return(Created($"/api/restaurants/{newRestaurant.Id}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new restaurant: {ex}");
}
return(BadRequest("Failed to save new restaurant"));
}
public MapView(RestaurantViewModel restaurant)
{
MapViewModel map = MapService.getMapRestaurant(RestaurantViewModel.GetRestaurant(restaurant));
var requesMap = new Map(
MapSpan.FromCenterAndRadius(
new Position(map.lat, map.lng), Distance.FromMiles(0.3)))
{
HeightRequest = 100,
WidthRequest = 960,
VerticalOptions = LayoutOptions.FillAndExpand
};
var stack = new StackLayout {
Spacing = 0
};
requesMap.Pins.Add(new Pin
{
Type = PinType.Generic,
Position = new Position(map.lat, map.lng),
Label = restaurant.NameRestaurant,
Address = restaurant.AddressRestaurant
});
stack.Children.Add(requesMap);
Content = stack;
}
public async Task <IActionResult> Update([FromBody] RestaurantViewModel vm)
{
var getResult = await _bo.ReadAsync(vm.Id);
if (!getResult.Success)
{
return(InternalServerError(getResult.Exception));
}
var item = getResult.Result;
if (item == null)
{
return(NotFound());
}
if (vm.CompareToModel(item))
{
return(NotModified());
}
item = vm.ToModel(item);
var updateResult = await _bo.UpdateAsync(item);
if (!updateResult.Success)
{
return(InternalServerError(updateResult.Exception));
}
return(Ok());
}
public AddFoodItem()
{
InitializeComponent();
this.WindowHeight = 450;
this.WindowWidth = 600;
DataContext = new RestaurantViewModel();
}
public ActionResult EditRestaurant(RestaurantViewModel restaurantViewModel)
{
if (!ModelState.IsValid)
{
using (var lunchContext = new LunchContext())
{
ViewBag.Cuisines = lunchContext.Cuisines.Select(c => new SelectListItem
{
Value = c.CuisineId.ToString(),
Text = c.Name
}).ToList();
return(View("AddEditRestaurant", restaurantViewModel));
}
}
using (var lunchContext = new LunchContext())
{
var restaurant = lunchContext.Restaurants.SingleOrDefault(p => p.RestaurantId == restaurantViewModel.RestaurantId);
if (restaurant != null)
{
restaurant.Name = restaurantViewModel.Name;
restaurant.CuisineId = restaurantViewModel.Cuisine.CuisineId.Value;
lunchContext.SaveChanges();
return(RedirectToAction("Index"));
}
}
return(new HttpNotFoundResult());
}
public async Task <IActionResult> Login(RestaurantViewModel model)
{
//validate user credentials against db
if (_context.Restaurant.Any(r => r.Email.Equals(model.Email)))
{
Restaurant currentRestaurant = _context.Restaurant.FirstOrDefault(p => p.Email == model.Email);
string salt = currentRestaurant.Salt;
string computedHash = Crypto.computeHash(model.Password, salt);
if (computedHash.Equals(currentRestaurant.Password))
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, currentRestaurant.Id.ToString()),
new Claim(ClaimTypes.Name, "Restaurant"),
new Claim(ClaimTypes.Email, model.Email)
};
var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var principal = new ClaimsPrincipal(identity);
await HttpContext.SignInAsync(principal);
return(RedirectToAction(nameof(Index)));
}
else
{
model.InfoMessage = "Wrong Password";
}
}
else
{
model.InfoMessage = "Email does not exist";
}
return(View(model));
}
public async Task <IActionResult> Register(RestaurantViewModel model)
{
if (ModelState.IsValid)
{
if (_context.Restaurant.Any(r => r.Email.Equals(model.Email)))
{
model.InfoMessage = "Email " + model.Email + " already in use.";
}
else
{
Restaurant dbRestaurant = model;
string salt = Crypto.generateSalt();
string hasedPassword = Crypto.computeHash(model.Password, salt);
dbRestaurant.Salt = salt;
dbRestaurant.Password = hasedPassword;
_context.Add(dbRestaurant);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
return(View(model));
}
public async Task <ActionResult> Search(string postCode)
{
var watch = new Stopwatch();
Console.WriteLine("Begin Search");
watch.Start();
var restaurantViewModel = new RestaurantViewModel();
if (!string.IsNullOrEmpty(postCode))
{
try
{
var restaurantList = await _restaurantService.SearchRestaurants(postCode);
restaurantViewModel = _restaurantViewModelBuilder.Build(restaurantList);
}
catch (Exception ex)
{
//TODO: log exception
Console.WriteLine(ex.Message);
return(View("Error"));
}
}
watch.Stop();
// TODO Log watch.ElapsedMilliseconds
Console.WriteLine($"End Search Time Taken{ watch.ElapsedMilliseconds}");
return(View(restaurantViewModel));
}
public ActionResult Create([FromBody] RestaurantViewModel vm)
{
var rt = vm.ToRestaurant();
var res = _bo.Create(rt);
return(res.Success ? Ok() : InternalServerError());
}
public IActionResult RestaurantView()
{
ViewData["Context"] = _context;
var viewModel = new RestaurantViewModel(_context);
return(View(viewModel));
}
public async Task <IActionResult> Restaurant(int?id)
{
if (id == null)
{
return(NotFound());
}
var restaurant = _restaurantRepository.Restaurant.FirstOrDefault(m => m.RestaurantId == id);
if (restaurant == null)
{
return(NotFound());
}
var restaurantVM = new RestaurantViewModel
{
CarouselImage1 = restaurant.CarouselImage1,
CarouselImage2 = restaurant.CarouselImage2,
CarouselImage3 = restaurant.CarouselImage3,
RestaurantId = restaurant.RestaurantId,
RestaurantName = restaurant.RestaurantName,
Phone = restaurant.Phone,
Hours = restaurant.Hours,
Keywords = restaurant.Keywords,
Website = restaurant.Website,
};
return(View(restaurantVM));
}
public JsonRestaurant RestaurantTolist()
{
JsonRestaurant jsonRestaurant = new JsonRestaurant();
RestaurantViewModel RestaurantListobj = new RestaurantViewModel();
List <RestaurantViewModel> RestaurantlinkListobj = new List <RestaurantViewModel>();
try
{
var ListRestaurant = _place.PlaceRestaurantid();
foreach (var item in ListRestaurant)
{
RestaurantListobj.Name = item.Name;
RestaurantListobj.CategoryId = _category.FindById(item.CategoryId).Id;
RestaurantListobj.GalleryId = item.GalleryId;
RestaurantListobj.DetailId = _detail.FindById(item.DetailId).Id;
RestaurantListobj.LocationX = _address.FindById(item.AdressId).LocationX;
RestaurantListobj.LocationY = _address.FindById(item.AdressId).LocationY;
RestaurantListobj.LocationR = _address.FindById(item.AdressId).LocationR;
RestaurantListobj.PhoneNumber = item.PhoneNumber;
RestaurantlinkListobj.Add(RestaurantListobj);
}
jsonRestaurant.result = RestaurantlinkListobj;
return(jsonRestaurant);
}
catch (Exception ex)
{
string s = ex.Message;
return(jsonRestaurant);
}
}
// GET
public IActionResult EditProfile()
{
string restaurantId = HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value;
var restaurant = _context.Restaurant.FirstOrDefault(r => r.Id == Int32.Parse(restaurantId));
RestaurantViewModel restVm = restaurant;
return(View(restVm));
}
public async Task <IActionResult> CreateRestaurant(string email, [FromBody] RestaurantViewModel model)
{
UserData user = await _userGateway.FindByEmail(email);
Result <int> result = await _restaurantGateway.CreateRestaurant(model.Name, model.Adresse, model.PhotoLink, model.Telephone, user.UserId);
return(Ok(result));
}
public RestaurantViewModel Update(RestaurantViewModel restaurantViewModel)
{
var restaurant = Mapper.Map <Restaurant>(restaurantViewModel);
_restaurantService.Update(restaurant);
Commit();
return(restaurantViewModel);
}
