/// <summary>
/// 修改菜单
/// </summary>
/// <param name="currentUser"></param>
/// <param name="incrementMenu"></param>
/// <returns></returns>
public async Task <BaseResponseModel> UpdateMenuAsync(UserCacheBo currentUser, IncrementMenuParam incrementMenu)
{
var responseModel = new ResponseModel <bool>();
var count = await SysMenuDao.UpdateMenuAsync(currentUser, incrementMenu);
return(count ? responseModel.Succeed(true) : responseModel.Fail(ResponseCode.Fail, "修改失败"));
}
/// <summary>
/// 更新按钮
/// </summary>
/// <param name="currentUser"></param>
/// <param name="incrementMenu"></param>
/// <returns></returns>
public async Task <bool> UpdateMenuAsync(UserCacheBo currentUser, IncrementMenuParam incrementMenu)
{
var count = await CurrentDbContext.SysMenus.Where(c => c.MenuId == incrementMenu.MenuId).UpdateFromQueryAsync(c => new SysMenu()
{
Deleted = incrementMenu.Deleted,
MenuName = incrementMenu.MenuName,
OrderIndex = incrementMenu.OrderIndex,
Icon = incrementMenu.Icon,
Url = incrementMenu.Url,
UpdatedBy = currentUser.UserId,
UpdatedTime = DateTime.Now,
});
return(count > 0);
//var menu = await FindAsync<SysMenu>(incrementMenu.MenuId);
//if (menu != null)
//{
// menu.Deleted = incrementMenu.Deleted;
// menu.MenuName = incrementMenu.MenuName;
// menu.OrderIndex = incrementMenu.OrderIndex;
// menu.Icon = incrementMenu.Icon;
// menu.Url = incrementMenu.Url;
// menu.UpdatedBy = currentUser.UserId;
// menu.UpdatedTime = DateTime.Now;
// Update(menu);
//}
//return await SaveChangesAsync() > 0;
}
/// <summary>
/// 创建缓存
/// </summary>
/// <param name="userCache"></param>
public static void CreateUserCache(UserCacheBo userCache)
{
// 直接以用户id作为缓存key -- 单点登录
// 若想一个账号多点登录的，可以换一种方式-如guid等
var sid = userCache.UserId.ToString();
var key = FormatPrefixKey(sid);
userCache.LoginIp = LionWeb.GetClientIp();
userCache.LoginTime = DateTime.Now;
var redisClient = LionWeb.AutofacContainer.Resolve <RedisClient>();
redisClient.Set(key, userCache, RedisTimeout);
AddToMemoryCache(key, userCache);
LionWeb.HttpContext.Items["user"] = userCache;
//UserCacheBo oldCache = Get(sid,false);
//UserCacheBo cache = oldCache;
////如果是同一用户,仅更新时间 单点登录
//if (oldCache?.LoginIp != userCache.LoginIp || oldCache?.UserToken != userCache.UserToken || oldCache?.PassWord != userCache.PassWord)
//{
// DeleteCache(sid);
// oldCache = null;
//}
//if (oldCache == null)
//{
// cache = userCache;
// var redisClient = LionWeb.AutofacContainer.Resolve<RedisClient>();
// redisClient.Set(key, cache, RedisTimeout);
// AddToMemoryCache(key, cache);
//}
}
/// <summary>
/// 获取当前角色能访问的按钮
/// </summary>
/// <param name="roleId"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <BaseResponseModel> GetRoleMenuAsync(long roleId, UserCacheBo currentUser)
{
var menus = await SysMenuDao.GetMenusAsync(roleId, currentUser.TenantId);
var result = MenuBll.GetMenuList(menus);
return(new ResponseModel().Succeed(result));
}
/// <summary>
/// 获取菜单对象
/// </summary>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <List <MenuPermsDto> > GetCurrentMenuTreeAsync(UserCacheBo currentUser)
{
var currentMenus = await GetCurrentMenuAsync(currentUser);
var cacheMenus = GetMenus(currentMenus);
return(cacheMenus.MapToList <MenuPermsDto>());
}
/// <summary>
/// 获取当前用户的权限菜单树 - 按钮放置于页面下
/// </summary>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <List <MenuPermsDto> > GetCurrentMenuListAsync(UserCacheBo currentUser)
{
var cacheMenus = await GetCurrentMenuAsync(currentUser);
var permsDto = cacheMenus.MapToList <MenuPermsDto>();
var resultMenus = GetMenuList(permsDto);
return(resultMenus);
}
/// <summary>
/// 登出 -- 注销当前信息
/// </summary>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task LogoutAsync(UserCacheBo currentUser)
{
await RedisClient.DeleteAsync(CacheKeys.USER + currentUser.UserId);
await RedisClient.DeleteAsync(CacheKeys.MENU_TREE + currentUser.UserId);
LionMemoryCache.Remove(CacheKeys.USER + currentUser.UserId);
LionMemoryCache.Remove(CacheKeys.MENU_TREE + currentUser.UserId);
}
/// <summary>
/// 检查角色是否可操作
/// </summary>
/// <param name="roleIds"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <string> CheckRoleIds(List <long> roleIds, UserCacheBo currentUser)
{
var userRoles = await SysUserDao.CurrentDbContext.SysUserRoleRelations.Where(c => c.TenantId == currentUser.TenantId && !c.Deleted && roleIds.Contains(c.RoleId) && c.State == 1).ToListAsync();
if (userRoles.Any(c => c.CreatedBy <= 0))
{
return("系统角色只读");
}
if (userRoles.Any(c => currentUser.RoleIdList.Contains(c.RoleId)))
{
return("自身角色不可操作");
}
return("");
}
/// <summary>
/// 校验当前角色是否能操作
/// </summary>
/// <param name="roleId"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
private async Task <string> RoleIdCheckAsync(long roleId, UserCacheBo currentUser)
{
var role = await SysRoleDao.FirstAsync <SysRole>(c => c.RoleId == roleId && c.TenantId == currentUser.TenantId && !c.Deleted);
if (currentUser.RoleIdList.Contains(roleId))
{
return("当前角色不可操作");
}
if (role == null)
{
return("角色不存在");
}
if (role.CreatedBy <= 0)
{
return("系统角色只读");
}
return("");
}
/// <summary>
/// 获取当前用户的原始权限 并设置缓存
/// </summary>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <List <MenuCacheBo> > GetCurrentMenuAsync(UserCacheBo currentUser)
{
var menuKey = $"{CacheKeys.MENU_TREE}{currentUser.UserId}";
var cacheMenus = await GetMenuTreeCacheAsync(menuKey);
if (cacheMenus != null)
{
return(cacheMenus);
}
//从数据库中获取菜单树 由于菜单不经常变化故设置redis存储7天 本地缓存设置1天
var roleIds = currentUser.RoleCacheBos.Select(c => c.RoleId).ToList();
cacheMenus = await SysMenuDao.GetMenusAsync(roleIds, currentUser.TenantId);
await RedisClient.SetAsync(menuKey, cacheMenus, new TimeSpan(7, 0, 0, 0));
Cache.Set(menuKey, cacheMenus, new TimeSpan(1, 0, 0, 0));
return(cacheMenus);
}
/// <summary>
/// 用户管理界面获取可关联角色 能看到这个界面的 就有管理所有当前租户下的权限 除系统创建角色外
/// </summary>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <PageResponse <RoleListDto> > GetCanRelationRoleListAsync(UserCacheBo currentUser)
{
CloseTracking();
Expression <Func <SysRole, bool> > roleExpression = s => !s.Deleted && s.TenantId == currentUser.TenantId && s.CreatedBy > 0;
var tempQueryable = CurrentDbContext.SysRoles.Where(roleExpression);
if (currentUser.CreatedBy > 0)
{
tempQueryable = tempQueryable.Where(c => !currentUser.RoleIdList.Contains(c.RoleId));
}
var resultQueryable = from sysRole in tempQueryable
select new RoleListDto()
{
RoleId = sysRole.RoleId.ToString(),
RoleName = sysRole.RoleName,
};
var result = await LoadPageEntitiesAsync(resultQueryable, 1, 1000, false, c => c.RoleId);
return(result);
}
/// <summary>
/// 重新生成缓存和token
/// </summary>
/// <param name="userCache"></param>
private static void CreateTokenCache(UserCacheBo userCache)
{
// 将某些信息存到token的payload中，此处是放的内存缓存信息 可替换成其它的
// aes加密的原因是避免直接被base64反编码看见
//var encryptMsg = userCache.ToJson().EncryptAES();
userCache.SessionId = Guid.NewGuid().ToString("N");
var dic = new Dictionary <string, string>()
{
{ "uid", userCache.UserId.ToString() },
{ "tenantId", userCache.TenantId.ToString() },
{ "sessionId", userCache.SessionId } //一个账号仅允许在一个地方登录
};
var token = TokenManager.GenerateToken(dic.ToJson(), 3 * 24);
LionWeb.HttpContext.Response.Headers["token"] = token;
userCache.UserToken = token;
LionWeb.HttpContext.Response.Headers["Access-Control-Expose-Headers"] = "token"; //多个以逗号分隔 eg:token,sid
LionUser.CurrentUser = userCache;
//LionUserCache.CreateUserCache(userCache);
}
public virtual async Task <BaseResponseModel> RemoveRoleAsync(long roleId, UserCacheBo currentUser)
{
var result = new ResponseModel <string>();
var db = SysRoleDao.CurrentDbContext;
var checkResult = await RoleIdCheckAsync(roleId, currentUser);
if (!checkResult.IsNullOrEmpty())
{
return(result.Fail(checkResult));
}
var count = await db.SysRoles.Where(c => c.RoleId == roleId && !c.Deleted).DeleteFromQueryAsync();
count += await db.SysUserRoleRelations.Where(c => c.RoleId == roleId).DeleteFromQueryAsync();
count += await db.SysRoleMenuRelations.Where(c => c.RoleId == roleId).DeleteFromQueryAsync();
count += await db.SaveChangesAsync();
return(count > 0 ? result.Succeed("角色删除成功") : result.Fail("角色删除失败"));
}
/// <summary>
/// 获取当前角色关联用户
/// </summary>
/// <param name="roleId"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <BaseResponseModel> GetRoleUserAsync(long roleId, UserCacheBo currentUser)
{
SysRoleDao.CloseTracking();
var db = SysRoleDao.CurrentDbContext;
var userRoleRelations = db.SysUserRoleRelations.Where(c => c.RoleId == roleId && !c.Deleted && c.TenantId == currentUser.TenantId);
// 排除当前管理员 和 自己
var users = db.SysUsers.Where(c => c.TenantId == currentUser.TenantId && c.CreatedBy > 0 && c.UserId != currentUser.UserId);
var data = from user in users
join userRole in userRoleRelations on user.UserId equals userRole.UserId into ur1
from ur2 in ur1.DefaultIfEmpty()
select new
{
roleId = ur2 == null ? -1 : ur2.RoleId,
userId = user.UserId,
NickName = user.NickName
};
var result = await data.Distinct().ToListAsync();
return(new ResponseModel().Succeed(result));
}
/// <summary>
/// 获取角色及关联一览
/// </summary>
/// <param name="rolePageParam"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <PageResponse <RoleListDto> > RoleListAsync(RolePageParam rolePageParam, UserCacheBo currentUser)
{
CloseTracking();
Expression <Func <SysRole, bool> > roleExpression = s => !s.Deleted && s.TenantId == currentUser.TenantId;
if (!rolePageParam.RoleName.IsNullOrEmpty())
{
roleExpression = roleExpression.And(c => c.RoleName.Contains(rolePageParam.RoleName));
}
var tempQueryable = CurrentDbContext.SysRoles.Where(roleExpression);
if (currentUser.CreatedBy > 0)
{
// 非管理员不看系统创建的角色
tempQueryable = tempQueryable.Where(c => c.CreatedBy > 0);
}
var resultQueryable = from sysRole in tempQueryable
select new RoleListDto()
{
RoleId = sysRole.RoleId.ToString(),
RoleDesc = sysRole.RoleDesc,
RoleName = sysRole.RoleName,
NickNames = from userRole in CurrentDbContext.SysUserRoleRelations
join sysUser in CurrentDbContext.SysUsers on userRole.UserId equals sysUser.UserId
where userRole.RoleId == sysRole.RoleId && !userRole.Deleted && userRole.TenantId == currentUser.TenantId && userRole.State == 1 && sysUser.State == 1 && sysUser.TenantId == currentUser.TenantId
select sysUser.NickName
};
var result = await LoadPageEntitiesAsync(resultQueryable, rolePageParam.CurrentPage, rolePageParam.PageSize, false, c => c.RoleId);
return(result);
}
/// <summary>
/// 修改密码
/// </summary>
/// <param name="modifyPwdParam"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <ResponseModel <string> > ModifyPwdAsync(ModifyPwdParam modifyPwdParam, UserCacheBo currentUser)
{
var result = new ResponseModel <string>();
if (modifyPwdParam.NewPassWord == modifyPwdParam.OldPassWord)
{
return(result.Fail(ResponseCode.Fail, "不允许原密码和新密码相同的修改"));
}
if (modifyPwdParam.OldPassWord.Md5Encrypt() == currentUser.PassWord)
{
var updateResult = await SysUserDao.ModifyPwdAsync(modifyPwdParam, currentUser.UserId);
if (updateResult)
{
// 修改成功 登出 重新登录
await LogoutAsync(currentUser);
return(result.Succeed("修改成功,请重新登录"));
}
return(result.Fail(ResponseCode.Fail, "修改失败，请稍后再试"));
}
return(result.Fail(ResponseCode.Fail, "原密码不正确"));
}
/// <summary>
/// 用户管理获取一览数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="pageSize"></param>
/// <param name="currentPage"></param>
/// <param name="email"></param>
/// <param name="nickName"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <PageResponse <UserManagerDto> > GetManagerUserAsync(int pageSize, int currentPage, string email, string nickName, UserCacheBo currentUser)
{
var result = await SysUserDao.GetManagerUserAsync(pageSize, currentPage, email, nickName, currentUser);
return(result);
}
/// <summary>
/// 用户管理界面创建用户
/// </summary>
/// <param name="param"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <BaseResponseModel> CreateManagerUserAsync(CreateUserParam param, UserCacheBo currentUser)
{
var result = new ResponseModel <bool>();
// 考虑是否验证上传的角色是当前租户下的
var checkResult = await CheckRoleIds(param.RoleIds, currentUser);
if (!checkResult.IsNullOrEmpty())
{
return(result.Fail(checkResult));
}
if (await ExistUserAsync(param.Email))
{
result.Fail(ResponseCode.Fail, "该邮箱已存在", false);
return(result);
}
var sysUser = new SysUser()
{
NickName = param.NickName,
PassWord = param.Pwd.Md5Encrypt(),
Email = param.Email,
Sex = 1,
State = 1,
CreatedTime = DateTime.Now,
UpdatedTime = DateTime.Now,
TenantId = currentUser.TenantId,
UpdatedBy = 0,
CreatedBy = currentUser.UserId,
SysUserRoleRelations = new List <SysUserRoleRelation>()
};
param.RoleIds.ForEach(roleId =>
{
sysUser.SysUserRoleRelations.Add(new SysUserRoleRelation()
{
TenantId = currentUser.TenantId,
RoleId = roleId,
State = 1,
CreatedTime = DateTime.Now,
CreatedBy = currentUser.UserId,
Deleted = false,
});
});
SysUserDao.Add(sysUser);
var count = await SysUserDao.SaveChangesAsync();
return(count > 0 ? result.Succeed(true) : result.Fail("保存失败", false));
}
public virtual async Task <BaseResponseModel> AddMenuAsync(UserCacheBo currentUser, IncrementMenuParam incrementMenu)
{
var responseModel = new ResponseModel <bool>();
var sysMenu = incrementMenu.MapTo <SysMenu>();
sysMenu.CreatedTime = DateTime.Now;
sysMenu.CreatedBy = currentUser.UserId;
sysMenu.UpdatedBy = currentUser.UserId;
var relations = new List <SysRoleMenuRelation>();
// 循环取出租户主体信息角色 增加新权限关系 默认为删除状态 点击分配给使用
var db = SysMenuDao.CurrentDbContext;
var roleIdsQueryable = db.SysUserRoleRelations.Where(c => !c.Deleted && c.State == 1 && c.TenantId > 1 && c.CreatedBy == 0).Select(c => new RoleCacheBo {
RoleId = c.RoleId, TenantId = c.TenantId
});
for (int i = 1; i < 100000; i++)
{
var roleIds = SysMenuDao.LoadPageEntities(roleIdsQueryable, i, 100, true, roleId => roleId.RoleId);
if (roleIds.PageData.Count > 0)
{
roleIds.PageData.ForEach(roleInfo =>
{
relations.Add(new SysRoleMenuRelation()
{
TenantId = roleInfo.TenantId,
MenuId = sysMenu.MenuId,
RoleId = roleInfo.RoleId,
Deleted = true, //默认不分配给超级管理员看 需单独分配
CreatedTime = DateTime.Now,
CreatedBy = 0, //系统创建的都设置为0
State = 1,
});
});
}
else
{
break;
}
}
relations.Add(new SysRoleMenuRelation()
{
TenantId = 1, //系统租户ID
MenuId = sysMenu.MenuId,
RoleId = 1, //系统角色ID
Deleted = false, //系统管理员使用
CreatedTime = DateTime.Now,
CreatedBy = 0, //系统创建的都设置为0
State = 1,
});
await db.SysRoleMenuRelations.AddRangeAsync(relations);
await SysMenuDao.AddAsync(sysMenu);
var count = await SysMenuDao.SaveChangesAsync();
return(count > 0 ? responseModel.Succeed(true) : responseModel.Fail(ResponseCode.Fail, "保存失败"));
}
/// <summary>
/// 修改角色
/// </summary>
/// <param name="incrementRoleParam"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <BaseResponseModel> ModifyRoleAsync(IncrementRoleParam incrementRoleParam, UserCacheBo currentUser)
{
var result = new ResponseModel <string>();
var db = SysRoleDao.CurrentDbContext;
if (await db.SysRoles.AnyAsync(c => c.TenantId == currentUser.TenantId && !c.Deleted && c.RoleName == incrementRoleParam.RoleName && c.RoleId != incrementRoleParam.RoleId))
{
return(result.Fail("角色名已存在"));
}
var checkResult = await RoleIdCheckAsync(incrementRoleParam.RoleId, currentUser);
if (!checkResult.IsNullOrEmpty())
{
return(result.Fail(checkResult));
}
var role = await db.SysRoles.FirstOrDefaultAsync(c => !c.Deleted && c.RoleId == incrementRoleParam.RoleId && c.TenantId == currentUser.TenantId);
role.RoleName = incrementRoleParam.RoleName;
role.RoleDesc = incrementRoleParam.RoleDesc ?? "";
role.UpdatedBy = currentUser.UserId;
role.UpdatedTime = DateTime.Now;
var count = await db.SaveChangesAsync();
return(count > 0 ? result.Succeed("修改成功") : result.Fail("修改失败", "修改失败"));
}
/// <summary>
/// 用户管理界面获取可关联角色
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <PageResponse <RoleListDto> > GetCanRelationRoleList(UserCacheBo currentUser)
{
PageResponse <RoleListDto> roleList = await SysRoleDao.GetCanRelationRoleListAsync(currentUser);
return(roleList);
}
public virtual async Task <BaseResponseModel> ModifyUserRoleAsync(ModifyUserRoleParam param, UserCacheBo currentUser)
{
var result = new ResponseModel <string>();
var checkResult = await RoleIdCheckAsync(param.RoleId, currentUser);
if (!checkResult.IsNullOrEmpty())
{
return(result.Fail(checkResult));
}
var db = SysRoleDao.CurrentDbContext;
var dbUserIds = await db.SysUsers.Where(c => c.TenantId == currentUser.TenantId && c.CreatedBy > 0 && c.UserId != currentUser.UserId).Select(c => c.UserId).ToListAsync();
var crossUserIds = param.UserIds.Intersect(dbUserIds).ToList(); //检查修改的用户是否是自己管理的用户ID，谨防其它手段上传的数据
//直接全量修改 原有角色用户关系删除 直接新增现加的
await db.SysUserRoleRelations.Where(c => c.RoleId == param.RoleId && c.TenantId == currentUser.TenantId).DeleteFromQueryAsync();
if (crossUserIds.Count > 0)
{
var userRoles = new List <SysUserRoleRelation>();
crossUserIds.ForEach(uid =>
{
userRoles.Add(new SysUserRoleRelation()
{
TenantId = currentUser.TenantId,
UserId = uid,
RoleId = param.RoleId,
State = 1,
CreatedBy = currentUser.UserId,
CreatedTime = DateTime.Now,
Deleted = false,
UpdatedBy = 0,
UpdatedTime = DateTime.Now,
});
});
await db.SysUserRoleRelations.AddRangeAsync(userRoles);
}
await db.SaveChangesAsync();
return(result.Succeed("修改成功"));
}
/// <summary>
/// 用户管理界面编辑用户信息
/// </summary>
/// <param name="modifyUserParam"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <BaseResponseModel> ModifyManagerUserAsync(ModifyUserParam modifyUserParam, UserCacheBo currentUser)
{
// 考虑是否验证上传的角色是当前租户下的
var checkResult = await CheckRoleIds(modifyUserParam.RoleIds, currentUser);
if (!checkResult.IsNullOrEmpty())
{
return(new ResponseModel().Fail(checkResult));
}
var result = await SysUserDao.ModifyManagerUserAsync(modifyUserParam.UserId, modifyUserParam.RoleIds, modifyUserParam.NickName, currentUser);
return(result);
}
public virtual async Task <BaseResponseModel> ModifyRoleMenuAsync(ModifyRoleMenuParam roleMenuParam, UserCacheBo currentUser)
{
var result = new ResponseModel <string>();
var checkResult = await RoleIdCheckAsync(roleMenuParam.RoleId, currentUser);
if (!checkResult.IsNullOrEmpty())
{
return(result.Fail(checkResult));
}
var currentUserMenus = await MenuBll.GetCurrentMenuAsync(currentUser);
var currentMenuIds = currentUserMenus.Select(c => c.MenuId).ToList();
//检查提交的按钮是否存在当前用户管理菜单数据中，只操作存在部分 即交集
var crossMenuIds = roleMenuParam.MenuIds.Intersect(currentMenuIds).ToList();
// 这里不是做的全量操作，而且新增部分做插入 数据库中的不在提交数据中的部分做删除 提交的和数据库相交叉的部分不做变动
var dbMenuIds = await SysMenuDao.LoadEntities <SysRoleMenuRelation>(c => c.RoleId == roleMenuParam.RoleId && c.TenantId == currentUser.TenantId).Select(c => c.MenuId).ToListAsync();
var dIds = dbMenuIds.Except(crossMenuIds).ToList(); //需要删除的权限
var iIds = crossMenuIds.Except(dbMenuIds).ToList(); //需要插入的新权限
var db = SysRoleDao.CurrentDbContext;
if (dIds.Count > 0)
{
await db.SysRoleMenuRelations.Where(c => dIds.Contains(c.MenuId) && c.RoleId == roleMenuParam.RoleId).DeleteAsync();
}
if (iIds.Count > 0)
{
var roleMenuRelations = iIds.Select(iId => new SysRoleMenuRelation()
{
TenantId = currentUser.TenantId,
CreatedBy = currentUser.UserId,
CreatedTime = DateTime.Now,
MenuId = iId,
State = 1,
Deleted = false,
RoleId = roleMenuParam.RoleId,
UpdatedBy = 0,
UpdatedTime = DateTime.Now,
}).ToList();
await db.SysRoleMenuRelations.AddRangeAsync(roleMenuRelations);
}
await db.SaveChangesAsync();
return(result.Succeed("修改成功"));
}
public virtual async Task <BaseResponseModel> RemoveManagerUserAsync(long uid, UserCacheBo currentUser)
{
var result = new ResponseModel <bool>();
var db = SysUserDao.CurrentDbContext;
var deleteUser = await db.SysUsers.FirstOrDefaultAsync(c => c.UserId == uid && c.TenantId == currentUser.UserId && c.State == 1);
if (deleteUser == null)
{
return(result.Fail("账号不存在"));
}
// 管理员创建者都是0 注册的
if (deleteUser.CreatedBy <= 0)
{
return(result.Fail("管理员只读"));
}
var count = 0;
count += await db.SysUsers.Where(c => c.UserId == uid && c.TenantId == currentUser.TenantId).DeleteFromQueryAsync();
count += await db.SysUserRoleRelations.Where(c => c.UserId == uid && c.TenantId == currentUser.TenantId).DeleteFromQueryAsync();
count += await db.SaveChangesAsync();
return(count > 0 ? result.Succeed(true) : result.Fail("删除失败"));
}
public virtual async Task <ResponseModel <bool> > ModifyManagerUserAsync(long uid, List <long> roleIds, string nickName, UserCacheBo currentUser)
{
var result = new ResponseModel <bool>();
var user = await CurrentDbContext.SysUsers.FirstOrDefaultAsync(c => c.UserId == uid && c.State == 1 && c.TenantId == currentUser.TenantId);
if (user == null)
{
return(result.Fail("修改的用户信息不存在"));
}
if (user.CreatedBy == 0)
{
return(result.Fail("管理员只读"));
}
//获取当前用户所拥有的角色
var existRoleIds = await CurrentDbContext.SysUserRoleRelations.Where(c => c.UserId == uid && !c.Deleted && c.State == 1 && c.TenantId == currentUser.TenantId && c.CreatedBy > 0)
.Select(c => c.RoleId).ToListAsync();
user.NickName = nickName;
var dRoleIds = existRoleIds.Except(roleIds).ToList(); //删除此前分配的角色 不在这次保存角色中的
var iRoleIds = roleIds.Except(existRoleIds).ToList(); //插入这次新增的不在之前角色中的
//相同部分不做改变
if (dRoleIds.Any())
{
// 删除
await CurrentDbContext.SysUserRoleRelations.Where(c => c.UserId == uid && dRoleIds.Contains(c.RoleId) && c.TenantId == currentUser.TenantId).DeleteFromQueryAsync();
}
if (iRoleIds.Count > 0)
{
//插入
var userRoleRelations = new List <SysUserRoleRelation>();
iRoleIds.ForEach(roleId =>
{
userRoleRelations.Add(new SysUserRoleRelation()
{
TenantId = currentUser.TenantId,
CreatedBy = currentUser.UserId,
CreatedTime = DateTime.Now,
RoleId = roleId,
State = 1,
UserId = uid,
});
});
await CurrentDbContext.SysUserRoleRelations.AddRangeAsync(userRoleRelations);
}
var count = await SaveChangesAsync();
return(count > 0 ? result.Succeed(true) : result.Fail("保存修改信息失败"));
}
/// <summary>
/// 添加到本地缓存
/// </summary>
/// <param name="key"></param>
/// <param name="cache"></param>
private static void AddToMemoryCache(string key, UserCacheBo cache)
{
Cache.Set(key, cache, Timeout);
}
/// <summary>
/// 新增角色
/// </summary>
/// <param name="incrementRoleParam"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <BaseResponseModel> AddRoleAsync(IncrementRoleParam incrementRoleParam, UserCacheBo currentUser)
{
var result = new ResponseModel <string>();
var db = SysRoleDao.CurrentDbContext;
SysRoleDao.CloseTracking();
if (await db.SysRoles.CountAsync(c => c.TenantId == currentUser.TenantId && !c.Deleted) > 500)
{
return(result.Fail("一个租户下角色上限为500个"));
}
if (await db.SysRoles.AnyAsync(c => c.TenantId == currentUser.TenantId && !c.Deleted && c.RoleName == incrementRoleParam.RoleName))
{
return(result.Fail("角色名已存在"));
}
var role = new SysRole()
{
TenantId = currentUser.TenantId,
CreatedBy = currentUser.UserId,
CreatedTime = DateTime.Now,
Deleted = false,
RoleDesc = incrementRoleParam.RoleDesc ?? "",
RoleName = incrementRoleParam.RoleName,
};
await db.SysRoles.AddAsync(role);
var count = await db.SaveChangesAsync();
return(count > 0 ? result.Succeed("添加成功") : result.Fail("添加失败"));
}
/// <summary>
/// 获取用户管理用户一览
/// </summary>
/// <param name="pageSize"></param>
/// <param name="currentPage"></param>
/// <param name="email"></param>
/// <param name="nickName"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <PageResponse <UserManagerDto> > GetManagerUserAsync(int pageSize, int currentPage, string email, string nickName, UserCacheBo currentUser)
{
CloseTracking();
Expression <Func <SysUser, bool> > userExpression = sysUser => sysUser.State == 1 && sysUser.TenantId == currentUser.TenantId;
if (!email.IsNullOrEmpty())
{
userExpression = userExpression.And(c => c.Email == email);
}
if (!nickName.IsNullOrEmpty())
{
userExpression = userExpression.And(c => c.NickName.Contains(nickName));
}
// 分配用户管理界面 则可以管理当前所有用户
var sysUserQueryable = CurrentDbContext.SysUsers.Where(userExpression);
if (currentUser.CreatedBy > 0)
{
//非超级管理员不读取超级管理员信息
sysUserQueryable = sysUserQueryable.Where(c => c.CreatedBy > 0);
}
var result = await LoadPageEntitiesProjectToAsync <SysUser, long, UserManagerDto>(sysUserQueryable, currentPage, pageSize, false, u => u.UserId);
var uids = result.PageData.Select(c => long.Parse(c.UserId));
var rolesQueryable = from userRoleRelation in CurrentDbContext.SysUserRoleRelations
join sysRole in CurrentDbContext.SysRoles on userRoleRelation.RoleId equals sysRole.RoleId
where !userRoleRelation.Deleted && userRoleRelation.State == 1 && !sysRole.Deleted && sysRole.TenantId == currentUser.TenantId && userRoleRelation.TenantId == currentUser.TenantId &&
uids.Contains(userRoleRelation.UserId)
select new
{
userRoleRelation.UserId,
userRoleRelation.RoleId,
sysRole.RoleName,
sysRole.RoleDesc,
};
var roles = await rolesQueryable.Distinct().ToListAsync();
result.PageData.ForEach(u =>
{
var r = roles.Where(c => c.UserId.ToString() == u.UserId).ToList();
u.RoleIds = r.Select(c => c.RoleId.ToString()).ToList();
u.RoleNames = r.Select(c => c.RoleName).ToList();
});
return(result);
}
/// <summary>
/// 获取角色及关联用户一览
/// </summary>
/// <param name="rolePageParam"></param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <PageResponse <RoleListDto> > RoleListAsync(RolePageParam rolePageParam, UserCacheBo currentUser)
{
PageResponse <RoleListDto> roleList = await SysRoleDao.RoleListAsync(rolePageParam, currentUser);
return(roleList);
}
