private void LoadMenu()
{
ICommandManager commandManager = Container.Resolve <ICommandManager>();
IMenuService menuService = Container.Resolve <IMenuService>();
// Add file command
menuService.Add(new MenuItemViewModel("_File", 1));
menuService.Get("_File")
.Add(new MenuItemViewModel("E_xit", 101, null,
commandManager.GetCommand("ExitCommand"),
new KeyGesture(Key.F4, ModifierKeys.Alt, "Alt + F4")));
// Add refresh command
menuService.Add(new MenuItemViewModel("_Refersh", 2, null,
commandManager.GetCommand("RefreshCommand"),
new KeyGesture(Key.F5)));
// Tools Menu
menuService.Add(new MenuItemViewModel("_Tools", 3));
menuService.Get("_Tools").Add(new MenuItemViewModel("_Selection", 401, null,
commandManager.GetCommand("SelectionView"), new KeyGesture(Key.F9)));
menuService.Add(new MenuItemViewModel("T_hemes", 4));
Int32 themeCount = 500;
foreach (ITheme theme in _themeManager.Themes)
{
menuService.Get("T_hemes")
.Add(new MenuItemViewModel(theme.Name, ++themeCount, null, commandManager.GetCommand("ThemeCommand"))
{
CommandParameter = theme.Name,
});
}
}
public void OnInitialized(IContainerProvider containerProvider)
{
regionManager = containerProvider.Resolve <IRegionManager>();
regionManager.RegisterViewWithRegion(RegionNames.TabRegion, typeof(DefaultView));
regionManager.AddToRegion(RegionNames.LeftRegion, ServiceLocator.Current.GetInstance <ToolBoxView>());
regionManager.AddToRegion(RegionNames.RightRegion, ServiceLocator.Current.GetInstance <PropertiesView>());
regionManager.AddToRegion(RegionNames.MainRegion, ServiceLocator.Current.GetInstance <DocumentView>());
menuService.Add(new MenuItem()
{
Command = new DelegateCommand(ShowOutput), Parent = "View", Title = "Output"
});
menuService.Add(new MenuItem()
{
Command = new DelegateCommand(ShowProperties), Parent = "View", Title = "Properties Window"
});
menuService.Add(new MenuItem()
{
Command = new DelegateCommand(ShowToolbox), Parent = "View", Title = "Toolbox"
});
menuService.Add(new MenuItem()
{
Command = new DelegateCommand(AddNewDocument), Parent = "File", Title = "New"
});
}
public ActionResult Create(MenuViewModel menuViewModel, string submit)
{
if (ModelState.IsValid)
{
if (menuViewModel != null && submit == "Save")
{
menuViewModel.DateCreated = DateTime.UtcNow;
menuViewModel.DateModified = DateTime.UtcNow;
var menuLink = Mapper.Map <MenuViewModel, Menu>(menuViewModel);
_menuService.Add(menuLink);
AddMessage(this, "", "Record has Added Successfully", MessageType.Success);
return(RedirectToAction("Index", "Menu"));
}
if (menuViewModel != null && submit == "SaveAndContinue")
{
menuViewModel.DateCreated = DateTime.UtcNow;
menuViewModel.DateModified = DateTime.UtcNow;
var menuLink = Mapper.Map <MenuViewModel, Menu>(menuViewModel);
_menuService.Add(menuLink);
AddMessage(this, "", "Record has Added Successfully", MessageType.Success);
ModelState.Clear();
return(View());
}
}
return(View(menuViewModel));
}
private void SetupModuleMenu()
{
logger.Log(String.Format("SetupModuleMenu voor '{0}'", this.GetType()), Category.Debug, Priority.None);
menuService.Add(new MenuItem {
Parent = "View", Title = "Project Browser", Command = cmdOpenProjectBrowserModule
});
menuService.Add(new MenuItem {
Parent = "Project", Title = "Log regions and views", Command = cmdShowRegionsAndViews
});
}
public async Task <ActionResult> AddAjax(MenuDto dto)
{
if (ModelState.IsValid)
{
var result = await _menuService.Add(dto);
if (result.IsNotBlank())
{
return(Ok(result));
}
}
return(Fail("验证失败"));
}
public ActionResult <AddModel <MenuModel> > Add()
{
try
{
return(Ok(_serviceMenu.Add()));
}
catch (Exception exception)
{
ModelState.AddModelError("ErrorMessage", exception.Message);
return(BadRequest(ModelState));
}
}
public IActionResult Add([FromBody] MenuViewModel vm)
{
var model = _menuService.Add(vm);
_menuService.SaveChanges();
return(Ok(model));
}
public IActionResult Post([FromBody] Menu data)
{
data.isActive = true;
var createdMenu = service.Add(data);
return(CreatedAtAction("Get", new { id = createdMenu.Data.Id }, createdMenu));
}
public ActionResult SaveOrUpdateMenu([Bind("Name,SubMenu,Id,MenuId")] Menu menu)
{
try
{
if (menu != null && menu.Id == 0)
{
_menuService.Add(menu);
Alert("Menu adicionado com sucesso!", Enum.NotificationType.success);
}
else
{
if (menu.Id != menu.MenuId)
{
_menuService.Update(menu);
Alert("Menu atualizado com sucesso!", Enum.NotificationType.success);
}
else
{
Alert("Informe ao administrador do sistema.", Enum.NotificationType.error);
}
}
}
catch (Exception)
{
Alert("Informe ao administrador do sistema.", Enum.NotificationType.error);
}
ModelState.Clear();
UpdateMenus(_adminViewModel);
return(View("Menu", _adminViewModel));
}
public MenuViewModel Add(MenuViewModel menuViewModel)
{
var menu = _mapper.Map <MenuViewModel, Menu>(menuViewModel);
_menuService.Add(menu);
return(menuViewModel);
}
public HttpResponseMessage Add(HttpRequestMessage request, MenuViewModel modelVm)
{
if (ModelState.IsValid)
{
HttpResponseMessage response = null;
try
{
var model = new Menu();
model.UpdateMenu(modelVm);
var result = _menuService.Add(model);
_menuService.Save();
var menuVm = Mapper.Map <Menu, MenuViewModel>(result);
response = request.CreateResponse(HttpStatusCode.OK, menuVm);
return(response);
}
catch (Exception ex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public async Task <HttpResponseMessage> Post(HttpRequestMessage request, MenuViewModel menuVm)
{
//Khoi tao
Menu newMenu = new Menu();
newMenu.UpdateMenu(menuVm); //Gan ViewModel sang Model de Insert DB, this
//Gọi hàm Insert
var menu = await _menuService.Add(newMenu);
await _menuService.SaveAsync();
return(await CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
response = request.CreateResponse(HttpStatusCode.Created, menu);
}
return response;
}));
}
public ActionResult EditMenu(MenuDTO menu, Guid?module, Guid?parent)
{
return(HttpHandleExtensions.AjaxCallGetResult(() =>
{
menu.Permissions = new Collection <PermissionDTO>();
if (module.HasValue)
{
menu.Module = _moduleService.FindBy(module.Value);
}
if (parent.HasValue)
{
menu.Parent = _menuService.FindBy(parent.Value);
}
if (menu.Id == Guid.Empty)
{
_menuService.Add(menu);
this.JsMessage = MessagesResources.Add_Success;
}
else
{
_menuService.Update(menu);
this.JsMessage = MessagesResources.Update_Success;
}
base.ClearCacheMenus();
// 更新所有登陆用户缓存，以更新菜单信息
AuthorizeManager.ClearAllCache();
return Json(new AjaxResponse
{
Succeeded = true,
RedirectUrl = Url.Action("Index")
});
}));
}
public async Task <IActionResult> Add([FromBody] Menu entity)
{
if (await _menuService.Add(entity))
{
return(Ok());
}
return(BadRequest());
}
public IActionResult AddMenu(Menu menu)
{
if (_menuService.Add(menu))
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(RedirectToAction(nameof(Create)));
}
}
public async Task <IActionResult> Create([Bind("MenuId,MenuTitle,PageName,Depth,Path,IsActive,DisplayOrder,ParentId,Description,PageType,PageContetnt,MenuGroupId")] Menu menu)
{
if (ModelState.IsValid)
{
await _menuService.Add(menu);
return(RedirectToAction(nameof(Index), new { id = menu.MenuGroupId }));
}
ViewData["MenuGroupId"] = new SelectList(await _menuGroupService.MenuGroup(), "MenuGroupId", "MenuTitile", menu.MenuGroupId);
return(View(menu));
}
public async Task <CustomApiResponse> Post([FromBody] MenusDto entity)
{
var inputEntity = _mapper.Map <Menus>(entity);
//if (await _menuService.IsExisted(entity.Name))
//{
// return new CustomApiResponse("MenuName đã tồn tại", true);
//}
var result = await _menuService.Add(inputEntity);
return(new CustomApiResponse(result));
}
public ActionResult MenuEkle(Menu menu)
{
Pages page = new Pages();
page.Name = menu.Link;
page.NameEN = menu.NameENG;
_pagesService.Add(page);
menu.Link = "/home/PageDisplay/?pageName=" + menu.Link;
_menuService.Add(menu);
return(RedirectToAction("MenuEkle", "Menu"));
}
public ActionResult Add(MenuDto dto)
{
if (ModelState.IsValid)
{
var result = _menuService.Add(dto);
if (result.IsNotBlank())
{
return(RedirectToAction("Index"));
}
}
return(View(dto));
}
public ActionResult Create(Menu menu)
{
//[Bind(Include = "MenuID,MenuTitle,Depth,Path,IsActive,DisplayOrder,ParentId,Description,PageContetnt,GroupID")]
if (ModelState.IsValid)
{
_menuService.Add(menu);
return(RedirectToAction("Index/" + menu.MenuGroupId));
}
ViewBag.MenuGroupId = new SelectList(_menuGroupService.MenuGroup(), "MenuGroupId", "MenuTitile", menu.MenuGroupId);
return(View(menu));
}
public ActionResult Add(Menu model)
{
if (ModelState.IsValid)
{
_Service.Add(model);
_Service.Save();
return(RedirectToAction("Index", new { parentId = model.parentId }));
}
ViewBag.languageId = _toolAdmin.LanguageSelectList();
ViewBag.Menu = "active";
return(View(model));
}
public async Task <ActionResult <Result> > Create([FromBody] NewMenuInputModel input)
{
try
{
var result = await _service.Add(input);
return(ReturnResult(result));
}
catch (Exception ex)
{
return(BadRequest(Result.Error(ex)));
}
}
public ActionResult AddMenu(List <int> data)
{
foreach (var item in data)
{
int menu = Convert.ToInt32(_menuService.GetList().Where(x => x.ParentID == null).Select(x => x.OrderNumber).Max());
Page pages = _pageService.GetByPageID(item);
Menu menuAdding = new Menu();
if (menu != null)
{
menuAdding.OrderNumber = menu + 1;
}
else
{
menuAdding.OrderNumber = 0;
}
menuAdding.ParentID = null;
menuAdding.Url = pages.Url;
menuAdding.Type = "Page";
menuAdding.MenuName = pages.PageName;
_menuService.Add(menuAdding);
}
List <Menu> locations;
List <Entities.EntityClasses.Menu> menuNew;
locations = _menuService.GetList();
menuNew = locations.Where(l => l.ParentID == null).OrderBy(l => l.OrderNumber).
Select(l => new Entities.EntityClasses.Menu
{
id = l.MenuID,
text = l.MenuName,
type = l.Type,
Children = GetChildren(locations, l.MenuID)
}).ToList();
ViewBag.menusList = menuNew;
ViewBag.latestPages = _pageService.GetList().OrderBy(x => x.CreatedTime).Take(5);
ViewBag.Pages = _pageService.GetList();
return(Json(new { result = "Redirect", url = Url.Action("Index", "Menu") }));
}
static void Main(string[] args)
{
User user = new User()
{
Name = "ELEVEN", Id = 1239, Password = "******"
};
{
#region 装饰器模式实现静态AOP
//IUserService userService = SimpleFactory.CreateService<IUserService>("IUserService");
//userService = new DecoratorAOP(userService);
//userService.Register(user);
#endregion
}
{
#region 延迟代理模式实现静态AOP
//IUserService userService = new ProxyAOP();
//userService.Register(user);
#endregion
}
{
#region
IUserService userService = UnityAOP.UnityContainer.Resolve <IUserService>();
userService.Register(user);
Console.WriteLine("**********IOrderService**********");
Order order = new Order()
{
Id = 1, OrderNo = "201801290001", Remark = "test"
};
IOrderService orderService = UnityAOP.UnityContainer.Resolve <IOrderService>();
orderService.Create(order);
orderService.Cancel(order);
orderService.Pay(order);
Console.WriteLine("**********IMenuService**********");
IMenuService menuService = UnityAOP.UnityContainer.Resolve <IMenuService>();
menuService.Add();
menuService.Delete();
menuService.Update();
menuService.Select();
//IUserService userService = container.Resolve<IUserService>("UserServiceEx");
//userService.Register();
#endregion
}
Console.Read();
}
public ActionResult Create(Menu model)
{
try
{
service.Add(model);
}
catch (Exception ex)
{
//return View();
Success = false;
Message = ex.Message;
}
return(EasyUIResult());
}
public ActionResult New(MenuViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
MenuConfig.Clear();
if (!_menuService.Verify(model))
{
ModelState.AddModelError("", "URL冲突，请检查");
return(View(model));
}
var result = _menuService.Add(model);
return(RedirectToAction("Index", "Result", new { state = result, style = "dialog" }));
}
public IActionResult Post([FromBody] CreateEditViewModel menu)
{
if (menu is null)
{
return(BadRequest("Menu is null."));
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var menuMapper = _mapper.Map <Database.Context.Models.Menu>(menu);
_menuProvider.Add(menuMapper);
return(Ok(menu));
}
public MenuViewModel Add(MenuViewModel model)
{
try
{
Menu menu = new Menu();
menu.UpdateMenu(model);
var res = _menuService.Add(menu);
_menuService.SaveChanges();
return(Mapper.Map <MenuViewModel>(res));
}
catch (Exception ex)
{
LogError(ex);
return(null);
}
}
public IActionResult AddMenu([FromBody] Menu menu)
{
ResponseResult result = new ResponseResult();
try
{
result.Status = _menuService.Add(menu);
result.Message = "Success";
}
catch (Exception ex)
{
result.Message = ex.Message.ToString();
result.Status = false;
}
return(Ok(result));
}
public ActionResult EditMenu(MenuDTO menu)
{
menu.Permissions = new Collection <PermissionDTO>();
if (menu.Id == Guid.Empty)
{
_menuService.Add(menu);
}
else
{
_menuService.Update(menu);
}
return(Json(new AjaxResponse
{
Succeeded = true,
ShowMessage = false,
RedirectUrl = Url.Action("Index")
}));
}