public ActionResult AddPortionFood([Bind(Include = "IdFood, Amount")] PortionFood portion)
{
int idDish = int.Parse(RouteData.Values["Id"].ToString());
if (ModelState.IsValid)
{
portion.IdDish = idDish;
ValidationResult result = PortionFoodService.Add(portion);
if (!result.IsSuccess)
{
var errorDetails = result.GetAllErrors();
throw new HttpException(404, "Model you add is incorrect. " + errorDetails);
}
}
List <int> usedInDishFoodIds = DishService.Get(idDish).PortionFood.
Where(p => !p.IsDeleted).Select(pf => pf.Food.Id).ToList();
ViewBag.IdFood = new SelectList(
FoodService.Get().Where(x => !usedInDishFoodIds.Contains(x.Id)),
"Id", "Name");
ViewBag.IdDish = idDish;
return(View());
}
public async void Dishes_RemoveByIdAsync_PositiveAndNegative_Test()
{
var options = new DbContextOptionsBuilder <DreamFoodDeliveryContext>()
.UseInMemoryDatabase(databaseName: "Dishes_RemoveByIdAsync_PositiveAndNegative_Test")
.Options;
using (var context = new DreamFoodDeliveryContext(options))
{
context.AddRange(_dishes);
await context.SaveChangesAsync();
}
using (var context = new DreamFoodDeliveryContext(options))
{
var dish = await context.Dishes.AsNoTracking().FirstOrDefaultAsync();
var service = new DishService(_mapper, context, _tagService);
var resultPositive = await service.RemoveByIdAsync(dish.Id.ToString());
var resultNegative = await service.RemoveByIdAsync(new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Message.Should().BeNull();
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Message.Should().Contain(ExceptionConstants.DISH_WAS_NOT_FOUND);
}
}
void initDishs()
{
DishTypeService typeService = new DishTypeService();
DishService dishService = new DishService();
List <DishType> typeList = typeService.GetList();
List <Dish> allDish = new List <Dish>();
foreach (DishType type in typeList)
{
List <Dish> dishList = dishService.GetListByTypeId(type.Id);
if (dishList != null)
{
allDish.AddRange(dishList);
}
DishAndTypeList.Add(new DishModel {
DishType = type, DishList = dishList
});
}
DishType defautType = new DishType()
{
Id = "0", Name = "所有"
};
DishAndTypeList.Insert(0, new DishModel()
{
DishType = defautType, DishList = allDish
});
}
public CartItemsController(ApplicationDbContext context, DishService dishService, IngredientService ingredientService, CartService cartService)
{
_context = context;
_dishService = dishService;
_ingredientService = ingredientService;
_cartService = cartService;
}
public async void Dishes_GetByIdAsync_PositiveAndNegative_Test()
{
var options = new DbContextOptionsBuilder <DreamFoodDeliveryContext>()
.UseInMemoryDatabase(databaseName: "Dishes_GetByIdAsync_PositiveAndNegative_Test")
.Options;
using (var context = new DreamFoodDeliveryContext(options))
{
context.AddRange(_dishes);
await context.SaveChangesAsync();
}
using (var context = new DreamFoodDeliveryContext(options))
{
var dish = await context.Dishes.AsNoTracking().FirstOrDefaultAsync();
var service = new DishService(_mapper, context, _tagService);
var resultPositive = await service.GetByIdAsync(dish.Id.ToString());
var resultNegative = await service.GetByIdAsync(new Guid().ToString());
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Name.Should().BeEquivalentTo(dish.Name);
resultPositive.Data.Composition.Should().BeEquivalentTo(dish.Composition);
resultPositive.Data.Description.Should().BeEquivalentTo(dish.Description);
resultPositive.Data.Weight.Should().BeEquivalentTo(dish.Weight);
resultNegative.IsSuccess.Should().BeFalse();
resultNegative.Data.Should().BeNull();
}
}
public ActionResult Create(DishForm model)
{
Dish toInsert = model.Map <Dish>();
if (ModelState.IsValid)
{
//gestion image
if (model.File != null)
{
string name = Guid.NewGuid().ToString() + model.File.FileName;
string path = Path.Combine(Server.MapPath("~/Content/Image"), name);
//placer image dans un dossier
model.File.SaveAs(path);
toInsert.Picture = name;
}
//Inserer en db
DishService ds = new DishService();
ds.Insert(toInsert);
ViewBag.SuccessMessage = "Dish inserted";
return(RedirectToAction("Dish", "Index", new { Area = "" }));
}
return(View(model));
}
public JsonResult GetDishes()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var dishes = DishService.GetUserDishes(userId);
return(Json(dishes, JsonRequestBehavior.AllowGet));
}
public DishController(IHostingEnvironment environment, DishService service, ApplicationDbContext context, ILogger <DishController> logger)
{
_hostingEnvironment = environment;
_service = service;
_context = context;
_logger = logger;
}
public async void Dihes_AddAsync_Positive_Test()
{
var options = new DbContextOptionsBuilder <DreamFoodDeliveryContext>()
.UseInMemoryDatabase(databaseName: "Dihes_AddAsync_Positive_Test")
.Options;
using (var context = new DreamFoodDeliveryContext(options))
{
var tagService = new TagService(_mapper, context);
var service = new DishService(_mapper, context, tagService);
TagToAdd[] tags = new TagToAdd[] {
new TagToAdd
{
TagName = "New"
}
};
DishToAdd dish = new DishToAdd()
{
Name = "Name",
Composition = "Composition",
Description = "Description",
Weight = "Weight",
TagNames = new HashSet <TagToAdd>(tags)
};
var resultPositive = await service.AddAsync(dish);
resultPositive.IsSuccess.Should().BeTrue();
resultPositive.Data.Name.Should().BeEquivalentTo(dish.Name);
resultPositive.Data.Composition.Should().BeEquivalentTo(dish.Composition);
resultPositive.Data.Description.Should().BeEquivalentTo(dish.Description);
resultPositive.Data.Weight.Should().BeEquivalentTo(dish.Weight);
}
}
/// <summary>
/// Post example
/// </summary>
/// <param name="startDateDecorator"></param>
public SynchronizationData Post(DateTimeDecorator startDateDecorator)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "Input data format is invalid.");
return(null);
}
DateTime startDate = startDateDecorator.DateTime;
var data = new SynchronizationData();
context = Request.GetOwinContext().Get <ApplicationDbContext>();
foodConsistencyTypeService = new FoodConsistencyTypeService(context);
data.FoodConsistencyTypes = foodConsistencyTypeService.Get(startDate).ToList();
foodCategoryService = new FoodCategoryService(context);
data.FoodCategories = foodCategoryService.Get(startDate).ToList();
dishCategoryService = new DishCategoryService(context);
data.DishCategories = dishCategoryService.Get(startDate).ToList();
foodService = new FoodService(context);
data.Food = foodService.Get(startDate).ToList();
dishService = new DishService(context);
data.Dishes = dishService.Get(startDate).ToList();
portionService = new PortionFoodService(context);
data.Portions = portionService.Get(startDate).ToList();
return(data);
}
static void Main(string[] args)
{
DishService ds = new DishService();
Console.WriteLine(ds.Get(2));
Console.ReadKey();
}
public DishController(ApplicationDbContext context, ILogger <DishController> logger, IngredientService ingredientService, DishService dishService)
{
_context = context;
_logger = logger;
_ingredientService = ingredientService;
_dishService = dishService;
}
public async Task Details_ReturnsDishDetail()
{
// Arrange
var dishId = 1;
var mockLogger = new Mock <ILogger <DishController> >();
var mockIngredientService = new IngredientService(_context);
var mockDishService = new DishService(_context);
var controller = new DishController(_context, mockLogger.Object, mockIngredientService, mockDishService);
// Act
var result = await controller.Details(dishId);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.Null(viewResult.ViewName);
Assert.NotNull(viewResult.ViewData);
var viewModel = Assert.IsType <Dish>(viewResult.ViewData.Model);
Assert.NotNull(viewModel.Category);
var category = _context.Categories.SingleOrDefault(g => g.CategoryId == viewModel.CategoryId);
Assert.NotNull(category);
}
// GET: Dish
public ActionResult Index()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var model = DishService.GetUserDishes(userId);
return(View(model));
}
public ActionResult Details(int id)
{
DishService dishService = new DishService();
Dish dish = dishService.Get(id);
DishDetailsModel model = dish.Map <DishDetailsModel>();
return(View(model));
}
public void Setup()
{
var mongoDBContext = new MongoDBContext("mongodb://127.0.0.1:27017", "DigitalMenu");
var dishRepository = new DishRepository(mongoDBContext);
var workTimeSheetRpository = new WorkTimeSheetRepository(mongoDBContext);
_dishService = new DishService(dishRepository, workTimeSheetRpository);
}
public void FilterDishes()
{
var res = DishService.GetDishListFromFilter(false, 0, 0, "Garlic Paradise", new List <long>(), -1).Result;
Assert.NotNull(res);
Assert.True(res.Count > 0);
Assert.Equal(1, res.FirstOrDefault().dish.id);
}
public async Task <ActionResult> Post([FromBody] SaveDishResource resource)
{
var dish = Mapper.Map <SaveDishResource, Dish>(resource);
Dish addedDish = await DishService.AddDishAsync(dish);
return(CreatedAtRoute("GetDish", new { id = addedDish.Id }, addedDish));
}
public ActionResult DeleteDish(int id)
{
DishService.Delete(id);
TempData["SaveResult"] = "Your dish was deleted";
return(RedirectToAction("Index"));
}
public DishWindow(Dish dish)
{
contents = DishService.GetContents(dish.Id);
InitializeComponent();
DataGridDishes.ItemsSource = contents;
TextBlockPrice.Content = dish.Price + " PLN";
DishNameTextBox.Text = dish.Name;
}
public async Task FilterDishesAsync()
{
var res = await DishService.GetDishListFromFilter(false, 0, 0, "", new List <long>(), -1);
Assert.NotNull(res);
Assert.True(res.Count > 0);
Assert.Equal(1, res.FirstOrDefault().dish.id);
}
// GET: Dish
public ActionResult Index()
{
DishService dishService = new DishService();
IEnumerable <Dish> collection = dishService.GetAll();
IEnumerable <DishDetailsModel> model = collection.Select(item => item.Map <DishDetailsModel>());
return(View(model));
}
public ActionResult RemoveDish(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DishService.Remove((int)id);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Get(string id)
{
Dish dish = await DishService.GetDishByIdAsync(id);
if (dish == null)
{
return(NotFound());
}
return(Ok(dish));
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Dish dishToDel = DishService.Get((int)id);
return(View(dishToDel));
}
private void Select_Click(object sender, RoutedEventArgs e)
{
List <Dish> a = new DishService().GetList();
List <DishType> b = new DishTypeService().GetList();
List <Curorder> c = new CurorderService().GetList();
List <CurorderDetail> d = new CurorderDetailService().GetByCurorderId(c[0].CurorderId);
List <Hisorder> g = new HisorderService().GetList();
List <HisorderDetail> f = new HisorderDetailService().GetListByHisorderId(g[0].HisorderId);
MessageBox.Show("OK");
}
public DishAppService(IRepository <Dish, int> repository,
DishService dishService,
IRepository <Dish_FoodIngredient> dish_FoodIngredientRepository,
IObjectMapper objectMapper,
IRepository <RestaurantSetting> restaurantSettingsRepository) : base(repository)
{
_dishService = dishService;
_dish_FoodIngredientRepository = dish_FoodIngredientRepository;
_objectMapper = objectMapper;
_restaurantSettingsRepository = restaurantSettingsRepository;
}
public ActionResult Edit(int id)
{
var userId = Guid.Parse(User.Identity.GetUserId());
var model = MealService.GetEditById(id);
var dishes = DishService.GetUserDishSelectList(userId);
var tags = TagService.GetUserTagSelectList(userId);
model.DishData = dishes.ToList();
model.TagData = tags.ToList();
return(View(model));
}
//GET
public ActionResult Create()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var dishes = DishService.GetUserDishSelectList(userId);
var tags = TagService.GetUserTagSelectList(userId);
MealViewCreateModel model = new MealViewCreateModel();
model.DishData = dishes.ToList();
model.TagData = tags.ToList();
return(View(model));
}
public ActionResult Edit(int id)
{
var userId = Guid.Parse(User.Identity.GetUserId());
var model = DishService.GetEditById(id);
var ingredients = IngredientService.GetUserIngredientSelectList(userId);
var tags = TagService.GetUserTagSelectList(userId);
model.IngredientData = ingredients.ToList();
model.TagData = tags.ToList();
return(View(model));
}
public void LoadTreeNodeChildren(TreeNode selected)
{
if( null==selected){
return;
}
selectedLast = selected;
if (selected.Parent != null)
{
_DishTypeIdLast = selected.Id;
}
DishService service = new DishService();
var dishesMenus = service.LoadSubTypeById(selected.Id);
selected.Children.Clear();
foreach (var menu in dishesMenus)
{
var child = selected.createChild(menu.DishTypeId, menu.Name);
selected.Children.Add(child);
}
//SelectedTreeNodeFalse(Root);
//selected._Selected = true;
}
