// GET api/restaurant/GetMySqlAddress1
public System.Web.Http.Results.JsonResult<Models.Restaurant> GetMySqlAddress1()
{
var restaurant = new Models.Restaurant();
var context = new EifelContext();
restaurant = context.Restaurants.Single<Restaurant>(r => r.ID == 1);
return this.Json<Models.Restaurant>(restaurant);
}
public async Task <IActionResult> UpdateRestaurant(int id,
[FromBody] Models.Restaurant restaurant)
{
if (restaurant == null)
{
return(BadRequest());
}
var restaurantEnt = await _restService.GetRestaurantAsync(id);
if (restaurantEnt == null)
{
return(NotFound(new { Error = $"A restaurant with the ID '{id}' could not be found." }));
}
TryValidateModel(restaurant);
// Add validation
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
_restMapper.MapRestaurantModelToEntity(restaurant, restaurantEnt);
_restService.UpdateRestaurant(restaurantEnt);
if (!await _restService.SaveChangesAsync())
{
throw new Exception($"Error updating restaurant '{restaurantEnt.Name}'.");
}
return(NoContent());
}
/// <summary>
/// 增加一条数据
/// </summary>
public int Add(Models.Restaurant model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("insert into Restaurant(");
strSql.Append("Name,Address,Photo_Path)");
strSql.Append(" values (");
strSql.Append("@Name,@Address,@Photo_Path)");
strSql.Append(";select @@IDENTITY");
SqlParameter[] parameters =
{
new SqlParameter("@Name", SqlDbType.NVarChar, 50),
new SqlParameter("@Address", SqlDbType.NVarChar, 100),
new SqlParameter("@Photo_Path", SqlDbType.NVarChar, 1000)
};
parameters[0].Value = model.Name;
parameters[1].Value = model.Address;
parameters[2].Value = model.Photo_Path;
object obj = DbHelperSQL.GetSingle(strSql.ToString(), parameters);
if (obj == null)
{
return(0);
}
else
{
return(Convert.ToInt32(obj));
}
}
/// <summary>
/// 更新一条数据
/// </summary>
public bool Update(Models.Restaurant model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("update Restaurant set ");
strSql.Append("Name=@Name,");
strSql.Append("Address=@Address,");
strSql.Append("Photo_Path=@Photo_Path");
strSql.Append(" where Id=@Id");
SqlParameter[] parameters =
{
new SqlParameter("@Name", SqlDbType.NVarChar, 50),
new SqlParameter("@Address", SqlDbType.NVarChar, 100),
new SqlParameter("@Photo_Path", SqlDbType.NVarChar, 1000),
new SqlParameter("@Id", SqlDbType.Int, 4)
};
parameters[0].Value = model.Name;
parameters[1].Value = model.Address;
parameters[2].Value = model.Photo_Path;
parameters[3].Value = model.Id;
int rows = DbHelperSQL.ExecuteSql(strSql.ToString(), parameters);
if (rows > 0)
{
return(true);
}
else
{
return(false);
}
}
public List <Models.Restaurant> DataTableToList(DataTable dt)
{
List <Models.Restaurant> modelList = new List <Models.Restaurant>();
int rowCount = dt.Rows.Count;
if (rowCount > 0)
{
Models.Restaurant model;
for (int i = 0; i < rowCount; i++)
{
model = new Models.Restaurant();
if (dt.Rows[i]["Id"] != null && dt.Rows[i]["Id"].ToString() != "")
{
model.Id = int.Parse(dt.Rows[i]["Id"].ToString());
}
if (dt.Rows[i]["Name"] != null && dt.Rows[i]["Name"].ToString() != "")
{
model.Name = dt.Rows[i]["Name"].ToString();
}
if (dt.Rows[i]["Address"] != null && dt.Rows[i]["Address"].ToString() != "")
{
model.Address = dt.Rows[i]["Address"].ToString();
}
if (dt.Rows[i]["Photo_Path"] != null && dt.Rows[i]["Photo_Path"].ToString() != "")
{
model.Photo_Path = dt.Rows[i]["Photo_Path"].ToString();
}
modelList.Add(model);
}
}
return(modelList);
}
public ActionResult Edit(int id, FormCollection collection)
{
try
{
if (ModelState.IsValid)
{
Models.Restaurant temp = new Models.Restaurant
{
Id = id,
Name = collection["Name"],
Address = collection["Address"],
City = collection["City"],
State = collection["State"],
PhoneNumber = collection["PhoneNumber"],
};
da.UpdateRestaurant(temp);
return(RedirectToAction("Index"));
}
return(View());
}
catch
{
return(View());
}
}
public ActionResult Create(FormCollection collection)
{
try
{
if (ModelState.IsValid)
{
Models.Restaurant temp = new Models.Restaurant
{
//Id = int.Parse(collection["Id"]),
Name = collection["Name"],
Address = collection["Address"],
City = collection["City"],
State = collection["State"],
PhoneNumber = collection["PhoneNumber"]
};
da.InsertRestaurant(temp);
return(RedirectToAction("Index"));
}
return(View());
}
catch
{
return(View());
}
}
public void AddRestaurant(Models.Restaurant restaurant)
{
//if (_data.Any(r => r.Id == restaurant.Id))
//{
// throw new InvalidOperationException($"Restaurant located at {restaurant.Location} already exists.");
//}
_db.Add(Mapper.Map(restaurant));
}
public async Task UpdateElectedRestaurant(int poolId, int restaurantId)
{
Models.Pool pool = dbContext.Pools.Single(x => x.Id == poolId);
Models.Restaurant restaurant = dbContext.Restaurants.Single(x => x.Id == restaurantId);
pool.RestaurantElected = restaurant;
dbContext.Update(pool);
await dbContext.SaveChangesAsync();
}
public async Task <ActionResult> CreateRestaurantAsync([FromBody] Models.Restaurant restaurant)
{
restaurantContext.Restaurants.Add(restaurant);
await restaurantContext.SaveChangesAsync();
return(CreatedAtAction(nameof(GetRestaurantAsync), new { id = restaurant.Id }, restaurant));
}
public Entities.Restaurant RestaurantModelToEntity(Models.Restaurant restaurant)
{
return(new MapperConfiguration(cfg => cfg.CreateMap <Models.Restaurant,
Entities.Restaurant>()
.ForMember(dest => dest.OrdUser, opt => opt.Ignore())
.ForMember(dest => dest.ServiceArea, opt => opt.Ignore()))
.CreateMapper()
.Map <Entities.Restaurant>(restaurant));
}
public void MapRestaurantModelToEntity(Models.Restaurant restaurantMod,
Entities.Restaurant restaurantEnt)
{
var mapper = new MapperConfiguration(configure =>
configure.CreateMap <Models.Restaurant, Entities.Restaurant>())
.CreateMapper();
mapper.Map(restaurantMod, restaurantEnt);
}
public IActionResult OnGet(int id)
{
Restaurant = _restaurantData.Get(id);
if (Restaurant == null)
{
return(RedirectToAction("Index", "Home"));
}
return(Page());
}
// GET: Restaurant/Delete/5
public ActionResult Delete(int id)
{
Restaurant libRest = Repo.GetRestaurantById(id);
var webRest = new Models.Restaurant
{
Id = libRest.Id,
Location = libRest.Location
};
return(View(webRest));
}
public async Task <int> Add(string name)
{
Models.Restaurant restaurant = new Models.Restaurant()
{
Name = name
};
dbContext.Restaurants.Add(restaurant);
await dbContext.SaveChangesAsync();
return(restaurant.Id);
}
// GET: Restaurant/Details/5
public ActionResult Details(int id)
{
var restaurant = db.GetRestaurantByRestaurantId(id);
c = new Models.Restaurant();
c.RestaurantId = restaurant.RestaurantId;
c.RestaurantName = restaurant.RestaurantName;
c.AddressId = restaurant.AddressId;
HttpContext.Session.SetInt32("RestaurantId", restaurant.RestaurantId);
restaurantList.Add(c);
return(View(c));
}
//UPDATE
public async Task <int> UpdateRestaurant(Models.Restaurant restaurant)
{
try
{
_context.Entry(restaurant).State = EntityState.Modified;
return(await _context.SaveChangesAsync());
}
catch (Exception)
{
throw;
}
}
public IActionResult Post([FromBody] Models.Restaurant restaurant)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
restaurant.AwesomenessLevel = 0;
var restaurantId = _restaurantInteractor.CreateRestaurant(Models.Restaurant.MapToEntity(restaurant));
restaurant.Id = restaurantId;
return(CreatedAtRoute("GetRestaurant", new { id = restaurantId }, restaurant));
}
public async Task <Contracts.RestaurantType> AddRestaurantAsync(string name)
{
var newRestaurant = new Models.Restaurant(name);
_dbContext.Set <Models.Restaurant>().Add(newRestaurant);
await _dbContext.SaveChangesAsync();
return(new Contracts.RestaurantType
{
Id = newRestaurant.Id,
Name = name
});
}
public async Task Add(User user, Pool pool, Restaurant restaurant)
{
Models.User userModel = dbContext.Users.Single(x => x.Id == user.Id);
Models.Pool poolModel = dbContext.Pools.Single(x => x.Id == pool.Id);
Models.Restaurant restaurantModel = dbContext.Restaurants.Single(x => x.Id == restaurant.Id);
dbContext.Votes.Add(new Models.Vote()
{
User = userModel,
Pool = poolModel,
Restaurant = restaurantModel
});
await dbContext.SaveChangesAsync();
}
/// <summary>
/// Add a review, and optionally associate it with a restaurant.
/// </summary>
/// <param name="review">The review</param>
/// <param name="restaurant">The restaurant (or null if none)</param>
public void AddReview(Models.Review review, Models.Restaurant restaurant)
{
if (restaurant != null)
{
// get the db's version of that restaurant
// (can't use Find with Include)
var contextRestaurant = _db.Restaurant.Include(r => r.Review).First(r => r.Id == restaurant.Id);
restaurant.Reviews.Add(review);
contextRestaurant.Review.Add(Mapper.Map(review));
}
else
{
_db.Add(Mapper.Map(review));
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Restaurant = await _context.Restaurant.FirstOrDefaultAsync(m => m.Id == id);
if (Restaurant == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> AddRestaurant([FromBody] Models.Restaurant restaurant)
{
if (restaurant == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
// Check if another restaurant exists with specified name.
if (await _restService.RestaurantNameExistsAsync(restaurant.Name))
{
return(Conflict(new
{
Error = $"A restaurant with the name '{restaurant.Name}' already exists."
}));
}
// Add default restaurant cover image if not is set
if (restaurant.RestaurantCoverImagePath == null ||
restaurant.RestaurantCoverImagePath == string.Empty)
{
restaurant.RestaurantCoverImagePath = "Media/Shared/Images/fast_food_meal.jpg";
}
// Map restaurant model to entity.
var restaurantEntity = _restMapper.RestaurantModelToEntity(restaurant);
restaurantEntity.IsActive = false;
restaurantEntity.IsSuspended = false;
_restService.AddRestaurant(restaurantEntity);
if (!await _restService.SaveChangesAsync())
{
throw new Exception($"Could not save restaurant '{restaurant.Name}'.");
}
// Map newly saved restaurant back to model.
restaurant = _restMapper.RestaurantEntityToModel(restaurantEntity);
return(CreatedAtRoute("GetRestaurants",
new { restaurantId = restaurant.Id },
restaurant));
}
public IActionResult Create(EditRestaurantViewModel model)
{
if (ModelState.IsValid)
{
var restaurant = new Models.Restaurant {
Name = model.Name, Cuisine = model.Cuisine
};
_restaurantAll.Add(restaurant);
// return View("Details", restaurant);
return(RedirectToAction("Details", new { id = restaurant.Id })); // TODO :fix redirection to details
}
return(View());
}
public IHttpActionResult PutRestaurant(int id, Models.Restaurant restaurant)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
restaurant.Id = id;
Restaurant restaurantDAL;
try
{
restaurantDAL = db.Restaurants.Find(id);
}
catch
{
return(InternalServerError());
}
if (restaurantDAL == null)
{
return(NotFound());
}
db.Entry(restaurantDAL).CurrentValues.SetValues(restaurant);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!RestaurantExists(id))
{
return(NotFound());
}
else
{
return(InternalServerError());
}
}
catch
{
return(InternalServerError());
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Create([Bind(Include = "Name,Food")] Models.Restaurant r)
{
try
{
if (ModelState.IsValid)
{
lib.AddRestaurant(ModelConverter.Convert(r));
return(RedirectToAction("Index"));
}
}
catch
{
return(View());
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Restaurant = await _context.Restaurant.FindAsync(id);
if (Restaurant != null)
{
_context.Restaurant.Remove(Restaurant);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public ActionResult Edit(Models.Restaurant r)
{
try
{
if (ModelState.IsValid)
{
lib.EditRestaurant(ModelConverter.Convert(r));
return(RedirectToAction("Index"));
}
}
catch
{
return(View());
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public void Persist(int RestaurantId, ApplicationDbContext context)
{
Models.Restaurant restaurant = new Models.Restaurant
{
Id = RestaurantId,
Name = this.Name,
Description = this.Description,
HoursOfOperation = this.HoursOfOperation,
Address = this.Address,
Region = this.Region
};
context.Update(restaurant);
List <CategoryRestaurant> categoryRestaurants = CreateManyToManyRelationships(restaurant.Id);
restaurant.CategoryRestaurants = categoryRestaurants;
context.SaveChanges();
}
public IActionResult Put(Guid id, [FromBody] Models.Restaurant restaurant)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
try
{
restaurant.Id = id;
_restaurantInteractor.UpdateRestaurant(Models.Restaurant.MapToEntity(restaurant));
return(new OkResult());
}
catch (EntityNotFoundException)
{
return(new NotFoundResult());
}
}
public Restaurant(Models.Restaurant restaurant)
{
if (restaurant == null)
{
return;
}
Id = restaurant.Id;
Name = restaurant.Name;
Phone = restaurant.Phone;
Zipcode = restaurant.Zipcode;
Street = restaurant.Street;
Number = restaurant.Number;
Complement = restaurant.Complement;
District = restaurant.District;
City = restaurant.City;
State = restaurant.State;
StockingLevel = restaurant.StockingLevel;
}
/// <summary>
/// Creates the mock unit work
/// </summary>
/// <param name="menuItems">Itens to be added to the restaurant menu</param>
/// <returns></returns>
private static MockUnitOfWork CreateMockUnitOfWork(ICollection<MenuItem> menuItems)
{
var unitOfWork = new MockUnitOfWork();
unitOfWork.InitializeRepository<Models.Restaurant>();
var restaurant = new Models.Restaurant
{
Menu = new Menu
{
MenuId = 1,
Dishes = menuItems
}
};
unitOfWork.GetRepository<Models.Restaurant>().Insert(restaurant);
return unitOfWork;
}
