示例#1
0
        protected override void AfterWorkSpaceLoaded()
        {
            MenuAddRequest[] menuadd = new MenuAddRequest[3];

            xwcs.core.controls.VisualControlInfo vic = Info.getVisualControlInfoByGuid(Guid.Parse(DashboardControl.GUID));
            XwBarButtonItem barButtonItem1           = new XwBarButtonItem(vic.Name);

            barButtonItem1.ItemClick += buttonClick1;
            menuadd[0] = new MenuAddRequest {
                destination = MenuDestination.MENU_file_open, content = barButtonItem1
            };

            vic = Info.getVisualControlInfoByGuid(Guid.Parse(supp.OutputControl.GUID));
            XwBarButtonItem barButtonItem2 = new XwBarButtonItem(vic.Name);

            barButtonItem2.ItemClick += buttonClick2;
            menuadd[1] = new MenuAddRequest {
                destination = MenuDestination.MENU_ViewOtherWindows, content = barButtonItem2
            };

            vic = Info.getVisualControlInfoByGuid(Guid.Parse(supp.TestControl.GUID));
            XwBarButtonItem barButtonItem3 = new XwBarButtonItem(vic.Name);

            barButtonItem3.ItemClick += buttonClick3;
            menuadd[2] = new MenuAddRequest {
                destination = MenuDestination.MENU_ViewOtherWindows, content = barButtonItem3
            };

            EventProxy.fireEvent(new AddToolBarRequestEvent(this, new AddToolBarRequest(menuadd)));
        }
        public async Task <MenuResponse> Add(MenuAddRequest request)
        {
            if (!HasPremission(request.RequestOwner, MenuPremssion.CanAdd))
            {
                return(UnauthorizedRequest());
            }
            var menuWithItems = request.ViewModel.MapToModel();

            await BaseBeforeAddAsync(menuWithItems, request.RequestOwner);

            await _menuDataSrv.AddAsync(menuWithItems);

            await request.ViewModel.MenuItems.ForEachAsync(x => _metaDataHandler.HandleAddition(x.MetaData));

            await BaseAfterAddAsync(menuWithItems, request.RequestOwner);

            return(new MenuResponse
            {
                Access = ResponseAccess.Granted,
                Menu = menuWithItems.MapToViewModel()
            });
        }
        public BasicResponse <MenuInfo> AddMenu(MenuAddRequest menurequest)
        {
            MenuInfo menuDTO        = menurequest.MenuInfo;
            string   menuCode       = "001"; //菜单编码
            string   parentMenuCode = "";    //父菜单编码
            short    menuMemo       = 0;     //菜单标志
            string   menuSort       = "0";

            if (string.IsNullOrEmpty(menuDTO.MenuName))
            {
                ThrowException("AddMenu", new Exception("模块名称必须输入!"));
            }
            if (string.IsNullOrEmpty(menuDTO.MenuParent))
            {
                ThrowException("AddMenu", new Exception("请选择模块上级模块!"));
            }
            if (!string.IsNullOrEmpty(menuDTO.MenuFile))
            {
                if (!menuDTO.MenuFile.Contains(".dll") && !menuDTO.MenuFile.Contains(".exe"))
                {
                    ThrowException("AddMenu", new Exception("菜单引用文件必须是dll文件或者是exe文件!"));
                }
            }
            parentMenuCode = GetMenuCodeByMenuName(menuDTO.MenuParent.Trim());
            List <MenuModel> MenuList    = _Repository.GetMenuList();
            List <MenuModel> SonMenuList = new List <MenuModel>();

            if (string.IsNullOrEmpty(parentMenuCode))//一级目录
            {
                SonMenuList = MenuList.FindAll(a => a.MenuMemo == -1).OrderByDescending(a => a.MenuCode).ToList();
                if (SonMenuList.Count > 0)
                {
                    //将此一级目录加在当前最后一个一级目录的后面
                    menuCode = (int.Parse(SonMenuList[0].MenuCode) + 1).ToString("000");
                    menuSort = (int.Parse(SonMenuList[0].MenuCode) + 1).ToString();
                }
                else
                {
                    menuSort = "1";
                }
                menuMemo = -1;
            }
            else//子模块
            {
                SonMenuList = MenuList.FindAll(a => a.MenuParent == parentMenuCode).OrderByDescending(a => a.MenuCode).ToList();
                if (SonMenuList.Count > 0)
                {
                    //将此一级目录加在当前最后一个一级目录的后面
                    menuCode = parentMenuCode.ToString() +
                               (int.Parse(SonMenuList[0].MenuCode.Substring(parentMenuCode.Length + 1)) + 1).ToString("000");
                    menuSort = (int.Parse(SonMenuList[0].MenuCode.Substring(parentMenuCode.Length + 1)) + 1).ToString();
                }
                else
                {
                    //当前模块是父模块的第一个模块
                    menuCode = parentMenuCode.ToString() + "001";
                    menuSort = "1";
                }
            }
            menuDTO.MenuCode   = menuCode;
            menuDTO.MenuMemo   = menuMemo;
            menuDTO.MenuSort   = menuSort;
            menuDTO.MenuParent = parentMenuCode;

            //判断菜单名是否存在,只有不存在才能插入
            if (CheckMenuNameExist(menuDTO.MenuName))
            {
                ThrowException("AddMenu", new Exception(String.Format("菜单名:{0} 已存在,请重新输入!", menuDTO.MenuName)));
            }

            var _menu        = ObjectConverter.Copy <MenuInfo, MenuModel>(menuDTO);
            var resultmenu   = _Repository.AddMenu(_menu);
            var menuresponse = new BasicResponse <MenuInfo>();

            menuresponse.Data = ObjectConverter.Copy <MenuModel, MenuInfo>(resultmenu);
            return(menuresponse);
        }
        /// <summary>
        /// 添加一个全新信息到菜单表并返回成功后的菜单对象(支持添加、更新,根据状态来判断)
        /// </summary>
        /// <param name="menuDTO"></param>
        /// <returns></returns>
        public BasicResponse <MenuInfo> AddMenuEx(MenuAddRequest menurequest)
        {
            BasicResponse <MenuInfo> Result = new BasicResponse <MenuInfo>();
            MenuInfo menuDTO = menurequest.MenuInfo;

            try
            {
                long   ID             = 0;
                string menuCode       = "001"; //菜单编码
                string parentMenuCode = "";    //父菜单编码
                short  menuMemo       = 0;     //菜单标志
                string menuSort       = "0";

                if (menuDTO == null)
                {
                    ThrowException("AddMenuEx", new Exception("菜单对象为空,请检查是否已赋值!"));
                }
                if (menuDTO.InfoState == InfoState.NoChange)
                {
                    ThrowException("AddMenuEx", new Exception("DTO对象未设置状态,请先设置!"));
                }
                if (string.IsNullOrEmpty(menuDTO.MenuName))
                {
                    ThrowException("AddMenuEx", new Exception("菜单名称必须输入!"));
                }
                if (string.IsNullOrEmpty(menuDTO.Remark1))
                {
                    ThrowException("AddMenuEx", new Exception("菜单简称必须输入!"));
                }
                //if (string.IsNullOrEmpty(menuDTO.MenuParent))
                //{
                //    ThrowException("AddMenuEx", new Exception("请选择菜单上级模块!"));
                //}
                if (!string.IsNullOrEmpty(menuDTO.MenuFile))
                {
                    if (!menuDTO.MenuFile.Contains(".dll") && !menuDTO.MenuFile.Contains(".exe"))
                    {
                        ThrowException("AddMenuEx", new Exception("菜单引用文件必须是dll文件或者是exe文件!"));
                    }
                }
                if (string.IsNullOrEmpty(menuDTO.MenuCode))
                {
                    #region 计算菜单编码
                    parentMenuCode = menuDTO.MenuParent.Trim();
                    List <MenuModel> MenuList    = _Repository.GetMenuList();
                    List <MenuModel> SonMenuList = new List <MenuModel>();
                    if (string.IsNullOrEmpty(parentMenuCode))//一级目录
                    {
                        SonMenuList = MenuList.FindAll(a => a.MenuMemo == -1).OrderByDescending(a => a.MenuCode).ToList();
                        if (SonMenuList.Count > 0)
                        {
                            //将此一级目录加在当前最后一个一级目录的后面
                            menuCode = (int.Parse(SonMenuList[0].MenuCode) + 1).ToString("000");
                            menuSort = (int.Parse(SonMenuList[0].MenuCode) + 1).ToString();
                        }
                        else
                        {
                            menuSort = "1";
                        }
                        menuMemo = -1;
                    }
                    else//子模块
                    {
                        SonMenuList = MenuList.FindAll(a => a.MenuParent == parentMenuCode).OrderByDescending(a => a.MenuCode).ToList();
                        if (SonMenuList.Count > 0)
                        {
                            //将此一级目录加在当前最后一个一级目录的后面
                            menuCode = parentMenuCode.ToString() +
                                       (int.Parse(SonMenuList[0].MenuCode.Substring(parentMenuCode.Length + 1)) + 1).ToString("000");

                            menuSort = (int.Parse(SonMenuList[0].MenuCode.Substring(parentMenuCode.Length + 1)) + 1).ToString();
                        }
                        else
                        {
                            //当前模块是父模块的第一个模块
                            menuCode = parentMenuCode.ToString() + "001";

                            menuSort = "1";
                        }
                    }
                    menuDTO.MenuCode   = menuCode;
                    menuDTO.MenuMemo   = menuMemo;
                    menuDTO.MenuSort   = menuSort;
                    menuDTO.MenuParent = parentMenuCode;
                    #endregion
                }
                else
                {
                    parentMenuCode = menuDTO.MenuParent.Trim();
                    if (string.IsNullOrEmpty(parentMenuCode))//一级目录
                    {
                        menuDTO.MenuParent = "";
                    }
                    else
                    {
                        menuDTO.MenuParent = parentMenuCode;
                    }
                }
                if (menuDTO.MenuCode == menuDTO.MenuParent)
                {
                    ThrowException("AddMenuEx", new Exception("父菜单不能和菜单名称相同!"));
                }
                if (menuDTO.MenuParent.Length > 0)
                {
                    menuDTO.MenuMemo = 0;
                }

                if (menuDTO.InfoState == InfoState.AddNew)
                {
                    ID             = IdHelper.CreateLongId();
                    menuDTO.MenuID = ID.ToString();
                    var _menu      = ObjectConverter.Copy <MenuInfo, MenuModel>(menuDTO);
                    var resultmenu = _Repository.AddMenu(_menu);
                    Result.Data = ObjectConverter.Copy <MenuModel, MenuInfo>(resultmenu);
                }
                else
                {
                    var _menu = ObjectConverter.Copy <MenuInfo, MenuModel>(menuDTO);
                    _Repository.UpdateMenu(_menu);
                    var resultmenu = _Repository.GetMenuById(menuDTO.MenuID);
                    Result.Data = ObjectConverter.Copy <MenuModel, MenuInfo>(resultmenu);
                }
            }
            catch (System.Exception ex)
            {
                Result.Code    = 1;
                Result.Message = ex.Message;
            }
            return(Result);
        }
示例#5
0
 public BasicResponse <MenuInfo> AddMenu(MenuAddRequest menurequest)
 {
     return(_menuService.AddMenu(menurequest));
 }
示例#6
0
 public AddToolBarRequest(MenuAddRequest[] content)
 {
     this.content = content;
 }
        /// <summary>
        /// 添加一个全新信息到菜单表并返回成功后的菜单对象(支持添加和更新)
        /// </summary>
        /// <param name="menurequest"></param>
        /// <returns></returns>
        public BasicResponse <MenuInfo> AddMenuEx(MenuAddRequest menurequest)
        {
            var responseStr = HttpClientHelper.Post(Webapi + "/v1/Menu/AddMenuEx?token=" + Token, JSONHelper.ToJSONString(menurequest));

            return(JSONHelper.ParseJSONString <BasicResponse <MenuInfo> >(responseStr));
        }