private CTMS_SYS_ROLEFUNCTION ModelToEntity(RoleFunction model)
{
if (model == null)
{
return(null);
}
return(new CTMS_SYS_ROLEFUNCTION()
{
ROLEFUNCTIONID = string.IsNullOrEmpty(model.RoleFunctionID) ? Guid.NewGuid().ToString() : model.RoleFunctionID,
FUNCTIONID = model.FunctionID,
PERMISSIONVALUE = model.PermissionValue,
ROLEID = model.RoleID,
REMARK = model.Remark,
DATARANGE = model.DataRange,
CREATEDATETIME = model.CreateDateTime,
CREATEUSERID = model.CreateUserID,
CREATEUSERNAME = model.CreateUserName,
EDITDATETIME = model.EditTime,
EDITUSERID = model.EditUserID,
EDITUSERNAME = model.EditUserName,
OWNERID = model.OwnerID,
OWNERNAME = model.OwnerName,
ISDELETED = model.IsDeleted
});
}
//Refresh datagridview in function tab
private void refreshDataViewFunction()
{
try
{
// Get function's datatable
DataTable functionTable = RoleFunction.GetListFunction();
// Add Vietnamese column's name
functionTable.Columns.Add("Mã chức năng", typeof(string), "[FUNCTIONID]");
functionTable.Columns.Add("Tên chức năng", typeof(string), "[FUNCTIONNAME]");
functionTable.Columns.Add("Nút kích hoạt", typeof(string), "[BUTTON]");
// Set data source to dataview for searching
dataViewFunction.DataSource = functionTable.DefaultView;
// Hide English columns'name
for (int i = 0; i < 3; i++)
{
dataViewFunction.Columns[i].Visible = false;
}
//Add auto complete datasource to textbox
textBoxFunctionSearch.AutoCompleteCustomSource.Clear();
for (int i = 0; i < functionTable.Rows.Count; i++)
{
String strFunctionName = functionTable.Rows[i][1].ToString();
textBoxFunctionSearch.AutoCompleteCustomSource.Add(strFunctionName);
}
}
catch
{
MessageBox.Show("Lỗi dữ liệu", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void FunctionItem(dynamic jsonResult, string roleId, string functionParent)
{
for (int i = 0; i < jsonResult.Count; i++)
{
string Id = Public.GetID2();
int id = jsonResult[i]["id"];
if (id != 0)
{
RoleFunction model = new RoleFunction();
model.Id = Id;
model.CategoryId = id;
model.RoleId = roleId;
model.Location = (i + 1);
model.FunctionParent = functionParent;
model.DatePublish = DateTime.Now;
model.UserId = int.Parse(Session["Ad_Id"].ToString());
db.RoleFunctions.Add(model);
}
dynamic children = jsonResult[i]["children"];
if (children != null)
{
FunctionItem(children, roleId, Id);
}
}
db.SaveChanges();
TempData["success"] = "Thêm thành công.";
}
public void RoleFunctionAdd(HttpContext context)
{
int RoleId = 0;
string FunctionArray = "";
if (!string.IsNullOrEmpty(GetParam("RoleId", context).ToString()))
{
RoleId = Convert.ToInt32(GetParam("RoleId", context).ToString());
}
if (!string.IsNullOrEmpty(GetParam("FunctionArray", context).ToString()))
{
FunctionArray = GetParam("FunctionArray", context).ToString();
}
string objOrder = GetParam("RoleFunctionModel", context);
RoleFunction roleFunction = JsonConvert.DeserializeObject <RoleFunction>(objOrder);
RoleFunctionBLL roleFunctionbll = new RoleFunctionBLL();
int result = 0;
if (RoleId != 0)
{
if (RoleId > 0)
{
result = roleFunctionbll.UpdateRoleFun(RoleId, FunctionArray) ? 1 : 0;
}
}
context.Response.Write(result);
}
public ActionResult GetRolePermission(string id)
{
//Role r = irole.GetByKey(id);
List <string> fids = RoleFunction.Entity().Where(p => p.RoleId.Equals(id)).Select(p => p.FunctionID).ToList();
return(Json(new { r = fids }));
}
public ActionResult Role(ModelRoleFunction model)
{
if (ModelState.IsValid)
{
var _News = new RoleFunction();
_News.UserName = model.UserName;
_News.NameFunction = "Tin tức";
_News.CodeFunction = "TINTUC";
_News.ActionEdit = model.FunctionEditNews;
_News.ActionAdd = model.FunctionAddNews;
_News.ActionDelete = model.FunctionDeleteNews;
_News.ActionAdmin = model.FunctionAdminNews;
_News.Id = model.IdNews;
_services.Add(_News);
var _Document = new RoleFunction();
_Document.UserName = model.UserName;
_Document.NameFunction = "Văn bản";
_Document.CodeFunction = "DOCUMENT";
_Document.ActionEdit = model.FunctionEditDocument;
_Document.ActionAdd = model.FunctionAddDocument;
_Document.ActionDelete = model.FunctionDeleteDocument;
_Document.ActionAdmin = model.FunctionAdminDocument;
_Document.Id = model.IdDocument;
_services.Add(_Document);
var _Calnedar = new RoleFunction();
_Calnedar.UserName = model.UserName;
_Calnedar.NameFunction = "Lịch công tác";
_Calnedar.CodeFunction = "CALENDAR";
_Calnedar.ActionEdit = model.FunctionEditCalendar;
_Calnedar.ActionAdd = model.FunctionAddCalendar;
_Calnedar.ActionDelete = model.FunctionDeleteCalendar;
_Calnedar.ActionAdmin = model.FunctionAdminCalendar;
_Calnedar.Id = model.IdCalendar;
_services.Add(_Calnedar);
var _Media = new RoleFunction();
_Media.UserName = model.UserName;
_Media.NameFunction = "Media";
_Media.CodeFunction = "MEDIA";
_Media.ActionEdit = model.FunctionEditMedia;
_Media.ActionAdd = model.FunctionAddMedia;
_Media.ActionDelete = model.FunctionDeleteMedia;
_Media.ActionAdmin = model.FunctionAdminMedia;
_Media.Id = model.IdMedia;
_services.Add(_Media);
var _Trained = new RoleFunction();
_Trained.UserName = model.UserName;
_Trained.NameFunction = "Đào tạo";
_Trained.CodeFunction = "TRAINED";
_Trained.ActionEdit = model.FunctionEditTrained;
_Trained.ActionAdd = model.FunctionAddTrained;
_Trained.ActionDelete = model.FunctionDeleteTrained;
_Trained.ActionAdmin = model.FunctionAdminTrained;
_Trained.Id = model.IdTrained;
_services.Add(_Trained);
}
return(View(model));
}
public void UpdateSystemRole(RoleInfo_Update roleInfo)
{
using (var biz = new GameBizAuthBusinessManagement())
{
biz.BeginTran();
using (var roleManager = new RoleManager())
{
var role = roleManager.GetRoleById(roleInfo.RoleId);
if (role == null)
{
throw new ArgumentException("指定编号的角色不存在 - " + roleInfo.RoleId);
}
role.RoleId = roleInfo.RoleId;
role.RoleName = roleInfo.RoleName;
roleManager.UpdateRole(role);
foreach (var item in roleInfo.AddFunctionList)
{
var roleFunction = roleManager.GetRoleFunction(role, item.FunctionId);
if (roleFunction != null)
{
throw new ArgumentException("添加权限到角色错误 - 已经包含权限\"" + roleFunction.Function.FunctionId + " - " + roleFunction.Function.DisplayName + "\"");
}
roleFunction = new RoleFunction
{
Role = role,
FunctionId = item.FunctionId,
Function = roleManager.LoadFunctionById(item.FunctionId),
Status = EnableStatus.Enable,
Mode = item.Mode,
};
roleManager.AddRoleFunction(roleFunction);
}
foreach (var item in roleInfo.ModifyFunctionList)
{
var roleFunction = roleManager.GetRoleFunction(role, item.FunctionId);
if (roleFunction == null)
{
throw new ArgumentException("修改权限错误 - 此角色尚未包含权限\"" + roleFunction.Function.FunctionId + " - " + roleFunction.Function.DisplayName + "\"");
}
roleFunction.Mode = item.Mode;
roleManager.UpdateRoleFunction(roleFunction);
}
foreach (var item in roleInfo.RemoveFunctionList)
{
var roleFunction = roleManager.GetRoleFunction(role, item.FunctionId);
if (roleFunction == null)
{
throw new ArgumentException("移除权限错误 - 此角色尚未包含权限\"" + roleFunction.Function.FunctionId + " - " + roleFunction.Function.DisplayName + "\"");
}
roleManager.DeleteRoleFunction(roleFunction);
}
}
biz.CommitTran();
}
}
public FormRoleFunctionDetail(RoleFunction function, String usertAction)
{
InitializeComponent();
this.Function = function;
this.UserAction = usertAction;
if (UserAction == "edit")
{
SetRoleFunctionDetail(function);
}
}
public void AddSystemRole(RoleInfo_Add roleInfo)
{
using (var biz = new GameBizAuthBusinessManagement())
{
biz.BeginTran();
using (var roleManager = new RoleManager())
{
var role = roleManager.GetRoleById(roleInfo.RoleId);
if (role != null)
{
throw new ArgumentException("指定编号的角色已经存在 - " + role.RoleId);
}
role = new SystemRole
{
RoleId = roleInfo.RoleId,
RoleName = roleInfo.RoleName,
IsAdmin = roleInfo.IsAdmin,
IsInner = false,
RoleType = roleInfo.RoleType,
FunctionList = new List <RoleFunction>(),
};
if (!role.IsAdmin)
{
foreach (var item in roleInfo.FunctionList)
{
var roleFunction = new RoleFunction
{
Role = role,
FunctionId = item.FunctionId,
Function = roleManager.LoadFunctionById(item.FunctionId),
Status = EnableStatus.Enable,
Mode = item.Mode,
};
role.FunctionList.Add(roleFunction);
}
var list = roleManager.QueryFixFunctionList(roleInfo.RoleType);
foreach (var item in list)
{
var roleFunction = new RoleFunction
{
Role = role,
FunctionId = item.FunctionId,
Function = item,
Status = EnableStatus.Enable,
Mode = "RW",
};
role.FunctionList.Add(roleFunction);
}
}
roleManager.AddRole(role);
}
biz.CommitTran();
}
}
private void buttonFunctionEdit_Click(object sender, EventArgs e)
{
if (dataViewFunction.SelectedRows.Count > 0)
{
int funtionlID = Convert.ToInt16(dataViewFunction.SelectedRows[0].Cells[0].Value);
RoleFunction updateFunction = RoleFunction.GetFunction(funtionlID);
FormRoleFunctionDetail formRFD = new FormRoleFunctionDetail(updateFunction, "edit");
formRFD.ShowDialog();
refreshDataViewFunction();
}
}
public bool checkAdmin()
{
_RoleCurent = _Roleservices.GetByUserNameCode(User.Identity.Name, "TINTUC");
if (_RoleCurent != null && _RoleCurent.ActionAdmin)
{
return(true);
}
else
{
return(false);
}
}
public FormRoleDetail()
{
InitializeComponent();
DataTable dtSystemFunction = RoleFunction.GetListFunction();
for (int i = 0; i < dtSystemFunction.Rows.Count; i++)
{
RoleFunction tempRF = new RoleFunction(int.Parse(dtSystemFunction.Rows[i][0].ToString()), dtSystemFunction.Rows[i][1].ToString(), dtSystemFunction.Rows[i][2].ToString());
listBoxSystemFunction.Items.Add(tempRF.FucntionName);
listBoxSystemFunctionID.Items.Add(tempRF.FunctionID);
}
}
public JsonResult In(string uname, string pword)
{
OperationResult r = new OperationResult();
if (uname.IsNullOrEmpty() || pword.IsNullOrEmpty())
{
r.Message = "用户名和密码不能为空";
r.ResultType = OperationResultType.ValidError;
}
else
{
if (uname.Equals("SuperRole") && pword.Equals("123456"))
{
r.ResultType = OperationResultType.Success;
UserHelper.SetSigninUser(ConfigHelper.SuperRole, "超级管理员", new List <string>()
{
ConfigHelper.SuperRole.ToString()
}, new List <string>());
return(Json(r));
}
string MD5Pword = Zhongyu.Common.EncryptHelper.MD5Encrypt(pword, 32);
LoginUser user = DapperService.SqlHelp.UserLogin(uname, MD5Pword);
if (user == null)
{
r.Message = "用户名或密码错误";
r.ResultType = OperationResultType.Error;
}
else
{
List <string> role = new List <string>();
r.ResultType = OperationResultType.Success;
DapperService.SqlHelp.GetUserRoles().Where(p1 => p1.UserId.Equals(user.Id)).ToList()
.ForEach(p => { role.Add(p.RoleId); });
string[] rolesArry = role.ToArray();
// string rolesString = rolesArry.ToString();
List <string> menus = RoleFunction.Entity()
.Where(p => rolesArry.Contains(p.RoleId))
.Select(p => p.FunctionID).ToList();
HashSet <string> hs = new HashSet <string>(menus);
var tt = RoleFunction.Entity();
var tt1 = RoleFunction.Entity().Where(p => rolesArry.Contains(p.RoleId));
UserHelper.SetSigninUser(user.Id, user.Name, role, hs.ToList());
}
}
return(Json(r));
}
/// <summary>
/// 修改角色功能权限
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Edit(RoleFunction model)
{
if (string.IsNullOrEmpty(model.RoleFunctionID))
{
LogService.WriteInfoLog(logTitle, "试图修改为空的RoleFunction实体!");
throw new KeyNotFoundException();
}
using (DbContext db = new CRDatabase())
{
db.Entry(ModelToEntity(model)).State = EntityState.Modified;
return(db.SaveChanges() > 0);
}
}
public JsonResult Deactivate_Api(RoleFunction role)
{
RoleFunction roleEdit = db.RoleFunction.Where(b => b.RoleId == role.RoleId).FirstOrDefault();
roleEdit.IsDelete = true;
if (db.SaveChanges() == 1)
{
return(Json(1, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(0, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// 新增角色功能权限
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public string Add(RoleFunction model)
{
if (model == null)
{
return(string.Empty);
}
using (DbContext db = new CRDatabase())
{
model.RoleFunctionID = Guid.NewGuid().ToString();
db.Set <CTMS_SYS_ROLEFUNCTION>().Add(ModelToEntity(model));
db.SaveChanges();
return(model.RoleFunctionID);
}
}
/// <summary>
/// 删除角色功能权限
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Delete(string id)
{
if (string.IsNullOrEmpty(id))
{
LogService.WriteInfoLog(logTitle, "试图删除为空的RoleFunction实体!");
throw new KeyNotFoundException();
}
RoleFunction model = Get(id);
if (model != null)
{
model.IsDeleted = true;
return(Edit(model));
}
return(false);
}
public JsonResult Create_Api(RoleFunction role)
{
try
{
db.RoleFunction.Add(role);
if (db.SaveChanges() == 1)
{
return(Json(1, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(0, JsonRequestBehavior.AllowGet));
}
}
catch (Exception e)
{
return(Json(e.Message, JsonRequestBehavior.AllowGet));
}
}
public ActionResult SetPermission(FormCollection coll)
{
OperationResult r = new OperationResult();
RoleFunctionDto model = new RoleFunctionDto();
try
{
model.RoleId = coll["role"].ToString().Split(',')[0].CastTo <Guid>().ToString();
model.FunctionID = coll["function"] == null ? "" : coll["function"].ToString();
RoleFunction.insert(model);
r.ResultType = OperationResultType.Success;
}
catch
{
r.Message = "新增失败，请检查所填数据是否正确。";
r.ResultType = OperationResultType.Error;
}
return(Json(r));
}
/// <summary>
/// 添加角色功能
/// </summary>
/// <param name="roleID"></param>
/// <param name="funIDs"></param>
/// <returns></returns>
public bool AddRoleFuns(int roleID, string[] funIDs)
{
try
{
var list = new List <RoleFunction>();
foreach (string funID in funIDs)
{
RoleFunction rf = new RoleFunction();
rf.RF_RoleID = roleID;
rf.RF_FunID = funID;
list.Add(rf);
}
_dataContext.RoleFunctions.InsertAllOnSubmit(list);
_dataContext.SubmitChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
private void InitRoleFunctions(RoleModule roleModule)
{
foreach (var function in roleModule.Module.Functions)
{
var roleFunctions = roleModule.RoleFunctions.Where(rf => rf.Function.FunctionID == function.FunctionID);
if (roleFunctions.Count() == 0)
{
RoleFunction rf = new RoleFunction()
{
RoleFunctionID = Guid.NewGuid(),
RoleModule = roleModule,
Function = function,
IsActive = false
};
roleModule.RoleSystem.IsActive = false;
SetParentRoleModuleIsActiveFalse(roleModule);
roleModule.IsActive = false;
RoleFunctionRepository.Add(rf);
RoleFunctionRepository.SaveChanges();
}
}
}
public async Task SaveRoleAuthAsync(long RoleId, long FunctionId, bool hasAuth)
{
using (var dapper = DapperFactory.Create())
{
var model = await dapper.QueryOneAsync <RoleFunction>(where : new { RoleId, FunctionId });
if (hasAuth)
{
if (model == null)
{
model = new RoleFunction();
model.RoleId = RoleId;
model.FunctionId = FunctionId;
await dapper.InsertAsync <RoleFunction>(model);
}
}
else if (model != null)
{
await dapper.DeleteAsync <RoleFunction>(where : new { RoleId, FunctionId });
}
}
}
public void SetRoleDetail(Role roledetail)
{
this.roleDetail = roledetail;
textBoxRoleID.Text = roleDetail.RoleID.ToString();
textBoxRoleName.Text = roleDetail.RoleName;
DataTable dtCurrentFunction = RoleDetail.GetListStaffFunction(roledetail.RoleID);
for (int i = 0; i < dtCurrentFunction.Rows.Count; i++)
{
RoleFunction tempRF = new RoleFunction(int.Parse(dtCurrentFunction.Rows[i][0].ToString()), dtCurrentFunction.Rows[i][1].ToString(), "");
listBoxCurrentFunction.Items.Add(tempRF.FucntionName);
listBoxCurrentFunctionID.Items.Add(tempRF.FunctionID);
}
DataTable dtSystemFunction = RoleFunction.GetListFunction();
for (int i = 0; i < dtSystemFunction.Rows.Count; i++)
{
RoleFunction tempRF = new RoleFunction(int.Parse(dtSystemFunction.Rows[i][0].ToString()), dtSystemFunction.Rows[i][1].ToString(), dtSystemFunction.Rows[i][2].ToString());
listBoxSystemFunction.Items.Add(tempRF.FucntionName);
listBoxSystemFunctionID.Items.Add(tempRF.FunctionID);
}
ListBox lstTemp = new ListBox();
for (int i = 0; i < listBoxCurrentFunctionID.Items.Count; i++)
{
for (int j = 0; j < listBoxSystemFunctionID.Items.Count; j++)
{
if (listBoxCurrentFunctionID.Items[i].ToString() == listBoxSystemFunctionID.Items[j].ToString())
{
listBoxSystemFunctionID.Items.RemoveAt(j);
listBoxSystemFunction.Items.RemoveAt(j);
break;
}
}
}
}
private void buttonOk_Click(object sender, EventArgs e)
{
if (!superValidator1.Validate())
{
return;
}
try
{
if (UserAction == "edit")
{
Function.FucntionName = textBoxFunctionName.Text;
Function.Button = textBoxButton.Text;
DialogResult dialogResult = MessageBox.Show("Xác nhận cập nhập thông tin chức năng này không", "Thông báo", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dialogResult == DialogResult.Yes)
{
if (RoleFunction.UpdateFunction(Function) > 0)
{
MessageBox.Show("Cập nhập chức năng thành công", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
else
{
RoleFunction newFunction = new RoleFunction(0, textBoxFunctionName.Text, textBoxButton.Text);
if (RoleFunction.InsertFunction(newFunction) > 0)
{
MessageBox.Show("Thêm chức năng thành công", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
catch
{
MessageBox.Show("Lỗi dữ liệu", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
this.Close();
}
public void InsertRoleActions()
{
var actions = Context.Query <Function>().ToList();
var roles = Context.Query <Role>().ToList();
var roleActions = new List <RoleFunction>();
var rd = new Random(DateTime.Now.Millisecond);
var flag = true;
foreach (var role in roles)
{
foreach (var function in actions)
{
if (role.Code != "Admin")
{
flag = true;
}
else
{
var i = rd.Next(100);
flag = i > 80;
}
if (flag)
{
var rf = new RoleFunction()
{
Id = Guid.NewGuid(), FunctionId = function.Id, RoleId = role.Id
};
roleActions.Add(rf);
}
}
}
var row = Context.Insert <RoleFunction>(roleActions);
Console.WriteLine(row);
}
public void TestMethod1()
{
//
// TODO: Add test logic here
//
UnitOfWork unitOfWork = new UnitOfWork();
IRoleFunctionRepository repository = RepositoryFactory.GetRepository<IRoleFunctionRepository, RoleFunction>(unitOfWork);
RoleFunctionKey key = new RoleFunctionKey();
key.Function = new Function(2);
key.Role = new Role(5);
RoleFunction rolefunction = new RoleFunction(key);
rolefunction.Status = RoleFunctionStatus.Normal;
rolefunction.Description = "this is description";
repository.Add(rolefunction);
unitOfWork.Commit();
//IList<RoleFunction> rolefunctions = repository.FindAll();
//int rolesize = rolefunctions.Count;
//Console.Read();
//Console.WriteLine(rolefunctions.Count);
//Console.Read();
}
private void buttonFunctionDelete_Click(object sender, EventArgs e)
{
if (dataViewFunction.SelectedRows.Count > 0)
{
int funtionlID = Convert.ToInt16(dataViewFunction.SelectedRows[0].Cells[0].Value);
DialogResult dialogResult = MessageBox.Show("Xác nhận xóa chức năng", "Thông báo", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (dialogResult == DialogResult.Yes)
{
try
{
if (RoleFunction.DeleteFunction(funtionlID) > 0)
{
MessageBox.Show("Xóa chức năng thành công", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
catch
{
MessageBox.Show("Chức năng này đang được sử dụng", "Lỗi dữ liệu", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
refreshDataViewFunction();
}
}
public JsonResult UpdateFunctions(int id, string functions)
{
Role role = this.repository.FindBy(id);
if (role == null)
{
return Json(new { success = false, message = "角色不能为空!" });
}
if (functions == null)
{
return Json(new { success = false, message = "请检查参数是否正确！" });
}
JavaScriptSerializer serializer = new JavaScriptSerializer();
IList<int> functionids = serializer.Deserialize<IList<int>>(functions);
IRoleFunctionRepository rolefunctionRepository = RepositoryFactory.GetRepository<IRoleFunctionRepository, RoleFunction>(this.unitOfWork);
IFunctionRepository functionRepository = RepositoryFactory.GetRepository<IFunctionRepository, Function>();
HashSet<Function> existFunctions = functionRepository.FindByRole(role);
foreach (var n in functionids)
{
Function function = functionRepository.FindBy(n);
if (function == null)
continue;
RoleFunction roleFunction = rolefunctionRepository.FindBy(new RoleFunctionKey() { Function = function, Role = role });
if (roleFunction == null)
{
roleFunction = new RoleFunction(new RoleFunctionKey() { Function = function, Role = role });
rolefunctionRepository.Add(roleFunction);
}
else
{
existFunctions.Remove(function);
}
}
foreach (var d in existFunctions)
{
RoleFunction roleFunction = new RoleFunction(new RoleFunctionKey() { Function = d, Role = role });
rolefunctionRepository.Remove(roleFunction);
}
this.unitOfWork.Commit();
return Json(new { success = true, message = "成功更新角色的信息！" }, JsonRequestBehavior.AllowGet);
}
public void DeleteRoleFunction(RoleFunction roleFunction)
{
Delete <RoleFunction>(roleFunction);
}
public void UpdateRoleFunction(RoleFunction roleFunction)
{
Update <RoleFunction>(roleFunction);
}
public void AddRoleFunction(RoleFunction roleFunction)
{
Add <RoleFunction>(roleFunction);
}
private void SetRoleFunctionDetail(RoleFunction function)
{
textBoxFunctionID.Text = function.FunctionID.ToString();
textBoxFunctionName.Text = function.FucntionName;
textBoxButton.Text = function.Button;
}
