public MenuItemDTO CreateMenuItem(MenuItemToCreateDTO menuItemToCreateDTO)
{
using (var db = new sakilaContext())
{
Menu menuToCreate = new Menu();
menuToCreate.Description = menuItemToCreateDTO.description;
menuToCreate.Menutype = menuItemToCreateDTO.menutype;
menuToCreate.Price = menuItemToCreateDTO.price;
menuToCreate.Title = menuItemToCreateDTO.title;
if (menuItemToCreateDTO.imageid != null)
{
menuToCreate.Imageid = (long)menuItemToCreateDTO.imageid;
}
else
{
menuToCreate.Imageid = 1;
}
db.Menu.Add(menuToCreate);
db.SaveChanges();
MenuItemDTO menuItemDTOToReturn = new MenuItemDTO();
menuItemDTOToReturn.description = menuToCreate.Description;
menuItemDTOToReturn.imageUrl = db.Image.Where(i => i.Imageid == menuToCreate.Imageid).FirstOrDefault().ImageUrl;
menuItemDTOToReturn.menuId = menuToCreate.Menuid;
menuItemDTOToReturn.price = menuToCreate.Price;
menuItemDTOToReturn.title = menuToCreate.Title;
return(menuItemDTOToReturn);
}
}
public MenuItemDTO AddMenuItem(Guid id, MenuItemDTO dto)
{
if (id == Guid.Empty)
{
throw new ArgumentNullException("父菜单不能为空");
}
if (string.IsNullOrEmpty(dto.Name))
{
throw new ArgumentNullException("菜单名字不能为空");
}
if (string.IsNullOrEmpty(dto.URL))
{
throw new ArgumentNullException("菜单地址不能为空");
}
if (dto.OrderIndex <= 0)
{
throw new ArgumentNullException("菜单排序必须大于0");
}
Menu menu = menuRepository.GetByKey(id);
if (menu == null || menu.ID == Guid.Empty)
{
throw new ArgumentNullException("父菜单不存在");
}
MenuItem menuItem = Mapper.Map <MenuItemDTO, MenuItem>(dto);
menu.AddMenuItem(menuItem);
menuRepository.Update(menu);
RepositoryContext.Commit();
return(Mapper.Map <MenuItem, MenuItemDTO>(menuItem));
}
public async Task AddMenuItem(MenuItemDTO item)
{
var menuItem = new MenuItem()
{
Name = item.Name,
Price = item.Price
};
_unitOfWork.MenuItems.AddAsync(menuItem);
}
public void AddMenuItemTest()
{
MenuDTO menu = menuService.AddMenu(menu2);
Assert.IsTrue(menu.ID != Guid.Empty);
MenuItemDTO item = menuService.AddMenuItem(menu.ID, menuItem1);
Assert.IsTrue(item.ID != Guid.Empty);
}
public ServiceResponse <MenuItem> AddMenuItem(MenuItemDTO newMenuItem)
{
try
{
if (newMenuItem.Products.Count != newMenuItem.Products.Distinct().Count())
{
return(new ServiceResponse <MenuItem> {
Success = false, Message = $"There can only be one of each product"
});
}
var allProducts = _productRepository.GetAll();
if (allProducts == null)
{
return(new ServiceResponse <MenuItem> {
Success = false, Message = $"Cannot add because products file is corrupted"
});
}
foreach (var productId in newMenuItem.Products)
{
var found = allProducts.FirstOrDefault(product => product.Id == productId);
if (found == null)
{
return(new ServiceResponse <MenuItem> {
Success = false, Message = $"Product with id: {productId} does not exist"
});
}
}
var result = _menuRepository.Create(_mapper.Map <MenuItem>(newMenuItem));
if (result != null)
{
return new ServiceResponse <MenuItem> {
Message = $"Successfully added new menu Item with Id: {result.Id}", Data = result
}
}
;
return(new ServiceResponse <MenuItem> {
Success = false
});
}
catch (Exception e)
{
return(new ServiceResponse <MenuItem> {
Success = false, Message = $"Error adding menu item. Error message: {e.Message + " " + e.InnerException?.Message ?? ""}"
});
}
}
public IActionResult Update([FromBody] MenuItemDTO item)
{
try
{
_bizLogic.MenuItemCommand.Update(item);
_bizLogic.SaveChanges();
return(Ok());
}
catch (Exception ex)
{
return(NotFound(ex.Message));
}
}
public async Task <IActionResult> NewMenuItem([FromBody] MenuItemDTO item)
{
try
{
await _bizLogic.MenuItemCommand.AddMenuItem(item);
_bizLogic.SaveChanges();
return(Ok());
}
catch (Exception)
{
return(NotFound("Failed to add new item"));
}
}
public MenuItem FromDTO(MenuItemDTO dto)
{
return(new MenuItem
{
Id = dto.Id,
Name = dto.Name,
Controller = dto.Controller,
Action = dto.Action,
MenuLevel = dto.MenuLevel,
Parent = dto.Parent,
SortOrder = dto.SortOrder,
IsLink = dto.IsLink,
AccessGroup = dto.AccessGroup
});
}
public async Task <IActionResult> AddMenuItem([FromBody] MenuItemDTO newMenuItemDto)
{
//mapping DTO to Model
var newMenu = new RestaurantsMenu
{
Description = newMenuItemDto.Description,
IdDishType = newMenuItemDto.IdDishType,
IdRestaurant = newMenuItemDto.IdRestaurant,
Name = newMenuItemDto.Name,
Price = newMenuItemDto.Price,
Promo = newMenuItemDto.Promo
};
await restaurantMenuService.AddMenuItem(newMenu);
return(Ok());
}
public void Update(MenuItemDTO item)
{
var existingItem = _unitOfWork.MenuItems.Get(item.Id);
if (existingItem == null)
{
throw new Exception(
string.Format(
"Could not find menu item with id: ${0}", item.Id
));
}
existingItem.Name = item.Name;
existingItem.Price = item.Price;
_unitOfWork.MenuItems.Update(existingItem);
}
public void UpdateOne(MenuItemDTO menuItem)
{
try
{
using (ISession session = NHibernateHelper.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(menuItem);
transaction.Commit();
}
//return StorageResult.Success;
}
catch (Exception)
{
//return StorageResult.Failed;
}
}
public bool Add(MenuItemDTO MenuItemDTO, int userID)
{
if (MenuItemDTO != null)
{
using (IEateryDbContext context = _unitOfWork.GetEateryDbContext())
{
MenuItem MenuItem = ObjectTypeConverter.Convert <MenuItemDTO, MenuItem>(MenuItemDTO);
MenuItem.CreatedBy = userID;
MenuItem.CreatedDate = DateTime.Now;
this._MenuItemRepository.Add(context, MenuItem);
_unitOfWork.Commit(context);
return(true);
}
}
return(false);
}
public async Task <MenuItemDTO> AddItem(string categoryId, [FromBody] MenuItemDTO item)
{
using (var db = new RestaurantDatabase()) {
var menuItem = new MenuItem()
{
ItemDescription = item.ItemDescription,
ItemName = item.ItemName,
ItemPrice = item.ItemPrice,
ItemID = Guid.NewGuid(),
SpecialInstructions = item.SpecialInstructions,
InStock = true,
};
db.MenuItems.Add(menuItem);
await db.SaveChangesAsync();
return(new MenuItemDTO(menuItem));
}
}
public async Task <IActionResult> UpdateMenuItem([FromBody] MenuItemDTO menuItemDto)
{
//mapping DTO to Model
var updatedMenu = new RestaurantsMenu
{
Id = menuItemDto.Id,
Description = menuItemDto.Description,
IdDishType = menuItemDto.IdDishType,
IdRestaurant = menuItemDto.IdRestaurant,
Name = menuItemDto.Name,
Price = menuItemDto.Price,
Promo = menuItemDto.Promo
};
await restaurantMenuService.UpdateMenuItem(updatedMenu);
return(Ok());
}
public async Task <List <MenuItemDTO> > GetAll()
{
var items = await _unitOfWork.MenuItems.GetAllAsync();
var menuItemDTOs = new List <MenuItemDTO>();
foreach (var item in items.ToList())
{
var menuItemDTO = new MenuItemDTO()
{
Id = item.Id,
Name = item.Name,
Price = item.Price
};
menuItemDTOs.Add(menuItemDTO);
}
return(menuItemDTOs);
}
public MenuItemDTO Update(MenuItemDTO menuItemDTO, int?userID)
{
using (IEateryDbContext context = _unitOfWork.GetEateryDbContext())
{
MenuItem menuItem = this._MenuItemRepository.GetById(context, menuItemDTO.ID);
if (menuItem != null)
{
menuItem.IsPublished = menuItemDTO.IsPublished;
menuItem.UpdatedDate = DateTime.Now;
menuItem.UpdatedBy = userID;
menuItem = this._MenuItemRepository.Update(context, menuItem);
_unitOfWork.Commit(context);
if (menuItem != null)
{
return(ObjectTypeConverter.Convert <MenuItem, MenuItemDTO>(menuItem));
}
}
}
return(default(MenuItemDTO));
}
public void MyTestInitialize()
{
menuService = ServiceLocator.Instance.GetService <IMenuService>();
menu1 = new MenuDTO
{
Name = "用户管理",
Category = "AdminMenu",
OrderIndex = 10
};
menuItem1 = new MenuItemDTO
{
Name = "管理1",
URL = "#",
OrderIndex = 10
};
menuItem2 = new MenuItemDTO
{
Name = "管理2",
URL = "#",
OrderIndex = 20
};
menuItem2 = new MenuItemDTO
{
Name = "管理3",
URL = "#",
OrderIndex = 30
};
menu2 = new MenuDTO
{
Name = "公告管理",
Category = "AdminMenu",
OrderIndex = 20
};
menu3 = new MenuDTO
{
Name = "菜单管理",
Category = "AdminMenu",
OrderIndex = 30
};
}
public ActionResult Post([FromBody] MenuItemToCreateDTO menuItemToCreateDTO)
{
if (menuItemToCreateDTO == null)
{
return(BadRequest());
}
if (menuItemToCreateDTO.title == menuItemToCreateDTO.description)
{
ModelState.AddModelError("Title", "The title must be different than the description");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
MenuItemDTO createdMenuItemDTO = _menuRepository.CreateMenuItem(menuItemToCreateDTO);
return(CreatedAtRoute("GetMenu", new { menuId = createdMenuItemDTO.menuId }, createdMenuItemDTO));
}
public MenuItemDTO GetMenuItemById(int MenuItemID)
{
MenuItemDTO MenuItemDto = default(MenuItemDTO);
using (IEateryDbContext context = _unitOfWork.GetEateryDbContext())
{
try
{
MenuItem MenuItem = this._MenuItemRepository.GetAllQuery(context).FirstOrDefault(x => x.ID == MenuItemID);
if (MenuItem != null)
{
MenuItemDto = ObjectTypeConverter.Convert <MenuItem, MenuItemDTO>(MenuItem);
return(MenuItemDto);
}
}
catch (Exception ex)
{
//AppLogManager.LogError(ex);
throw ex;
}
}
return(MenuItemDto);
}
/// <summary>
/// Loads a menu item data to be delivered to front-end for display.
/// </summary>
private void LoadMenuItem(string strId)
{
int id;
if (int.TryParse(strId, out id))
{
var menuItem = _menuService.GetMenuItem(id);
if (menuItem != null)
{
var cart = _shoppingCartService.GetShoppingCart();
PageTitle = menuItem.Name;
MenuItem = new MenuItemDTO
{
Name = menuItem.Name,
Description = menuItem.Description,
Price = $"${menuItem.Price}",
ImageUrl = "/images/menu-items/" + menuItem.ImageUri,
AddCommand = new Command(() => OnAdded(menuItem.Id)),
ItemAdded = cart.GetOrderCount(menuItem) > 0 ? $"{cart.GetOrderCount(menuItem)} in cart" : null
};
}
}
}
public void InitDBTest()
{
InitAppRuntime();
ResetDB();
IUserService userService = ServiceLocator.Instance.GetService <IUserService>();
UserDTO user = new UserDTO()
{
UserName = "******",
Password = "******",
DateLastLogin = DateTime.Now,
DateRegistered = DateTime.Now,
Email = "mail1",
IsDisabled = false,
NickName = "qlf1"
};
user = userService.AddUser(user);
Assert.IsTrue(user.ID != Guid.Empty);
IMenuService menuService = ServiceLocator.Instance.GetService <IMenuService>();
MenuDTO userMenu = new MenuDTO
{
Name = "用户管理",
Category = "AdminMenu",
OrderIndex = 10
};
MenuDTO menu = new MenuDTO
{
Name = "菜单管理",
Category = "AdminMenu",
OrderIndex = 20
};
userMenu = menuService.AddMenu(userMenu);
menu = menuService.AddMenu(menu);
Assert.IsTrue(userMenu.ID != Guid.Empty);
MenuItemDTO menuItem1 = new MenuItemDTO
{
Name = "用户管理",
URL = "#",
OrderIndex = 10
};
menuItem1 = menuService.AddMenuItem(userMenu.ID, menuItem1);
MenuItemDTO menuItem2 = new MenuItemDTO
{
Name = "新增菜单",
URL = "#",
OrderIndex = 20
};
MenuItemDTO menuItem3 = new MenuItemDTO
{
Name = "菜单列表",
URL = "/angularTemplates/admin/menulist.html",
OrderIndex = 30
};
menuItem2 = menuService.AddMenuItem(menu.ID, menuItem2);
menuItem3 = menuService.AddMenuItem(menu.ID, menuItem3);
Assert.IsTrue(menuItem1.ID != Guid.Empty);
}
