public JsonResult UpdateMenu()
{
Sys_Menu entity = new Sys_Menu
{
Id = Request["menuId"].ToInt32(),
Description = Request["txtDesc"],
Name = Request["txtName"],
Url = Request["txtUrl"],
Enable = Request["Enable"].ToBoolean(),
ParentId = Convert.ToInt32(Request["txtParentId"])
};
Notify <bool> notify = new Notify <bool>();
if (_sysMenuService.UpdateEntity(entity))
{
notify.Data = true;
}
else
{
notify.Data = false;
notify.Status = StatusCode.Error;
notify.Message = "删除失败";
}
return(Json(notify, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 表单数据保存
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public HttpResponseMessage SaveSysMoudleForm(Sys_Menu obj)
{
DBHelper <Sys_Menu> dbhelp = new DBHelper <Sys_Menu>();
var result = obj.MenuID == 0 ? dbhelp.Add(obj) : dbhelp.Update(obj);
return(Json(true, result == 1 ? "保存成功！" : "保存失败"));
}
/// <summary>
/// 判断菜单是否已经打开
/// </summary>
/// <param name="sys_Menu">系统菜单</param>
/// <returns>返回布尔值</returns>
private bool IsMenuOpen(Sys_Menu sys_Menu)
{
try
{
if (!BaseService.CheckConfiguration("Global_MainUI_MdiTabMenu_CheckDuplicate").ToBoolEx())
{
return(false);
}
foreach (Form tabPage in this.OwnedForms)
{
ChildPage myPage = (ChildPage)tabPage;
Sys_Menu cys_Menu = myPage.SysMenu;
if (cys_Menu != null && cys_Menu.Menu_Id.Equals(sys_Menu.Menu_Id))
{
tabPage.Show();
return(true);
}
}
return(false);
}
catch (Exception ex)
{
SharedFunc.RaiseError(ex);
return(false);
}
finally
{
}
}
public ActionResult Edit(long id = 0)
{
var model = new Sys_Menu() { OrderIndex = 0 };
if (id > 0)
model = CacheClientLib.CacheClient.Services.Sys_MenuService.GetModel(id) ?? new Sys_Menu() { OrderIndex = 0 };
return View(model);
}
/// <summary>
/// 菜单编辑页面
/// </summary>
/// <param name="active"></param>
/// <param name="parentId"></param>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult MenuEdit(string active, int parentId = 0, string id = "")
{
Sys_Menu model = new Sys_Menu();
if (active == "1")
{
//新增
if (parentId != 0)
{
parentId = Convert.ToInt32(Request.Params["parentId"]);
}
model.ParentID = parentId;
}
else
{
//修改
if (id != "")
{
id = Request.Params["id"].ToString();
}
string sql = "select * from Sys_Menu where pk_Menu='" + id + "'";
model = _sys_MenuService.SelectData <Sys_Menu>(sql)[0];
}
return(View(model));
}
public static ChildPage LoadPage(string menuId)
{
try
{
List <Sys_Menu> MenuData = Provider.UserMenus;
Sys_Menu sys_Menu = MenuData.Find(m => m.Menu_Id == menuId);
if (sys_Menu == null)
{
return(null);
}
List <MyParameter> myParameters = new List <MyParameter>();
myParameters.Add("@Menu_Id", DbType.String, sys_Menu.Menu_Page, null);
DataTable dt = BaseService.Open("SystemMenu_Single", myParameters);
Sys_Page sys_Page = EntityHelper.GetEntity <Sys_Page>(dt);
ChildPage childPage = LoadPage(sys_Page);
childPage.Text = sys_Menu.Menu_Nick;
childPage.SysMenu = sys_Menu;
return(childPage);
}
catch (Exception ex)
{
throw ex;
}
finally
{
}
}
/// <summary>
/// 获得排序号
/// </summary>
/// <param name="menucode"></param>
/// <returns></returns>
public string GetSortNum(HttpContext context)
{
string pcode = context.Request.QueryString["pcode"];
List <Sys_Menu> lists = bll.GetList(p => p.Menu_Code == pcode).ToList();//" Menu_Code ='" + pcode + "'"
if (lists.Count > 0)
{
List <Sys_Menu> list = bll.GetList(p => p.Menu_ParentCode == pcode).ToList();
if (list.Count > 0)
{
Sys_Menu model = list.OrderByDescending(p => p.Menu_Sequence).First();
return((model.Menu_Sequence + 1).ToString());
}
else
{
return("1");
}
}
else
{
return("0");
}
}
public string ShowInfo(HttpContext context)
{
string code = context.Request.QueryString["code"];
Sys_Menu model = bll.Get(p => p.Menu_Code == code);
string json = "";
if (model != null)
{
string a = model.ToJson <Sys_Menu>();//JosnHandler.GetJson<Sys_Menu>(model);
List <Sys_MenuOperatingButton> ButtonList = model.Sys_MenuOperatingButton.OrderBy(p => p.Sort).ToList();
string b = JsonConvert.SerializeObject(new { Button = ButtonList });
JObject obj1 = (JObject)JsonConvert.DeserializeObject(a);
JObject obj2 = (JObject)JsonConvert.DeserializeObject(b);
obj1.Merge(obj2, new JsonMergeSettings
{
// union array values together to avoid duplicates
MergeArrayHandling = MergeArrayHandling.Union//合并json
});
json = obj1.ToString();
}
else
{
string b = "";
json = b;
}
return(json);
}
public JsonResult AddMenu()
{
Notify <bool> notify = new Notify <bool>();
Sys_Menu entity = new Sys_Menu
{
Description = Request["txtDesc"],
Name = Request["txtName"],
Url = Request["txtUrl"],
ParentId = Request["txtParentId"].ToInt32(),
Enable = Request["Enable"].ToInt32() == 1 ? true : false
};
if (null != _sysMenuService.AddEntity(entity))
{
int maxMenuId = _sysMenuService.LoadEntities(c => true).Max(c => c.Id);
#region 查询出当前登录角色,给角色授权菜单
Sys_User user = (Sys_User)Session["YD_USER"];
int roleId = (int)_sysUserRoleService.LoadEntities(c => c.UserId == user.Id).SingleOrDefault().RoleId;
#endregion
_sysRoleMenuService.AddEntity(new Sys_RoleMenu {
RoleId = roleId, MenuId = maxMenuId
});
notify.Data = true;
}
else
{
notify.Data = false;
notify.Status = StatusCode.Error;
notify.Message = "删除失败";
}
return(Json(notify, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 新建或编辑菜单
/// </summary>
/// <param name="menu"></param>
/// <returns></returns>
public async Task <WebResponseContent> Save(Sys_Menu menu)
{
WebResponseContent webResponse = new WebResponseContent();
bool result = true;;
try
{
if (menu == null)
{
return(webResponse.Error("没有获取到提交的参数"));
}
webResponse = menu.ValidationEntity(x => new { x.MenuName, x.TableName });
if (!webResponse.Status)
{
return(webResponse);
}
if (menu.Menu_Id <= 0)
{
menu.SetCreateDefaultVal();
repository.Add(menu);
}
else
{
menu.SetModifyDefaultVal();
repository.Update(menu, p => new
{
p.ParentId,
p.MenuName,
p.Url,
p.Auth,
p.OrderNo,
p.Icon,
p.Enable,
p.TableName,
p.ModifyDate,
p.Modifier
});
}
await repository.SaverChangesAsync();
if (result)
{
_menuVersionn = DateTime.Now.ToString("yyyyMMddHHMMssfff");
_menus = null;
}
webResponse.OK("保存成功", menu);
}
catch (Exception ex)
{
webResponse.Error(ex.Message);
}
finally
{
Logger.Info($"表:{menu.TableName},菜单：{menu.MenuName},权限{menu.Auth},{(webResponse.Status ? "成功" : "失败")}{webResponse.Message}");
}
return(webResponse);
}
public async Task <bool> AddOrUpdateAsync(Sys_Menu menu)
{
try
{
var sysMenu = await GetMenuAsync(menu.MenuId);
bool isNew = false;
if (sysMenu == null)
{
isNew = true;
sysMenu = new Sys_Menu();
}
foreach (var p in sysMenu.GetType().GetProperties())
{
//更新属性
var v = menu.GetType().GetProperty(p.Name).GetValue(menu);
if (v != null)
{
//其他字段更新
p.SetValue(sysMenu, v);
}
}
if (isNew)
{
context.Sys_Menus.Add(sysMenu);
}
return(await context.SaveChangesAsync() == 1);
}
catch (Exception)
{
return(false);
}
}
public ActionResult Form(int pid, int id = 0)
{
ViewBag.MenuList = menuService.GetAll();
//新增
if (id == 0)
{
Sys_Menu Sys_mu = new Sys_Menu();
Sys_mu.ParentID = 0;
Sys_mu.ParenName = "";
if (pid != 0)
{
var fileds = menuService.GetDefaultByMenuID(pid);
Sys_mu.ParentID = pid;
Sys_mu.ParenName = fileds.MenuName;
}
return(PartialView(Sys_mu));
}
else
{
var Sys_mu = menuService.GetDefaultByMenuID(id);
if (Sys_mu.ParentID != 0)
{
var field = menuService.GetDefaultByMenuID(Sys_mu.ParentID);
Sys_mu.ParenName = field.MenuName;
}
return(PartialView(Sys_mu));
}
}
public ActionResult _Delete(int Menulds)
{
Sys_Menu Sys_mu = new Sys_Menu();
Sys_mu.ID = Menulds;
return(Json(menuService.Delete(Sys_mu), JsonRequestBehavior.DenyGet));
}
/// <summary>
/// 获取用户菜单列表
/// </summary>
/// <param name="menutitle"></param>
/// <returns></returns>
public static List <Sys_Menu> GetUserMenuList(string menutitle, string currentuser)
{
List <Sys_Menu> menulist = new List <Sys_Menu>();
string sql = "";
using (var conn = new SqlConnection(SqlHelper.SqlConnString))
{
if (string.IsNullOrEmpty(menutitle))
{
sql = "select MenuNo,MenuName,MenuAddr,ParentNo,MenuTag,Image from View_Sys_UserLimitInfo where ParentNo='0000' and UserNo= '" + currentuser + "' order by MenuNo";
}
else
{
string sql1 = @"select MenuNo,MenuName,MenuAddr,ParentNo,MenuTag,Image from View_Sys_UserLimitInfo where ParentNo in (select MenuNo from Sys_MenuInfo where MenuName='{0}' and ParentNo='0000') and UserNo= '" + currentuser + "' order by MenuNo";
sql = string.Format(sql1, menutitle);
}
DataTable dt = SqlHelper.GetDataDataTable(SqlHelper.SqlConnString, System.Data.CommandType.Text, sql, null);
foreach (DataRow row in dt.Rows)
{
Sys_Menu model = new Sys_Menu();
//model.ID = NumericParse.StringToInt(DataHelper.GetCellDataToStr(row, "ID"));
model.MenuNo = DataHelper.GetCellDataToStr(row, "MenuNo");
model.MenuName = DataHelper.GetCellDataToStr(row, "MenuName");
model.MenuAddr = DataHelper.GetCellDataToStr(row, "MenuAddr");
model.ParentNo = DataHelper.GetCellDataToStr(row, "ParentNo");
model.MenuTag = DataHelper.GetCellDataToStr(row, "MenuTag");
model.Image = DataHelper.GetCellDataToStr(row, "Image");
menulist.Add(model);
}
return(menulist);
}
}
/// <summary>
/// 删除一条数据
/// </summary>
public string DelInfo(string id)
{
if (id.Length > 0)
{
Common_BLL pg = new Common_BLL();
Sys_MenuBLL bllMenu = new Sys_MenuBLL();
if (pg.Delete(TableName, TableKey, "'" + id + "'", ""))
{
//删除待办事项
new RoleConfig().DeleteMatterTasks(id.Replace("'", ""));
string rtnUrl = Request.RawUrl;
Sys_Menu MenuModel = bllMenu.FindByURL(rtnUrl);
if (MenuModel != null)
{
if (!string.IsNullOrEmpty(MenuModel.Menu_Name))
{
pg.AddLog(MenuModel.Menu_Name, id, "删除", "ID=" + id + "", bg.CurrUserInfo().UserID, bg.CurrUserInfo().DepartmentCode);
}
}
return("1");
}
else
{
return("0");
}
}
else
{
return("0");
}
}
/// <summary>Implements <see cref="ISys_MenuRepository.Find"/></summary>
public Sys_Menu Find(Int32 id)
{
String stmtId = "Sys_Menu.Find";
Sys_Menu result = SqlMapper.QueryForObject <Sys_Menu>(stmtId, id);
return(result);
}
/// <summary>Implements <see cref="ISys_MenuService.Insert"/></summary>
public void Insert(Sys_Menu obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
_repository.Insert(obj);
}
/// <summary>Implements <see cref="ISys_MenuService.Delete"/></summary>
public void Delete(Sys_Menu obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
_repository.Delete(obj);
}
public bool UpdateMenu([FromBody] Sys_MenuModel model)
{
Mapper.CreateMap <Sys_MenuModel, Sys_Menu>(); // 配置
Sys_Menu menu = Mapper.Map <Sys_MenuModel, Sys_Menu>(model); // 使用AutoMapper自动映射
IComponentLogic IComponent = container.Resolve <IComponentLogic>();
return(IComponent.UpdateMenu(menu));
}
public async Task <JsonResult> SaveMenu(Sys_Menu menu)
{
using (Sys_MenuRepository rep = new Sys_MenuRepository())
{
var result = await rep.AddOrUpdateAsync(menu);
return(Json(new { isOk = result }));
}
}
public ActionResult Save(Sys_Menu model, string _Sys_Function_List)
{
this.KeyID = _Logic.Save(model, _Sys_Function_List);
return(this.Success(new
{
status = 1,
ID = this.KeyID
}));
}
public static string SaveMenu(string eid, string emcode, string emname, string emgroup, string emstyle, string emsort, string epmcode, string epmname, string eshow, string eurl)
{
string r = "";
Sys_MenuBll sdb = new Sys_MenuBll();
SessionUserValidate iv = SysValidateBll.ValidateSession();
if (iv.f)
{
Sys_Menu sm = new Sys_Menu();
sm.mname = emname;
sm.mcode = emcode;
sm.mpname = epmname;
sm.mpcode = epmcode;
sm.mshow = eshow == "1" ? true : false;
sm.murl = eurl;
sm.mstyle = emstyle;
sm.mgroup = emgroup;
if (emcode.Length > 3)
{
sm.mhaschild = false;
}
else
{
sm.mhaschild = true;
}
sm.msort = Convert.ToInt32(emsort);
sm.mtype = "1";
sm.mdate = DateTime.Now.ToString();
if (eid == "0")
{
if (sdb.Add(sm) > 0)
{
r = "S";
}
else
{
r = "F";
}
}
else
{
if (sdb.Update(sm))
{
r = "S";
}
else
{
r = "F";
}
}
}
else
{
r = iv.badstr;
}
return(r);
}
/// <summary>Implements <see cref="ISys_MenuRepository.Insert"/></summary>
public void Insert(Sys_Menu obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
String stmtId = "Sys_Menu.Insert";
SqlMapper.Insert(stmtId, obj);
}
public Sys_MenuModel GetMenu(Guid id)
{
IComponentLogic IComponent = container.Resolve <IComponentLogic>();
Sys_Menu menu = IComponent.GetMenu(id);
Mapper.CreateMap <Sys_Menu, Sys_MenuModel>(); // 配置
Sys_MenuModel model = Mapper.Map <Sys_Menu, Sys_MenuModel>(menu); // 使用AutoMapper自动映射
return(model);
}
public Sys_MenuModel GetMenuListByUrl(string url)
{
IComponentLogic IComponent = container.Resolve <IComponentLogic>();
Sys_Menu menu = IComponent.GetMenuListByUrl(url);
Mapper.CreateMap <Sys_Menu, Sys_MenuModel>(); // 配置
Sys_MenuModel model = Mapper.Map <Sys_Menu, Sys_MenuModel>(menu); // 使用AutoMapper自动映射
return(model);
}
/// <summary>Implements <see cref="ISys_MenuRepository.Delete"/></summary>
public void Delete(Sys_Menu obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
String stmtId = "Sys_Menu.Delete";
SqlMapper.Delete(stmtId, obj);
}
public JsonResult PostSave(Sys_Menu entity)
{
if (entity.ID == 0)
{
return(Json(menuService.Insert(entity), JsonRequestBehavior.DenyGet));
}
else
{
return(Json(menuService.Update(entity), JsonRequestBehavior.DenyGet));
}
}
public JsonResult QuickSave(Sys_Menu model)
{
JsonResult result = new JsonResult();
if (model.Id == Guid.Empty)
{
result.Data = dalSM.Insert(model);
}
else
{
result.Data = dalSM.Update(model);
}
return(result);
}
/// <summary>
/// 根据菜单获取权限
/// </summary>
/// <param name="_Sys_Menu"></param>
/// <returns></returns>
public async Task <Dictionary <string, object> > GetPowerStateByMenu(Sys_Menu _Sys_Menu)
{
var _Sys_FunctionList = await db
.Query <Sys_Function>()
.OrderBy(w => w.t1.Function_Num)
.ToListAsync();
var _Sys_MenuFunctionList = await db
.Query <Sys_MenuFunction>(w => w.t1.MenuFunction_MenuID == _Sys_Menu.Menu_ID)
.ToListAsync();
var _Sys_RoleMenuFunctionList = await db
.Query <Sys_RoleMenuFunction>(w => w.In(w.t1.RoleMenuFunction_RoleID, this._Account.RoleIDList))
.ToListAsync();
var _PowerState = new Dictionary <string, object>();
if (this._Account.IsSuperManage)
{
foreach (var item in _Sys_FunctionList)
{
var ispower = _Sys_MenuFunctionList.Any(w => w.MenuFunction_MenuID == _Sys_Menu.Menu_ID && w.MenuFunction_FunctionID == item.Function_ID);
if (item.Function_ByName == "Have" | _Sys_Menu.Menu_ParentID == AppConfig.SysMenuID)
{
ispower = true;
}
_PowerState.Add(item.Function_ByName, ispower);
}
}
else
{
foreach (var item in _Sys_FunctionList)
{
if (this._Account.RoleIDList?.Count > 0)
{
var ispower = _Sys_RoleMenuFunctionList.Any(w =>
this._Account.RoleIDList.Contains(w.RoleMenuFunction_RoleID.ToGuid()) &&
w.RoleMenuFunction_MenuID == _Sys_Menu.Menu_ID &&
w.RoleMenuFunction_FunctionID == item.Function_ID);
_PowerState.Add(item.Function_ByName, ispower);
}
else
{
_PowerState.Add(item.Function_ByName, false);
}
}
}
return(_PowerState);
}
public object Put(int id, [FromBody] Sys_Menu model)
{
string currentUserName = "";
model.F_LastModifyTime = DateTime.Now;
model.F_LastModifyUserId = currentUserName;
var updateResult = sysMenuManager.Update(model);
return(Ok(new
{
success = updateResult
}));
}
public static ChildPage LoadPage(Sys_Menu sys_Menu)
{
try
{
ChildPage page = LoadPage(sys_Menu.Menu_Id);
return(page);
}
catch (Exception ex)
{
throw ex;
}
finally
{
}
}
public ActionResult Add(Sys_Menu model, bool isRedirect = false)
{
int id = model.Id;
ViewData.Model = model;
sys_MenuService.AddOrUpdate(model);
if (!isRedirect)
{
if (id > 0)
{
AddAlertMsg("修改成功");
}
else
{
AddAlertMsg("添加成功");
}
}
else
{
return RedirectToAction("Index");
}
return View(model);
}
/// <summary>
/// 根据ID进行实体更新
/// </summary>
/// <param name="model">实体</param>
/// <returns>是否成功</returns>
public bool Insert(Sys_Menu model)
{
return DalSys_Menu.Singleton.Insert(model);
}
/// <summary>
/// 根据实体整个更新数据库
/// </summary>
/// <param name="model">实体</param>
/// <returns>是否成功</returns>
public bool Update(Sys_Menu model)
{
return DalSys_Menu.Singleton.Update(model);
}
