public ActionResult SaveRole(Guid?roleId, string roleName, string roleText, string[] functions, string applicationName)
{
bool result;
IRoleInfo roleInfo = null;
if (roleId == null)
{
roleInfo = WebSecurity.CreateRole(roleName, roleText);
result = roleInfo != null;
}
else
{
result = WebSecurity.UpdateRoleText(roleText, roleId.Value);
roleInfo = new SimpleRole(roleId.Value, roleName)
{
RoleText = roleText
};
}
if (result)
{
//更新角色功能列表
if (functions != null && functions.Length > 0)
{
result = WebSecurity.UpdateFunctionsForRole(roleInfo.RoleId, functions);
if (result)
{
//移除当前功能列表的缓存
WebSecurity.RemoveFunctionCache(roleInfo.RoleId);
}
}
}
return(Json(new { Result = result, Data = roleInfo }));
}
/// <summary>添加标准通用角色与相关组织的映射关系</summary>
/// <param name="standardGeneralRoleId">标准通用角色标识</param>
/// <param name="organizationId">组织标识</param>
/// <param name="roleId">角色标识</param>
public int AddMappingRelation(string standardGeneralRoleId, string organizationId, string roleId)
{
if (this.HasMappingRelation(standardGeneralRoleId, organizationId))
{
// 已存在映射关系
return(1);
}
IRoleInfo role = null;
if (string.IsNullOrEmpty(roleId))
{
role = this.CreateNewRole(standardGeneralRoleId, organizationId);
}
else
{
role = MembershipManagement.Instance.RoleService.FindOne(roleId);
}
if (role == null)
{
// 相关角色信息不存在
return(2);
}
return(this.provider.AddMappingRelation(standardGeneralRoleId, organizationId, role.Id, role.StandardRoleId));
}
public async Task <int> RemoveRole(string code)
{
int ret;
using (var scope = this._repo.BeginTransScope())
{
code = Utility.ClearSafeStringParma(code);
IRoleInfo role = await this._repo.GetRole(code);
if (role == null)
{
throw new BizException("角色不存在，请检查后重试");
}
int diff = role.Right - role.Left + 1;
if (diff > 2)
{
throw new BizException("存在子角色不能删除！");
}
await _repo.MinusRolePoint(role.AppCode, role.Right);
//清除用户和角色的关系
await this._repo.RemovRolePrivilegeAsync(code, "");
await this._repo.RemovRoleUserAsync(code, "");
ret = await this._repo.RemoveRole(code);
scope.Complete();
}
return(ret);
}
public List <EmployeeModel> QueryEmployeeInfo(string name, string status, int pageIndex, int pageSize, out int rowCount)
{
using (TeamDBContext context = new TeamDBContext())
{
DatabaseAccess dba = context.DatabaseAccess();
DbCommand cmd = dba.CreateCommand();
StringBuilder sqlBuilder = new StringBuilder("SELECT u.UserName, u.[Enabled], ue.*, e.*, lc.UnitPrice AS PositionUnitPrice, lc.UnitValue AS PositionUnitValue, lc2.UnitPrice AS UserUnitPrice, lc2.UnitValue AS UserUnitValue FROM auth_User u INNER JOIN auth_UserExtend ue ON u.UserId = ue.UserId LEFT JOIN Employee e ON ue.UserId = e.EmployeeId LEFT JOIN LaborCost lc ON ue.Position = lc.TargetId AND lc.TargetType = 1 LEFT JOIN LaborCost lc2 ON u.UserId = lc2.TargetId AND lc2.TargetType = 2 WHERE 1 = 1");
if (!String.IsNullOrEmpty(name))
{
sqlBuilder.Append(" AND ue.RealName LIKE @RealName");
dba.AddInParameter(cmd, "RealName", DbType.String, String.Concat("%", name, "%"));
}
sqlBuilder.Append(" AND ue.Status = @Status");
if (String.IsNullOrEmpty(status))
{
dba.AddInParameter(cmd, "Status", DbType.String, "1-01");
}
else
{
dba.AddInParameter(cmd, "Status", DbType.String, String.Concat("1-0", status));
}
sqlBuilder.Append(" ORDER BY ue.RealName, u.UserName");
cmd.CommandText = sqlBuilder.ToString();
List <EmployeeModel> data = null;
using (DbDataReader reader = dba.ExecuteReaderPaging(cmd, PrepareQueryEmployeeInfoCommand, pageIndex, pageSize, out rowCount))
{
if (reader.HasRows)
{
data = new List <EmployeeModel>(50);
Guid lastUserId = Guid.Empty;
Guid currentUserId;
EmployeeModel employee = null;
while (reader.Read())
{
currentUserId = reader.GetGuidOrNull("UserId").Value;
if (currentUserId != lastUserId)
{
employee = ReadEmployeeInfo <EmployeeQueryModel>(reader);
if (employee.Roles == null)
{
employee.Roles = new List <IRoleInfo>(5);
}
data.Add(employee);
lastUserId = currentUserId;
}
IRoleInfo role = ReadRoleInfo(reader);
if (role != null)
{
employee.Roles.Add(role);
}
}
}
}
return(data);
}
}
public Task <int> UpdateRole(IRoleInfo entity)
{
var data = Map(entity);
data.RemoveUpdateColumn("AppCode");
data.RemoveUpdateColumn("IsSystemRole");
data.RemoveUpdateColumn("ParentCode");
return(base.UpdateAsync(data));
}
// ------------------------------------------------------------------------------------------
// 角色类的函数
// ------------------------------------------------------------------------------------------
/// <summary></summary>
/// <param name="roles"></param>
/// <returns></returns>
public static IRoleInfo[] ToRoleArray(IList <IRoleInfo> roles)
{
IRoleInfo[] roleArray = new IRoleInfo[roles.Count];
for (int index = 0; index < roleArray.Length; index++)
{
roleArray[index] = (IRoleInfo)roles[index];
}
return(roleArray);
}
public async Task <int> SaveRole(IRoleInfo entity, int type)
{
int ret = -1;
using (var scope = this._repo.BeginTransScope())
{
if (type == 1) // 新增
{
if (!entity.RoleCode.StartsWith(entity.AppCode))
{
entity.RoleCode = entity.AppCode + "_" + entity.RoleCode;
}
// 校验
bool result = await this._repo.CheckCode(entity.RoleCode);
if (!result)
{
ret = -1;
}
else
{
if (string.IsNullOrEmpty(entity.ParentCode)) // 根组织
{
entity.Left = 1;
entity.Right = entity.Left + 1;
}
else
{
IRoleInfo pRole = await _repo.GetRole(entity.ParentCode);
if (pRole == null)
{
throw new BizException("父角色不存在，请检查后重新保存");
}
await _repo.UpdateRolePoint(entity.AppCode, pRole.Right);
entity.Left = pRole.Right;
entity.Right = entity.Left + 1;
}
await this._repo.AddRole(entity);
ret = 1;
}
}
else
{
ret = await this._repo.UpdateRole(entity);
}
scope.Complete();
}
return(ret);
}
//#region 属性:HasOrganizationUnit(string accountId, string organizationNames)
///// <summary>
///// 检测用户是否拥有权限
///// </summary>
///// <param name="accountId"></param>
///// <param name="organizationNames"></param>
///// <returns></returns>
//public static bool HasOrganizationUnit(string accountId, string organizationNames)
//{
// return AuthorityContext.Instance.AuthorityService.HasAuthorizationObject(accountId, "OrganizationUnit", organizationNames);
//}
//#endregion
//#region 函数:HasRole(string accountId, string roleNames)
///// <summary>
///// 检测用户是否拥有权限
///// </summary>
///// <param name="accountId"></param>
///// <param name="roleName"></param>
///// <returns></returns>
//public static bool HasRole(string accountId, string roleNames)
//{
// return AuthorityContext.Instance.AuthorityService.HasAuthorizationObject(accountId, "Role", roleNames);
//}
//#endregion
//#region 函数:Check(IAccountInfo account, string[] roleName)
///// <summary>
///// 检测用户是否拥有权限
///// </summary>
///// <param name="account"></param>
///// <param name="authorityKeys"></param>
///// <returns></returns>
//public static bool HasAuthority(string accountId, string authorityNames)
//{
// return AuthorityContext.Instance.AuthorityService.HasAuthorizationObject(accountId, "Authority", authorityNames);
//}
//#endregion
////#region 函数:Check(IAccountInfo account, IRoleInfo[] roles, string[] authorityKeys)
/////// <summary>
/////// 检测用户是否拥有权限
/////// </summary>
/////// <param name="account"></param>
/////// <param name="roles"></param>
/////// <param name="authorityKeys"></param>
/////// <returns></returns>
////public static bool Check(IAccountInfo account, IRoleInfo[] roles, string[] authorityKeys)
////{
// //
// // 1.获取帐号的权限
// //
// // 2.获取的需要的角色范围
// //
// // 3.需要的权限范围
// //
// // 4.需要的权限优先级大于需要的角色的优先级.
// //
//// IList<AuthorityInfo> accountAuthorities = GetAuthorities(account);
//// IList<AuthorityInfo> systemAuthorities = GetUnionAuthorities(GetAuthorities(roles), GetAuthorities(authorityKeys));
//// IList<AuthorityInfo> authorities = GetIntersectionAuthorities(accountAuthorities, systemAuthorities);
//// return authorities.Count > 0 ? true : false;
////}
////#endregion
#region 函数:GetAuthorities(IAccountInfo account)
/// <summary>获取权限列表</summary>
/// <param name="account"></param>
/// <returns></returns>
public static IList <AuthorityInfo> GetAuthorities(IAccountInfo account)
{
IRoleInfo[] roles = new IRoleInfo[account.RoleRelations.Count];
for (int i = 0; i < roles.Length; i++)
{
roles[i] = account.RoleRelations[i].GetRole();
}
return(GetAuthorities(roles));
}
// -------------------------------------------------------
// 保存 添加 修改 删除
// -------------------------------------------------------
#region 函数:Save(IRoleInfo param)
/// <summary>保存记录</summary>
/// <param name="param">IRoleInfo 实例详细信息</param>
/// <returns>IRoleInfo 实例详细信息</returns>
public IRoleInfo Save(IRoleInfo param)
{
if (!this.IsExist(param.Id))
{
this.Insert(param);
}
else
{
this.Update(param);
}
return(param);
}
// -------------------------------------------------------
// 查询
// -------------------------------------------------------
#region 函数:FindOne(XmlDocument doc)
/// <summary>获取详细信息</summary>
/// <param name="doc">Xml 文档对象</param>
/// <returns>返回操作结果</returns>
public string FindOne(XmlDocument doc)
{
StringBuilder outString = new StringBuilder();
string id = XmlHelper.Fetch("id", doc);
IRoleInfo param = this.service.FindOne(id);
outString.Append("{\"data\":" + AjaxUtil.Parse <IRoleInfo>(param) + ",");
outString.Append(MessageObject.Stringify("0", I18n.Strings["msg_query_success"], true) + "}");
return(outString.ToString());
}
protected bool HasRole(IAccountInfo account, IRoleInfo Role)
{
bool success = false;
//// if (grade.IndexOf("[" + member.Grade + "]") > -1) success = true;
//for (int i = 0; i < gradeArray.Length; i++)
//{
// if (gradeArray[i] == member.Grade)
// {
// success = true;
// }
//}
return(success);
}
/// <summary>添加记录</summary>
/// <param name="param">IRoleInfo 实例的详细信息</param>
public void Insert(IRoleInfo param)
{
if (string.IsNullOrEmpty(param.Id))
{
param.Id = DigitalNumberContext.Generate("Key_Guid");
}
if (string.IsNullOrEmpty(param.Code))
{
param.Code = DigitalNumberContext.Generate("Table_Role_Key_Code");
}
this.ibatisMapper.Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_Insert", tableName)), param);
// 绑定关系
// BindRelation(param);
}
private static RoleInfo Map(IRoleInfo source)
{
return(new RoleInfo()
{
AppCode = source.AppCode,
IsSystemRole = source.IsSystemRole,
LastModifyTime = source.LastModifyTime,
LastModifyUserId = source.LastModifyUserId,
LastModifyUserName = source.LastModifyUserName,
ParentCode = source.ParentCode,
Remark = source.Remark,
RoleCode = source.RoleCode,
RoleName = source.RoleName,
Left = source.Left,
Right = source.Right
});
}
/// <summary>����Ĭ�Ͻ�ɫ</summary>
/// <param name="accountId">�ʺű�ʶ</param>
/// <param name="roleId">��ɫ��ʶ</param>
/// <returns>�ijɹ�, ���� 0, ��ʧ��, ���� 1.</returns>
public virtual int SetDefaultRole(string accountId, string roleId)
{
IRoleInfo role = MembershipManagement.Instance.RoleService[roleId];
if (role == null)
{
// δ�ҵ���ɫ��Ϣ��
return(1);
}
// ����Ĭ�Ϲ�˾��������Ϣ��
string organizationIds = string.Empty;
IOrganizationUnitInfo organization = MembershipManagement.Instance.OrganizationUnitService.FindCorporationByOrganizationUnitId(role.OrganizationUnitId);
if (organization == null)
{
// δ�ҵ���ɫ���صĹ�˾��Ϣ��
return(2);
}
organizationIds += organization.Id + ",";
int depth = 1;
organization = MembershipManagement.Instance.OrganizationUnitService.FindOneByRoleId(roleId, depth);
while (organization != null)
{
organizationIds += organization.Id + ",";
depth++;
organization = MembershipManagement.Instance.OrganizationUnitService.FindOneByRoleId(roleId, depth);
}
MembershipManagement.Instance.MemberService.SetDefaultCorporationAndDepartments(accountId, organizationIds);
// ͳһ������ɫ���ݷ������á�
return(MembershipManagement.Instance.RoleService.SetDefaultRelation(accountId, roleId));
}
// -------------------------------------------------------
// 角色
// -------------------------------------------------------
#region 函数:GetRoles(string ids)
/// <summary>获取对应的角色信息</summary>
/// <param name="ids">角色标识，多个以逗号隔开</param>
/// <returns></returns>
public IList <IRoleInfo> GetRoles(string ids)
{
string[] keys = ids.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
IList <IRoleInfo> list = new List <IRoleInfo>();
IRoleInfo item = null;
for (int i = 0; i < keys.Length; i++)
{
item = MembershipManagement.Instance.RoleService[keys[i]];
// 过滤对象为空或者禁用的对象。
if (item != null && item.Status == 1)
{
list.Add(item);
}
}
return(list);
}
/// <summary>同步信息</summary>
/// <param name="param">帐号信息</param>
public int SyncFromPackPage(IAccountInfo param)
{
// 此版本只同步姓名和帐号状态，不同步登录名。
string accountId = param.Id;
this.ibatisMapper.Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_SyncFromPackPage", tableName)), param);
if (param.RoleRelations.Count > 0)
{
// 1.设置默认角色信息
IMemberInfo member = MembershipManagement.Instance.MemberService.FindOne(param.Id);
if (member.Role != null)
{
IRoleInfo defaultRole = MembershipManagement.Instance.RoleService[member.Role.Id];
if (defaultRole != null)
{
MembershipManagement.Instance.RoleService.SetDefaultRelation(accountId, member.Role.Id);
MembershipManagement.Instance.OrganizationUnitService.SetDefaultRelation(accountId, member.Role.OrganizationUnitId);
}
}
// 2.移除非默认角色关系
MembershipManagement.Instance.RoleService.RemoveNondefaultRelation(accountId);
// 3.移除非默认组织关系
MembershipManagement.Instance.OrganizationUnitService.RemoveNondefaultRelation(accountId);
// 4.设置新的关系
foreach (IAccountRoleRelationInfo item in param.RoleRelations)
{
MembershipManagement.Instance.RoleService.AddRelation(accountId, item.RoleId);
// 根据角色设置组织关系
IRoleInfo role = MembershipManagement.Instance.RoleService.FindOne(item.RoleId);
// [容错]如果角色信息为空，中止相关组织设置
if (role == null)
{
continue;
}
if (!string.IsNullOrEmpty(role.OrganizationUnitId))
{
MembershipManagement.Instance.OrganizationUnitService.AddRelation(accountId, role.OrganizationUnitId);
MembershipManagement.Instance.OrganizationUnitService.AddParentRelations(accountId, role.OrganizationUnitId);
}
}
// 5.再次设置默认角色信息
if (member.Role != null)
{
MembershipManagement.Instance.RoleService.SetDefaultRelation(accountId, member.Role.Id);
MembershipManagement.Instance.OrganizationUnitService.SetDefaultRelation(accountId, member.Role.OrganizationUnitId);
}
//
// 设置群组关系
//
// 1.移除群组关系
MembershipManagement.Instance.GroupService.RemoveAllRelation(accountId);
// 2.设置新的关系
foreach (IAccountGroupRelationInfo item in param.GroupRelations)
{
MembershipManagement.Instance.GroupService.AddRelation(accountId, item.GroupId);
}
}
return(0);
}
/// <summary>修改记录</summary>
/// <param name="param">IRoleInfo 实例的详细信息</param>
public void Update(IRoleInfo param)
{
this.ibatisMapper.Update(StringHelper.ToProcedurePrefix(string.Format("{0}_Update", tableName)), param);
}
public Task <long> AddRole(IRoleInfo entity)
{
var data = Map(entity);
return(base.InsertAsync(data));
}
// -------------------------------------------------------
// ���� ɾ��
// -------------------------------------------------------
#region 属性:Save(IMemberInfo param)
/// <summary>������¼</summary>
/// <param name="param">IMemberInfo ʵ����ϸ��Ϣ</param>
/// <returns>IMemberInfo ʵ����ϸ��Ϣ</returns>
public IMemberInfo Save(IMemberInfo param)
{
IMemberInfo originalObject = this.FindOne(param.Id);
if (originalObject == null)
{
originalObject = param;
}
IRoleInfo defaultRole = null;
IAssignedJobInfo defaultAssignedJob = null;
// �����ֶ����� �Զ�������֯��Ϣ
// AutoBindingOrganizationUnitByPrimaryKey : None | RoleId | AssignedJobId
if (MembershipConfigurationView.Instance.AutoBindingOrganizationUnitByPrimaryKey == "RoleId" && !string.IsNullOrEmpty(param.RoleId))
{
defaultRole = MembershipManagement.Instance.RoleService[param.RoleId];
param.OrganizationUnitId = defaultRole.OrganizationUnitId;
this.SetDefaultOrganizationUnit(param.Account.Id, param.OrganizationUnitId);
this.SetDefaultCorporationAndDepartmentsByOrganizationUnitId(param.Account.Id, param.OrganizationUnitId);
}
else if (MembershipConfigurationView.Instance.AutoBindingOrganizationUnitByPrimaryKey == "AssignedJobId" && !string.IsNullOrEmpty(param.AssignedJobId))
{
defaultAssignedJob = MembershipManagement.Instance.AssignedJobService[param.AssignedJobId];
if (defaultAssignedJob != null)
{
param.OrganizationUnitId = defaultAssignedJob.OrganizationUnitId;
this.SetDefaultOrganizationUnit(param.Account.Id, param.OrganizationUnitId);
this.SetDefaultCorporationAndDepartmentsByOrganizationUnitId(param.Account.Id, param.OrganizationUnitId);
}
}
else if (MembershipConfigurationView.Instance.AutoBindingOrganizationUnitByPrimaryKey == "Self" && !string.IsNullOrEmpty(param.OrganizationUnitId))
{
// �����ֶ�����������֯��Ϣ
this.SetDefaultOrganizationUnit(param.Account.Id, param.OrganizationUnitId);
this.SetDefaultCorporationAndDepartmentsByOrganizationUnitId(param.Account.Id, param.OrganizationUnitId);
}
// ���ݸ�λ���� �Զ�����ְλ��Ϣ
if (MembershipConfigurationView.Instance.AutoBindingJobByPrimaryKey == "AssignedJobId" && !string.IsNullOrEmpty(param.AssignedJobId))
{
if (defaultAssignedJob == null)
{
defaultAssignedJob = MembershipManagement.Instance.AssignedJobService[param.AssignedJobId];
}
if (defaultAssignedJob != null)
{
this.SetDefaultJob(param.Account.Id, defaultAssignedJob.JobId);
}
}
else if (MembershipConfigurationView.Instance.AutoBindingJobByPrimaryKey == "Self" && !string.IsNullOrEmpty(param.JobId))
{
// ����������������ְλ��Ϣ
this.SetDefaultJob(param.Account.Id, param.JobId);
}
// ���ݸ�λ���� �Զ�����ְ����Ϣ
if (MembershipConfigurationView.Instance.AutoBindingJobGradeByPrimaryKey == "AssignedJobId" && !string.IsNullOrEmpty(param.AssignedJobId))
{
if (defaultAssignedJob == null)
{
defaultAssignedJob = MembershipManagement.Instance.AssignedJobService[param.AssignedJobId];
}
if (defaultAssignedJob != null)
{
this.SetDefaultJobGrade(param.Account.Id, defaultAssignedJob.JobGradeId);
}
}
else if (MembershipConfigurationView.Instance.AutoBindingJobGradeByPrimaryKey == "Self" && !string.IsNullOrEmpty(param.JobGradeId))
{
// ����Ĭ����������ְ����Ϣ
this.SetDefaultJobGrade(param.Account.Id, param.JobGradeId);
}
// ������֯ȫ·��
param.FullPath = CombineFullPath(param.Account.Name, param.OrganizationUnitId);
param = provider.Save(param);
// 1.������չ��Ϣ
if (param.ExtensionInformation != null)
{
param.ExtensionInformation.Save();
}
// 2.����Ĭ�Ͻ�ɫ��Ϣ
if (param.Role != null)
{
MembershipManagement.Instance.RoleService.SetDefaultRelation(param.Account.Id, param.Role.Id);
}
// 3.����Ĭ�ϸ�λ��Ϣ
if (param.AssignedJob != null)
{
MembershipManagement.Instance.AssignedJobService.RemoveDefaultRelation(param.Account.Id);
MembershipManagement.Instance.AssignedJobService.SetDefaultRelation(param.Account.Id, param.AssignedJob.Id);
}
// 4.���ü�ְ��Ϣ
if (param.PartTimeJobs.Count > 0)
{
this.BindPartTimeJobs(param);
}
else if (param.PartTimeJobs.Count == 0 && originalObject.PartTimeJobs.Count > 0)
{
// �Ƴ���Ĭ�ϸ�λ��ϵ
MembershipManagement.Instance.AssignedJobService.RemoveNondefaultRelation(param.Account.Id);
}
return(param);
}
/// <summary>同步信息</summary>
/// <param name="param">角色信息</param>
public int SyncFromPackPage(IRoleInfo param)
{
this.ibatisMapper.Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_SyncFromPackPage", tableName)), param);
return(0);
}
