public ActionResult Create(MenuPermission ObjMenuPermission)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
try
{
if (ModelState.IsValid)
{
db.MenuPermissions.Add(ObjMenuPermission);
db.SaveChanges();
sb.Append("Sumitted");
return(Content(sb.ToString()));
}
else
{
foreach (var key in this.ViewData.ModelState.Keys)
{
foreach (var err in this.ViewData.ModelState[key].Errors)
{
sb.Append(err.ErrorMessage + "<br/>");
}
}
}
}
catch (Exception ex)
{
sb.Append("Error :" + ex.Message);
}
return(Content(sb.ToString()));
}
// GET: MenuPermission
public ActionResult Index()
{
var query = "";
query = $"Exec prcgetAspnetUserList 'MenuPermission'";
SqlParameter[] sqlParameter1 = new SqlParameter[1];
sqlParameter1[0] = new SqlParameter("@Criteria", "MenuPermission");
List <MenuPermission> menuPermission = Helper.ExecProcMapTList <MenuPermission>("prcgetAspnetUserList", sqlParameter1).ToList();
var resultUsers = new List <MenuPermission>();
foreach (var menu in menuPermission)
{
var resultUser = new MenuPermission();
resultUser.UserId = menu.UserId;
resultUser.useridPermission = menu.useridPermission;
resultUser.UserName = menu.UserName;
resultUser.CompanyName = menu.CompanyName;
resultUser.comid = menu.comid;
resultUser.Email = menu.UserName;
resultUser.MenuPermissionId = menu.MenuPermissionId;
resultUsers.Add(resultUser);
}
ViewBag.MenuPermission = resultUsers;
return(View());
}
public ID Save(MenuPermission oMenuPermission)
{
bool bIsExist = false;
try
{
if (oMenuPermission.IsNew)
{
string QueryString = "SELECT COUNT(*) FROM Menu_Permission_Table WHERE MenuID=" + oMenuPermission.MenuID + " AND user_id=" + oMenuPermission.UserID;
bIsExist = ExecuteQueryFunctions.ExeSclr(_conn, QueryString);
if (!bIsExist)
{
BusinessObject.Factory.SetID(oMenuPermission, new ID(ExecuteQueryFunctions.GetNewID(_conn, "SELECT MAX(UPID) FROM Menu_Permission_Table")));
string QueryString2 = "INSERT INTO Menu_Permission_Table (UPID,MenuID,user_id,DBUserID,DBSDT)"
+ "VALUES(" +
oMenuPermission.ObjectID + "," +
oMenuPermission.MenuID + "," +
oMenuPermission.UserID + "," +
EMSGlobal._nCurrentUserID + ",'" +
DateTime.Now + "')";
ExecuteQueryFunctions.ExeNonQuery(_conn, QueryString2);
}
}
BusinessObject.Factory.SetObjectState(oMenuPermission, ObjectState.Saved);
}
catch (Exception e)
{
throw new ServiceException(e.Message);
}
return(oMenuPermission.ID);
}
private MenuPermission CreateObject(NullHandler oReader)
{
MenuPermission oMenuPermission = new MenuPermission();
MapObject(oMenuPermission, oReader);
return(oMenuPermission);
}
public ActionResult Index()
{
LoginService service = new LoginService();
var currentUser = CurrentSession.GetCurrentSession();
if (currentUser != null)
{
List <MenuPermission> list = new List <MenuPermission>();
var ListOfPermittedMenu = service.GetMenuPermission(currentUser.UserRoleId);
var maninMenu = ListOfPermittedMenu.Where(a => a.ParentScreenId == "0000").ToList();
foreach (var item in maninMenu)
{
var menu = new MenuPermission();
menu.MainModule = item;
var submodule = ListOfPermittedMenu.Where(a => a.ParentScreenId == item.ScreenId).ToList();
menu.SubModules = submodule;
list.Add(menu);
}
Session["MenuPermission"] = list;
return(View());
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public ActionResult UpdateManagePermission(MenuPermission menuPermission, bool[] IsVisible, int[] MenuId, int Id)
{
db.Database.ExecuteSqlCommand("delete from MenuPermissions where RoleId='" + Id + "'");
List <bool> list = new List <bool>(IsVisible);
for (int i = 0; i < MenuId.Length; i++)
{
if (list[i] == true)
{
IsVisible[i] = true;
list.RemoveAt(i + 1);
}
else
{
IsVisible[i] = false;
}
menuPermission.IsVisible = list[i];
menuPermission.RoleId = Id;
menuPermission.MenuId = MenuId[i];
db.MenuPermission.Add(menuPermission);
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public HomeView()
{
InitializeComponent();
BindingContext = viewModel = new HomeViewModel();
MenuPermission.Permission(this);
PopupNavigation.Instance.PushAsync(new HelloView());
}
public IActionResult Edit(MenuPermission model)
{
AlertBack alert = new AlertBack();
try
{
if (ModelState.IsValid)
{
_menuPermissionService.Update(model);
alert.Status = "success";
alert.Message = "Register Successfully";
}
else
{
alert.Status = "warning";
foreach (var key in this.ViewData.ModelState.Keys)
{
foreach (var err in this.ViewData.ModelState[key].Errors)
{
alert.Message += err.ErrorMessage + "<br/>";
}
}
}
}
catch (Exception ex)
{
alert.Status = "error";
alert.Message = ex.Message;
}
return(Json(alert));
}
public static bool HasPermission(string requiredPermission)
{
bool bFound = false;
if (requiredPermission == "CompanySettings")
{
requiredPermission = "MasterSettings";
}
if (requiredPermission == "UserDetails")
{
requiredPermission = "MasterSettings";
}
List <MenuPermission> menuPer = SessionPersister._PrivilegeInfo;
if (menuPer != null)
{
MenuPermission permission = menuPer.Where(x => x.ControllerName == requiredPermission).FirstOrDefault();
if ((permission != null) && (permission.CanCreate == true || permission.CanDelete == true || permission.CanEdit == true || permission.CanView == true))
{
bFound = true;
}
}
return(bFound);
}
public static void UpdateMenuPermission(MenuPermission entity)
{
DataCommand cmd = new DataCommand("UpdateMenuPermission");
cmd.SetParameter <MenuPermission>(entity);
cmd.ExecuteNonQuery();
}
private void RefreshObject(List <MenuPermission> oNewMenuPermissions, int id)
{
foreach (TreeNode item in CheckedNodes(tvwMenu.Nodes))
{
if (item.Checked)
{
_MenuPermission = new MenuPermission();
_MenuPermission.MenuPermissionID = id;
_MenuPermission.MenuID = (int)item.Tag;
_MenuPermission.RoleID = _oRole.RoleID;
oNewMenuPermissions.Add(_MenuPermission);
id++;
}
}
foreach (TreeNode item in CheckedNodes(tvwButton.Nodes))
{
if (item.Checked)
{
_MenuPermission = new MenuPermission();
_MenuPermission.MenuPermissionID = id;
_MenuPermission.MenuID = (int)item.Tag;
_MenuPermission.RoleID = _oRole.RoleID;
oNewMenuPermissions.Add(_MenuPermission);
id++;
}
}
}
public async Task <IActionResult> PutMenuPermission(long id, MenuPermission menuPermission)
{
if (id != menuPermission.mPID)
{
return(BadRequest());
}
_context.Entry(menuPermission).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MenuPermissionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <MenuPermission> > PostMenuPermission(MenuPermission menuPermission)
{
_context.MenuPermissions.Add(menuPermission);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMenuPermission", new { id = menuPermission.mPID }, menuPermission));
}
public ActionResult _AddMenuIntoAccount(int idAccount, int idRole, int idMenu, string IsRead, string IsCreate, string IsUpdate, string IsDelete, string IsExport)
{
// kiểm tra quyền thêm sửa xóa của từng menu , nhớ truyền type tương ứng
var sys = CheckActiveMenu.ReturnActive(SystemMessageConst.TypeAction.Addnew);
if (sys.IsSuccess == false)
{
return(Json(new { result = sys }, JsonRequestBehavior.AllowGet));
}
var db = new RoleUserBusiness();
MenuPermission item = new MenuPermission();
item.MenuId = idMenu;
item.RoleId = idRole;
item.UserId = idAccount;
item.IsRead = bool.Parse(IsRead);
item.IsCreate = bool.Parse(IsCreate);
item.IsUpdate = bool.Parse(IsUpdate);
item.IsDelete = bool.Parse(IsDelete);
item.IsExport = bool.Parse(IsExport);
var result = db.AddMenuIntoAccountRole(item);
return(Json(new { result }, JsonRequestBehavior.AllowGet));
}
public IActionResult AddMenuPermission(int menuId, int roleId, Nullable <int> sortOrder, Nullable <int> user)
{
AlertBack alert = new AlertBack();
try
{
MenuPermission menu = new MenuPermission
{
IsCreate = true,
IsDelete = true,
IsRead = true,
IsUpdate = true,
IsActive = true,
MenuId = menuId,
RoleId = roleId,
UserId = user,
SortOrder = sortOrder
};
_menuPermissionService.Insert(menu);
alert.Status = "success";
alert.Message = menu.Id.ToString();
}
catch (Exception ex)
{
alert.Status = "error";
alert.Message = ex.Message;
}
return(Json(alert));
}
public ActionResult Privilege()
{
MenuPermission privilege = new MenuPermission();
privilege.RolesItems = _IRole.GetAllRoles();
privilege.MenuItems = _ICommon.GetMenu().Where(x => x.MenuParentID == 0).ToList();
return(View(privilege));
}
private void GrantMenuPermissionToGroup(int permissionGroupId, MenuPermissionModel menuPermissionRq)
{
MenuPermission menuPermission = new MenuPermission();
_mapper.Map(menuPermissionRq, menuPermission);
menuPermission.PermissionGroupId = permissionGroupId;
_menuPermissionRepository.Create(menuPermission);
}
public ActionResult DeleteConfirmed(int id)
{
MenuPermission ObjMenuPermission = db.MenuPermissions.Find(id);
db.MenuPermissions.Remove(ObjMenuPermission);
db.SaveChanges();
return(Redirect(TempData["ThisUrl"].ToString()));
}
public static int InsertMenuPermission(MenuPermission entity)
{
DataCommand cmd = new DataCommand("InsertMenuPermission");
cmd.SetParameter <MenuPermission>(entity);
int result = cmd.ExecuteScalar <int>();
return(result);
}
private void btnSave_Click(object sender, EventArgs e)
{
try
{
if (!IsValid())
{
return;
}
bool IsNew = false;
using (DEWSRMEntities db = new DEWSRMEntities())
{
List <MenuPermission> oNewMenuPermissions = new List <MenuPermission>();
int id = db.MenuPermissions.Count() > 0 ? db.MenuPermissions.Max(obj => obj.MenuPermissionID) + 1 : 1;
RefreshObject(oNewMenuPermissions, id);
db.MenuPermissions.AddRange(oNewMenuPermissions);
foreach (MenuPermission item in _oMenuPermissions)
{
db.MenuPermissions.Attach(item);
}
db.MenuPermissions.RemoveRange(_oMenuPermissions);
db.SaveChanges();
MessageBox.Show("Data saved successfully.", "Save Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (!IsNew)
{
if (ItemChanged != null)
{
ItemChanged();
}
this.Close();
}
else
{
if (ItemChanged != null)
{
ItemChanged();
}
_MenuPermission = new MenuPermission();
RefreshValue();
}
}
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
MessageBox.Show(ex.Message, "Failed to save", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show(ex.InnerException.Message, "Failed to save", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public AlertBack DeleteMenuPermission([FromBody] MenuPermission model, int id = 0)
{
AlertBack alert = new AlertBack();
menuPermissionService.Delete(model);
alert.status = "success";
alert.message = "Register Successfully";
return(alert);
}
public PartialViewResult Create()
{
MenuPermission model = new MenuPermission();
ViewBag.Menus = new SelectList(_menuService.GetAll().ToArray(), "Id", "MenuText");
ViewBag.Roles = new SelectList(_roleService.GetAll().ToArray(), "Id", "RoleName");
ViewBag.Users = new SelectList(_userService.GetAll().ToArray(), "Id", "UserName");
return(PartialView(model));
}
private void MapObject(MenuPermission oMenuPermission, NullHandler oReader)
{
BusinessObject.Factory.SetID(oMenuPermission, new ID(oReader.GetInt32("UPID")));
oMenuPermission.MenuID = oReader.GetInt32("MenuID");
oMenuPermission.UserID = oReader.GetInt32("user_id");
BusinessObject.Factory.SetObjectState(oMenuPermission, ObjectState.Saved);
}
public PartialViewResult Edit(int id)
{
MenuPermission ObjMenuPermission = _menuPermissionService.Get(id);
ViewBag.Menus = new SelectList(_menuService.GetAll().ToArray(), "Id", "MenuText");
ViewBag.Roles = new SelectList(_roleService.GetAll().ToArray(), "Id", "RoleName");
ViewBag.Users = new SelectList(_userService.GetAll().ToArray(), "Id", "UserName");
return(PartialView(ObjMenuPermission));
}
public ActionResult _AddAccountUsingRole(int idAccount, int idRole)
{
var db = new RoleBusiness();
MenuPermission item = new MenuPermission();
item.RoleId = idRole;
item.UserId = idAccount;
var result = db.AddAccount_Menu_UsingRole(item);
return(Json(new { result }, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(Menu ObjMenu)
{
StringBuilder sb = new StringBuilder();
try
{
if (ModelState.IsValid)
{
db.Menu.Add(ObjMenu);
db.SaveChanges();
var getrole = db.Role.FirstOrDefault(m => m.Level == 12).Id;
if (getrole != null)
{
var checkmenu =
db.MenuPermission.FirstOrDefault(m => m.MenuId == ObjMenu.Id && m.RoleId == getrole);
if (checkmenu == null)
{
MenuPermission mn = new MenuPermission();
mn.MenuId = ObjMenu.Id;
mn.RoleId = getrole;
mn.IsCreate = true;
mn.IsRead = true;
mn.IsDelete = true;
mn.IsUpdate = true;
mn.IsExport = true;
db.MenuPermission.Add(mn);
db.SaveChanges();
}
}
sb.Append("Sumitted");
return(Content(sb.ToString()));
}
else
{
foreach (var key in this.ViewData.ModelState.Keys)
{
foreach (var err in this.ViewData.ModelState[key].Errors)
{
sb.Append(err.ErrorMessage + "<br/>");
}
}
}
}
catch (Exception ex)
{
sb.Append("Error :" + ex.Message);
}
ViewBag.ParentId = new SelectList(db.Menu, "Id", "MenuText", ObjMenu.ParentId);
return(Content(sb.ToString()));
}
public ActionResult SaveRolePrivilege(MenuPermission menuPermission)
{
if (_ICommon.SavePrivilege(menuPermission))
{
return(Json("Success"));
}
else
{
return(Json("error"));
}
}
/// <summary>
/// 更新SysPermission信息
/// </summary>
public void UpdateSysPermission(SysPermission entity)
{
CheckSysPermission(entity, false);
MenuPermission menuPermission = new MenuPermission()
{
MenuSysNo = entity.MenuSysNo,
PermissionSysNo = entity.SysNo
};
MenuPermissionDA.UpdateMenuPermission(menuPermission);
SysPermissionDA.UpdateSysPermission(entity);
}
public SystemMessage AddAccount_Menu_UsingRole(MenuPermission data)
{
SystemMessage systemMessage = new SystemMessage();
try
{
var db = new DB_CSEntities1();
var checkrole = db.Role.FirstOrDefault(m => m.Id == data.RoleId && m.IsActive == true);
if (checkrole == null)
{
systemMessage.IsSuccess = false;
systemMessage.Message = SystemMessageConst.systemmessage.RoleIsNotExist;
return(systemMessage);
}
var checkaccount = db.User.FirstOrDefault(m => m.Id == data.UserId && m.IsActive == true);
if (checkaccount == null)
{
systemMessage.IsSuccess = false;
systemMessage.Message = SystemMessageConst.systemmessage.AccountIsNotExist;
return(systemMessage);
}
var checkroleuser = db.RoleUser.FirstOrDefault(m => m.RoleId == data.RoleId && m.UserId == data.UserId);
if (checkroleuser == null)
{
RoleUser RU = new RoleUser();
RU.RoleId = data.RoleId;
RU.UserId = (string.IsNullOrEmpty(data.UserId.ToString())) ? 0 : data.UserId.Value;
db.RoleUser.Add(RU);
db.SaveChanges();
systemMessage.IsSuccess = true;
systemMessage.Message = SystemMessageConst.systemmessage.AddSuccess;
}
else
{
systemMessage.IsSuccess = true;
systemMessage.Message = SystemMessageConst.systemmessage.RoleAndAccountExit;
}
return(systemMessage);
}
catch (Exception e)
{
systemMessage.IsSuccess = false;
systemMessage.Message = e.ToString();
return(systemMessage);
}
}
public IActionResult Delete(int id)
{
AlertBack alert = new AlertBack();
MenuPermission ObjMenuPermission = _menuPermissionService.Get(id);
_menuPermissionService.Delete(ObjMenuPermission);
alert.Status = "success";
alert.Message = "Register Successfully";
return(Json(alert));
}
partial void InsertMenuPermission(MenuPermission instance) {
int rc;
string errorinfo = null;
rc = this.P_MenuPermission_I(
m_UserContext,
(int?)instance.MenuID,
(int?)instance.PermissionID,
ref errorinfo);
if (rc != 0) {
throw new Exception(errorinfo != String.Empty ? errorinfo : string.Format(UnknownError, rc));
}
}
