public async Task <IActionResult> Update([FromBody] DietaryRestrictionViewModel 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 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 = DietaryRestrictionViewModel.Parse(getOperation.Result);
ViewData["Title"] = "DietaryRestriction";
var crumbs = GetCrumbs();
crumbs.Add(new BreadCrumb()
{
Action = "New", Controller = "DietaryRestrictions", Icon = "fa-search", Text = "Detail"
});
ViewData["BreadCrumbs"] = crumbs;
return(View(vm));
}
public ActionResult Update([FromBody] DietaryRestrictionViewModel dr)
{
var currentResult = _bo.Read(dr.Id);
if (!currentResult.Success)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
var current = currentResult.Result;
if (current == null)
{
return(NotFound());
}
if (current.Name == dr.Name)
{
return(StatusCode((int)HttpStatusCode.NotModified));
}
if (current.Name != dr.Name)
{
current.Name = dr.Name;
}
var updateResult = _bo.Update(current);
if (!updateResult.Success)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
return(Ok());
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id, Name")] DietaryRestrictionViewModel vm)
{
if (ModelState.IsValid)
{
var getOperation = await _bo.ReadAsync(id);
if (!getOperation.Success)
{
return(View("Error", getOperation.Exception.Message));
}
if (getOperation.Result == null)
{
return(NotFound());
}
var result = getOperation.Result;
result.Name = vm.Name;
var updateOperation = await _bo.UpdateAsync(result);
if (!updateOperation.Success)
{
return(View("Error", getOperation.Exception.Message));
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create()
{
var drListOperation = await _drbo.ListAsync();
if (!drListOperation.Success)
{
return(View("Error", new ErrorViewModel()
{
RequestId = "Error"
}));
}
var drList = new List <DietaryRestrictionViewModel>();
foreach (var dr in drListOperation.Result)
{
if (!dr.IsDeleted)
{
var drvm = DietaryRestrictionViewModel.Parse(dr);
drList.Add(drvm);
}
ViewBag.DietaryRestrictions = drList.Select(dr => new SelectListItem()
{
Text = dr.Name, Value = dr.Id.ToString()
});
}
return(View());
}
public async Task <IActionResult> Edit(Guid id, DietaryRestrictionViewModel 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 ActionResult Create([FromBody] DietaryRestrictionViewModel vm)
{
var dr = vm.ToDietaryRestriction();
var res = _bo.Create(dr);
return(res.Success ? Ok() : InternalServerError());
}
public ActionResult Create([FromBody] DietaryRestrictionViewModel vm)
{
var dr = new DietaryRestriction(vm.Name);
var res = _bo.Create(dr);
var code = res.Success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError;
return(new ObjectResult(code));
}
public async Task <IActionResult> CreateAsync([FromBody] DietaryRestrictionViewModel vm)
{
var newItem = vm.ToModel();
var result = await _bo.CreateAsync(newItem);
if (!result.Success)
{
return(InternalServerError(result.Exception));
}
return(Created(Request.Path.Value, null));
}
private async Task <List <DietaryRestrictionViewModel> > GetDietaryRestrictionViewModels(List <Guid> ids)
{
var filterOperation = await _dro.FilterAsync(x => ids.Contains(x.Id));
var drList = new List <DietaryRestrictionViewModel>();
foreach (var item in filterOperation.Result)
{
drList.Add(DietaryRestrictionViewModel.Parse(item));
}
return(drList);
}
public ActionResult Create([FromBody] DietaryRestrictionViewModel vm)
{
var dr = vm.ToDietaryRestriction();
var res = _bo.Create(dr);
var statusCodeNum = res.Success ? (int)HttpStatusCode.OK : (int)HttpStatusCode.InternalServerError;
var statusCode = StatusCode(statusCodeNum);
return(statusCode);
//var dr = new DietaryRestriction(vm.Id, DateTime.Now, DateTime.Now, vm.IsDeleted, vm.Name);
//HttpStatusCode code = HttpStatusCode.BadRequest;
//var res = _bo.Create(dr);//, (res) => code = res.Success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError);
//return InternalServerError
//var code = res.Success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError;
//return new ObjectResult(code);
}
public ActionResult <List <DietaryRestrictionViewModel> > List()
{
var res = _bo.List();
if (!res.Success)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
var list = new List <DietaryRestrictionViewModel>();
foreach (var item in res.Result)
{
list.Add(DietaryRestrictionViewModel.Parse(item));
}
return(list);
}
public async Task <IActionResult> Index()
{
var listOperation = await _bo.ListUnDeletedAsync();
if (!listOperation.Success)
{
return(View("Error", listOperation.Exception.Message));
}
var lst = new List <DietaryRestrictionViewModel>();
foreach (var item in listOperation.Result)
{
lst.Add(DietaryRestrictionViewModel.Parse(item));
}
return(View(lst));
}
public async Task <IActionResult> Create([Bind("Name")] DietaryRestrictionViewModel vm)
{
if (ModelState.IsValid)
{
var dr = vm.ToDietaryRestriction();
var createOperation = await _bo.CreateAsync(dr);
if (!createOperation.Success)
{
return(View("Error", new ErrorViewModel()
{
RequestId = createOperation.Exception.Message
}));
}
return(RedirectToAction(nameof(Index)));
}
return(View(vm));
}
public async Task <IActionResult> ListAsync()
{
var listResult = await _bo.ListNonDeletedAsync();
if (!listResult.Success)
{
return(InternalServerError(listResult.Exception));
}
var list = listResult.Result;
var lst = new List <DietaryRestrictionViewModel>();
foreach (var item in list)
{
var vm = DietaryRestrictionViewModel.Parse(item);
lst.Add(vm);
}
return(Ok(lst));
}
public async Task <IActionResult> GetAsync(Guid id)
{
var getResult = await _bo.ReadAsync(id);
if (!getResult.Success)
{
return(InternalServerError(getResult.Exception));
}
var item = getResult.Result;
if (item == null)
{
return(NotFound());
}
var vm = DietaryRestrictionViewModel.Parse(item);
return(Ok(vm));
}
public ActionResult <List <DietaryRestrictionViewModel> > ListUnDeleted()
{
var res = _bo.ListUnDeleted();
if (!res.Success)
{
return(InternalServerError());
}
var list = new List <DietaryRestrictionViewModel>();
foreach (var item in res.Result)
{
list.Add(DietaryRestrictionViewModel.Parse(item));
}
return(list);
}
public async Task <IActionResult> Index()
{
var listOperation = await _bo.ListAsync();
if (!listOperation.Success)
{
return(View("Error", new ErrorViewModel()
{
RequestId = listOperation.Exception.Message
}));
}
var drListOperation = await _drbo.ListAsync();
if (!drListOperation.Success)
{
return(View("Error", new ErrorViewModel()
{
RequestId = drListOperation.Exception.Message
}));
}
var dishLst = new List <DishViewModel>();
foreach (var item in listOperation.Result)
{
if (!item.IsDeleted)
{
dishLst.Add(DishViewModel.Parse(item));
}
}
var drLst = new List <DietaryRestrictionViewModel>();
foreach (var item in drListOperation.Result)
{
if (!item.IsDeleted)
{
drLst.Add(DietaryRestrictionViewModel.Parse(item));
}
}
ViewBag.DietaryRestrictions = drLst;
return(View(dishLst));
}
public async Task <IActionResult> New(DietaryRestrictionViewModel vm)
{
if (ModelState.IsValid)
{
var model = vm.ToModel();
var createOperation = await _bo.CreateAsync(model);
if (!createOperation.Success)
{
TempData["Alert"] = AlertFactory.GenerateAlert(NotificationType.Danger, createOperation.Exception);
return(View(vm));
}
else
{
return(OperationSuccess("The record was successfuly created"));
}
}
return(View(vm));
}
public ActionResult <DietaryRestrictionViewModel> Get(Guid id)
{
var res = _bo.Read(id);
if (res.Success)
{
if (res.Result == null)
{
return(NotFound());
}
//if(res.Result.UpdatedAt != DateTime.Now) return StatusCode((int)HttpStatusCode.InternalServerError);
var drvm = DietaryRestrictionViewModel.Parse(res.Result);
return(drvm);
}
else
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public ActionResult <DietaryRestrictionViewModel> Get(Guid id)
{
var res = _bo.Read(id);
if (res.Success)
{
if (res.Result == null)
{
return(NotFound());
}
var vm = DietaryRestrictionViewModel.Parse(res.Result);
return(vm);
}
else
{
return(InternalServerError());
}
}
public async Task <IActionResult> Edit(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var getOperation = await _bo.ReadAsync((Guid)id);
if (!getOperation.Success)
{
return(View("Error", getOperation.Exception.Message));
}
if (getOperation.Result == null)
{
return(NotFound());
}
var vm = DietaryRestrictionViewModel.Parse(getOperation.Result);
return(View(vm));
}
public async Task <IActionResult> Index()
{
var listOperation = await _bo.ListNonDeletedAsync();
if (!listOperation.Success)
{
return(OperationErrorBackToIndex(listOperation.Exception));
}
var lst = new List <DietaryRestrictionViewModel>();
foreach (var item in listOperation.Result)
{
lst.Add(DietaryRestrictionViewModel.Parse(item));
}
ViewData["Title"] = "DietaryRestrictions";
ViewData["BreadCrumbs"] = GetCrumbs();
ViewData["DeleteHref"] = GetDeleteRef();
return(View(lst));
}
private async Task <DietaryRestrictionViewModel> GetDietaryRestrictionViewModel(Guid id)
{
var getOperation = await _dro.ReadAsync(id);
return(DietaryRestrictionViewModel.Parse(getOperation.Result));
}
public async Task <IActionResult> Index()
{
var menuOfTheDay = new MenuOfTheDayViewModel();
var menuListOperation = await _menubo.ListAsync();
if (!menuListOperation.Success)
{
return(View("Error"));
}
if (menuListOperation.Result.Count == 0)
{
return(View("Error"));
}
var servingListOperation = await _sbo.ListAsync();
if (!servingListOperation.Success)
{
return(View("Error"));
}
if (servingListOperation.Result.Count == 0)
{
return(View("Error"));
}
var dishListOperation = await _dbo.ListAsync();
if (!dishListOperation.Success)
{
return(View("Error"));
}
if (dishListOperation.Result.Count == 0)
{
return(View("Error"));
}
var dietaryRestrictionListOperation = await _drbo.ListAsync();
if (!dietaryRestrictionListOperation.Success)
{
return(View("Error"));
}
if (dietaryRestrictionListOperation.Result.Count == 0)
{
return(View("Error"));
}
var mealListOperation = await _mealbo.ListAsync();
if (!mealListOperation.Success)
{
return(View("Error"));
}
if (mealListOperation.Result.Count == 0)
{
return(View("Error"));
}
var courseListOperation = await _cbo.ListAsync();
if (!courseListOperation.Success)
{
return(View("Error"));
}
if (courseListOperation.Result.Count == 0)
{
return(View("Error"));
}
foreach (var serving in servingListOperation.Result)
{
var course = courseListOperation.Result.First(x => x.Id == serving.CourseId);
var dish = dishListOperation.Result.First(x => x.Id == serving.DishId);
var menu = menuListOperation.Result.First(x => x.Id == serving.MenuId);
var dr = dietaryRestrictionListOperation.Result.First(x => x.Id == dish.DietaryRestrictionId);
var meal = mealListOperation.Result.First(x => x.Id == menu.MealId);
if (meal.Menus == null)
{
meal.Menus = new List <Menu>();
}
meal.Menus.Add(menu);
menu.Meal = meal;
if (menu.Servings == null)
{
menu.Servings = new List <Serving>();
}
menu.Servings.Add(serving);
serving.Menu = menu;
if (dr.Dishes == null)
{
dr.Dishes = new List <Dish>();
}
dr.Dishes.Add(dish);
dish.DietaryRestriction = dr;
if (dish.Servings == null)
{
dish.Servings = new List <Serving>();
}
dish.Servings.Add(serving);
serving.Dish = dish;
if (course.Servings == null)
{
course.Servings = new List <Serving>();
}
course.Servings.Add(serving);
serving.Course = course;
}
List <ItemOnMenuOfTheDayViewModel> items = new List <ItemOnMenuOfTheDayViewModel>();
foreach (var dr in dietaryRestrictionListOperation.Result)
{
var drvm = DietaryRestrictionViewModel.Parse(dr);
foreach (var dish in dr.Dishes)
{
var dishvm = DishViewModel.Parse(dish);
items.Add(new ItemOnMenuOfTheDayViewModel()
{
DietaryRestriction = drvm, Dish = dishvm
});
}
}
return(View(menuOfTheDay));
}
