wenyongda/ZrAdminNetCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

优化仓储

Browse Source
This commit is contained in:
不做码农 2022-10-20 18:30:05 +08:00
parent e6dc9448fd
commit b5326df532
15 changed files with 435 additions and 590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ZR.Admin.WebApi/Controllers/System/SysMenuController.cs
View File

@ -21,13 +21,16 @@ namespace ZR.Admin.WebApi.Controllers.System
{ {
private readonly ISysRoleService sysRoleService; private readonly ISysRoleService sysRoleService;
private readonly ISysMenuService sysMenuService; private readonly ISysMenuService sysMenuService;
private readonly ISysRoleMenuService sysRoleMenuService;
public SysMenuController( public SysMenuController(
ISysRoleService sysRoleService, ISysRoleService sysRoleService,
ISysMenuService sysMenuService) ISysMenuService sysMenuService,
ISysRoleMenuService sysRoleMenuService)
{ {
this.sysRoleService = sysRoleService; this.sysRoleService = sysRoleService;
this.sysMenuService = sysMenuService; this.sysMenuService = sysMenuService;
this.sysRoleMenuService = sysRoleMenuService;
} }
/// <summary> /// <summary>
@ -63,7 +66,8 @@ namespace ZR.Admin.WebApi.Controllers.System
[ActionPermissionFilter(Permission = "system:menu:query")] [ActionPermissionFilter(Permission = "system:menu:query")]
public IActionResult GetMenuList(int menuId = 0) public IActionResult GetMenuList(int menuId = 0)
{ {
return SUCCESS(sysMenuService.GetMenusByMenuId(menuId), "yyyy-MM-dd HH:mm:ss"); long userId = HttpContext.GetUId();
return SUCCESS(sysMenuService.GetMenusByMenuId(menuId, userId), "yyyy-MM-dd HH:mm:ss");
} }
/// <summary> /// <summary>
@ -166,7 +170,7 @@ namespace ZR.Admin.WebApi.Controllers.System
{ {
return ToResponse(ResultCode.CUSTOM_ERROR, "存在子菜单,不允许删除"); return ToResponse(ResultCode.CUSTOM_ERROR, "存在子菜单,不允许删除");
} }
if (sysMenuService.CheckMenuExistRole(menuId)) if (sysRoleMenuService.CheckMenuExistRole(menuId))
{ {
return ToResponse(ResultCode.CUSTOM_ERROR, "菜单已分配,不允许删除"); return ToResponse(ResultCode.CUSTOM_ERROR, "菜单已分配,不允许删除");
} }

18
ZR.Repository/BaseRepository.cs
View File

@ -63,18 +63,34 @@ namespace ZR.Repository
{ {
return Context.Updateable(entity); return Context.Updateable(entity);
} }
/// <summary>
/// 实体根据主键更新
/// </summary>
/// <param name="entity"></param>
/// <param name="ignoreNullColumns"></param>
/// <returns></returns>
public int Update(T entity, bool ignoreNullColumns = false) public int Update(T entity, bool ignoreNullColumns = false)
{ {
return Context.Updateable(entity).IgnoreColumns(ignoreNullColumns).ExecuteCommand(); return Context.Updateable(entity).IgnoreColumns(ignoreNullColumns).ExecuteCommand();
} }
/// <summary>
/// 实体根据主键更新指定字段
/// return Update(user, t => new { t.NickName, }, true);
/// </summary>
/// <param name="entity"></param>
/// <param name="expression"></param>
/// <param name="ignoreAllNull"></param>
/// <returns></returns>
public int Update(T entity, Expression<Func<T, object>> expression, bool ignoreAllNull = false) public int Update(T entity, Expression<Func<T, object>> expression, bool ignoreAllNull = false)
{ {
return Context.Updateable(entity).UpdateColumns(expression).IgnoreColumns(ignoreAllNull).ExecuteCommand(); return Context.Updateable(entity).UpdateColumns(expression).IgnoreColumns(ignoreAllNull).ExecuteCommand();
} }
/// <summary> /// <summary>
/// 根据实体类更新指定列 eg：Update(dept, it => new { it.Status }, f => depts.Contains(f.DeptId));只更新Status列，条件是包含 /// 根据指定条件更新指定列 eg：Update(new SysUser(){ }, it => new { it.Status }, f => f.Userid == 1));
/// 只更新Status列，条件是包含
/// </summary> /// </summary>
/// <param name="entity"></param> /// <param name="entity"></param>
/// <param name="expression"></param> /// <param name="expression"></param>

211
ZR.Repository/System/SysRoleRepository.cs
View File

@ -1,211 +0,0 @@
using Infrastructure.Attribute;
using Infrastructure.Model;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using ZR.Model;
using ZR.Model.System;
namespace ZR.Repository.System
{
/// <summary>
/// 角色操作类
/// </summary>
[AppService(ServiceLifetime = LifeTime.Transient)]
public class SysRoleRepository : BaseRepository<SysRole>
{
/// <summary>
/// 查询所有角色数据
/// </summary>
/// <returns></returns>
public List<SysRole> SelectRoleList()
{
return Context.Queryable<SysRole>()
.Where(role => role.DelFlag == "0")
.OrderBy(role => role.RoleSort)
.ToList();
}
/// <summary>
/// 根据条件分页查询角色数据
/// </summary>
/// <param name="sysRole"></param>
/// <param name="pager"></param>
/// <returns></returns>
public PagedInfo<SysRole> SelectRoleList(SysRole sysRole, PagerInfo pager)
{
var exp = Expressionable.Create<SysRole>();
exp.And(role => role.DelFlag == "0");
exp.AndIF(!string.IsNullOrEmpty(sysRole.RoleName), role => role.RoleName.Contains(sysRole.RoleName));
exp.AndIF(!string.IsNullOrEmpty(sysRole.Status), role => role.Status == sysRole.Status);
exp.AndIF(!string.IsNullOrEmpty(sysRole.RoleKey), role => role.RoleKey == sysRole.RoleKey);
var query = Context.Queryable<SysRole>()
.Where(exp.ToExpression())
.OrderBy(x => x.RoleSort)
.Select((role) => new SysRole
{
RoleId = role.RoleId.SelectAll(),
UserNum = SqlFunc.Subqueryable<SysUserRole>().Where(f => f.RoleId == role.RoleId).Count()
});
return query.ToPage(pager);
}
/// <summary>
/// 根据用户查询
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public List<SysRole> SelectRolePermissionByUserId(long userId)
{
return Context.Queryable<SysRole>()
.Where(role => role.DelFlag == "0")
.Where(it => SqlFunc.Subqueryable<SysUserRole>().Where(s => s.UserId == userId).Any())
.OrderBy(role => role.RoleSort)
.ToList();
}
/// <summary>
/// 通过角色ID查询角色
/// </summary>
/// <param name="roleId">角色编号</param>
/// <returns></returns>
public SysRole SelectRoleById(long roleId)
{
return GetId(roleId);
}
/// <summary>
/// 通过角色ID删除角色
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public int DeleteRoleByRoleIds(long[] roleId)
{
return Delete(roleId);
}
/// <summary>
/// 获取用户所有角色信息
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public List<SysRole> SelectUserRoleListByUserId(long userId)
{
return Context.Queryable<SysUserRole, SysRole>((ur, r) => new JoinQueryInfos(
JoinType.Left, ur.RoleId == r.RoleId
)).Where((ur, r) => ur.UserId == userId)
.Select((ur, r) => r).ToList();
}
#region 用户角色对应菜单 用户N-1角色
/// <summary>
/// 根据角色获取菜单id
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public List<SysRoleMenu> SelectRoleMenuByRoleId(long roleId)
{
return Context.Queryable<SysRoleMenu>().Where(it => it.Role_id == roleId).ToList();
}
/// <summary>
/// 根据用户所有角色获取菜单
/// </summary>
/// <param name="roleIds"></param>
/// <returns></returns>
public List<SysRoleMenu> SelectRoleMenuByRoleIds(long[] roleIds)
{
return Context.Queryable<SysRoleMenu>().Where(it => roleIds.Contains(it.Role_id)).ToList();
}
/// <summary>
/// 批量插入用户菜单
/// </summary>
/// <param name="sysRoleMenus"></param>
/// <returns></returns>
public int AddRoleMenu(List<SysRoleMenu> sysRoleMenus)
{
return Context.Insertable(sysRoleMenus).ExecuteCommand();
}
/// <summary>
/// 删除角色与菜单关联
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public int DeleteRoleMenuByRoleId(long roleId)
{
return Context.Deleteable<SysRoleMenu>().Where(it => it.Role_id == roleId).ExecuteCommand();
}
#endregion
/// <summary>
/// 添加角色
/// </summary>
/// <param name="sysRole"></param>
/// <returns></returns>
public long InsertRole(SysRole sysRole)
{
sysRole.Create_time = DateTime.Now;
return InsertReturnBigIdentity(sysRole);
}
/// <summary>
/// 修改用户角色
/// </summary>
/// <param name="sysRole"></param>
/// <returns></returns>
public int UpdateSysRole(SysRole sysRole)
{
var db = Context;
sysRole.Update_time = db.GetDate();
return db.Updateable<SysRole>()
.SetColumns(it => it.Update_time == sysRole.Update_time)
.SetColumns(it => it.DataScope == sysRole.DataScope)
.SetColumns(it => it.Remark == sysRole.Remark)
.SetColumns(it => it.Update_by == sysRole.Update_by)
//.SetColumns(it => it.MenuCheckStrictly == sysRole.MenuCheckStrictly)
.SetColumns(it => it.DeptCheckStrictly == sysRole.DeptCheckStrictly)
.SetColumnsIF(!string.IsNullOrEmpty(sysRole.RoleName), it => it.RoleName == sysRole.RoleName)
.SetColumnsIF(!string.IsNullOrEmpty(sysRole.RoleKey), it => it.RoleKey == sysRole.RoleKey)
.SetColumnsIF(sysRole.RoleSort >= 0, it => it.RoleSort == sysRole.RoleSort)
.Where(it => it.RoleId == sysRole.RoleId)
.ExecuteCommand();
}
/// <summary>
/// 更改角色权限状态
/// </summary>
/// <param name="role"></param>
/// <returns></returns>
public int UpdateRoleStatus(SysRole role)
{
return Context.Updateable(role).UpdateColumns(t => new { t.Status }).ExecuteCommand();
}
/// <summary>
/// 检查角色权限是否存在
/// </summary>
/// <param name="roleKey">角色权限</param>
/// <returns></returns>
public SysRole CheckRoleKeyUnique(string roleKey)
{
return GetFirst(it => it.RoleKey == roleKey);
}
/// <summary>
/// 校验角色名称是否唯一
/// </summary>
/// <param name="roleName">角色名称</param>
/// <returns></returns>
public SysRole CheckRoleNameUnique(string roleName)
{
return GetFirst(it => it.RoleName == roleName);
}
}
}

189
ZR.Repository/System/SysUserRepository.cs
View File

@ -1,189 +0,0 @@
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using ZR.Model;
using ZR.Model.System;
using ZR.Model.System.Dto;
namespace ZR.Repository.System
{
/// <summary>
/// 用户管理
/// </summary>
[AppService(ServiceLifetime = LifeTime.Transient)]
public class SysUserRepository : BaseRepository<SysUser>
{
/// <summary>
/// 根据条件分页查询用户列表
/// <paramref name="user"/>
/// <paramref name="user"/>
/// </summary>
/// <returns></returns>
public PagedInfo<SysUser> SelectUserList(SysUser user, PagerInfo pager)
{
var exp = Expressionable.Create<SysUser>();
exp.AndIF(!string.IsNullOrEmpty(user.UserName), u => u.UserName.Contains(user.UserName));
exp.AndIF(!string.IsNullOrEmpty(user.Status), u => u.Status == user.Status);
exp.AndIF(user.BeginTime != DateTime.MinValue && user.BeginTime != null, u => u.Create_time >= user.BeginTime);
exp.AndIF(user.EndTime != DateTime.MinValue && user.EndTime != null, u => u.Create_time <= user.EndTime);
exp.AndIF(!user.Phonenumber.IsEmpty(), u => u.Phonenumber == user.Phonenumber);
exp.And(u => u.DelFlag == "0");
if (user.DeptId != 0)
{
List<SysDept> depts = Context.Queryable<SysDept>().ToList();
var newDepts = depts.FindAll(delegate (SysDept dept)
{
string[] parentDeptId = dept.Ancestors.Split(",", StringSplitOptions.RemoveEmptyEntries);
return parentDeptId.Contains(user.DeptId.ToString());
});
string[] deptArr = newDepts.Select(x => x.DeptId.ToString()).ToArray();
exp.AndIF(user.DeptId != 0, u => u.DeptId == user.DeptId || deptArr.Contains(u.DeptId.ToString()));
}
var query = Context.Queryable<SysUser>()
.LeftJoin<SysDept>((u, dept) => u.DeptId == dept.DeptId)
.Where(exp.ToExpression())
.Select((u, dept) => new SysUser
{
UserId = u.UserId.SelectAll(),
DeptName = dept.DeptName,
});
return query.ToPage(pager);
}
/// <summary>
/// 通过用户ID查询用户
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public SysUser SelectUserById(long userId)
{
return Context.Queryable<SysUser>().Filter(null, true).Where(f => f.UserId == userId).First();
}
/// <summary>
/// 校验用户名是否存在
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public int CheckUserNameUnique(string userName)
{
return Context.Queryable<SysUser>().Where(it => it.UserName == userName).Count();
}
/// <summary>
/// 添加用户
/// </summary>
/// <param name="sysUser"></param>
/// <returns></returns>
public int AddUser(SysUser sysUser)
{
sysUser.Create_time = DateTime.Now;
return Context.Insertable(sysUser).ExecuteReturnIdentity();
}
/// <summary>
/// 重置密码
/// </summary>
/// <param name="userid"></param>
/// <param name="password"></param>
/// <returns></returns>
public int ResetPwd(long userid, string password)
{
return Context.Updateable(new SysUser() { UserId = userid, Password = password })
.UpdateColumns(it => new { it.Password }).ExecuteCommand();
}
/// <summary>
/// 改变用户状态
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public int ChangeUserStatus(SysUser user)
{
return Context.Updateable(user).UpdateColumns(t => new { t.Status })
.ExecuteCommand();
}
/// <summary>
/// 删除用户(软删除)
/// </summary>
/// <param name="userid">用户id</param>
/// <returns></returns>
public int DeleteUser(long userid)
{
return Context.Updateable(new SysUser() { UserId = userid, DelFlag = "2" })
.UpdateColumns(t => t.DelFlag)
.ExecuteCommand();
}
/// <summary>
/// 修改用户信息
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public int UpdateUser(SysUser user)
{
return Context.Updateable(user)
.UpdateColumns(t => new
{
t.NickName,
t.Email,
t.Phonenumber,
t.DeptId,
t.Status,
t.Sex,
t.PostIds,
t.Remark,
t.Update_by,
t.Update_time
})
.IgnoreColumns(ignoreAllNullColumns: true)//忽略所有为null
.Where(f => f.UserId == user.UserId).ExecuteCommand();
}
/// <summary>
/// 修改用户头像
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public int UpdatePhoto(SysUser user)
{
return Context.Updateable<SysUser>()
.SetColumns(t => new SysUser()
{
Avatar = user.Avatar
})
.Where(f => f.UserId == user.UserId).ExecuteCommand();
}
/// <summary>
/// 登录
/// </summary>
/// <param name="user">登录实体</param>
/// <returns></returns>
public SysUser Login(LoginBodyDto user)
{
return GetFirst(it => it.UserName == user.Username && it.Password == user.Password);
}
/// <summary>
/// 修改登录信息
/// </summary>
/// <param name="user"></param>
/// <param name="userId"></param>
/// <returns></returns>
public void UpdateLoginInfo(LoginBodyDto user, long userId)
{
var db = Context;
db.Updateable(new SysUser() { LoginIP = user.LoginIP, LoginDate = db.GetDate(), UserId = userId })
.UpdateColumns(it => new { it.LoginIP, it.LoginDate })
.ExecuteCommand();
}
}
}

72
ZR.Repository/System/SysUserRoleRepository.cs
View File

@ -1,72 +0,0 @@
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using SqlSugar;
using System.Collections.Generic;
using ZR.Model;
using ZR.Model.System;
using ZR.Model.System.Dto;
namespace ZR.Repository.System
{
[AppService(ServiceLifetime = LifeTime.Transient)]
public class SysUserRoleRepository : BaseRepository<SysUserRole>
{
/// <summary>
/// 批量删除角色对应用户
/// </summary>
/// <param name="roleId">角色id</param>
/// <param name="userIds">用户id集合</param>
/// <returns></returns>
public int DeleteRoleUserByUserIds(long roleId, List<long> userIds)
{
return Context.Deleteable<SysUserRole>().Where(it => it.RoleId == roleId && userIds.Contains(it.UserId))
.ExecuteCommand();
}
/// <summary>
/// 获取用户数据根据角色id
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public List<SysUser> GetSysUsersByRoleId(long roleId)
{
return Context.Queryable<SysUserRole, SysUser>((t1, u) => new JoinQueryInfos(
JoinType.Left, t1.UserId == u.UserId))
.Where((t1, u) => t1.RoleId == roleId && u.DelFlag == "0")
.Select((t1, u) => u)
.ToList();
}
/// <summary>
/// 获取用户数据根据角色id
/// </summary>
/// <param name="roleUserQueryDto"></param>
/// <returns></returns>
public PagedInfo<SysUser> GetSysUsersByRoleId(RoleUserQueryDto roleUserQueryDto)
{
var query = Context.Queryable<SysUserRole, SysUser>((t1, u) => new JoinQueryInfos(
JoinType.Left, t1.UserId == u.UserId))
.Where((t1, u) => t1.RoleId == roleUserQueryDto.RoleId && u.DelFlag == "0");
if (!string.IsNullOrEmpty(roleUserQueryDto.UserName))
{
query = query.Where((t1, u) => u.UserName.Contains(roleUserQueryDto.UserName));
}
return query.Select((t1, u) => u).ToPage(roleUserQueryDto);
}
/// <summary>
/// 获取尚未指派的用户数据根据角色id
/// </summary>
/// <param name="roleUserQueryDto"></param>
/// <returns></returns>
public PagedInfo<SysUser> GetExcludedSysUsersByRoleId(RoleUserQueryDto roleUserQueryDto)
{
var query = Context.Queryable<SysUser>()
.Where(it => it.DelFlag == "0")
.Where(it => SqlFunc.Subqueryable<SysUserRole>().Where(s => s.UserId == it.UserId && s.RoleId == roleUserQueryDto.RoleId).NotAny())
.WhereIF(roleUserQueryDto.UserName.IsNotEmpty(), it => it.UserName.Contains(roleUserQueryDto.UserName));
return query.ToPage(roleUserQueryDto);
}
}
}

2
ZR.Service/System/ArticleService.cs
View File

@ -1,7 +1,5 @@
using Infrastructure.Attribute; using Infrastructure.Attribute;
using SqlSugar;
using ZR.Model.System; using ZR.Model.System;
using ZR.Repository.System;
using ZR.Service.System.IService; using ZR.Service.System.IService;
namespace ZR.Service.System namespace ZR.Service.System

43
ZR.Service/System/IService/ISysMenuService.cs
View File

@ -5,7 +5,7 @@ using ZR.Model.System.Vo;
namespace ZR.Service.System.IService namespace ZR.Service.System.IService
{ {
public interface ISysMenuService public interface ISysMenuService : IBaseService<SysMenu>
{ {
//List<SysMenu> SelectMenuList(long userId); //List<SysMenu> SelectMenuList(long userId);
@ -13,7 +13,7 @@ namespace ZR.Service.System.IService
List<SysMenu> SelectTreeMenuList(MenuQueryDto menu, long userId); List<SysMenu> SelectTreeMenuList(MenuQueryDto menu, long userId);
SysMenu GetMenuByMenuId(int menuId); SysMenu GetMenuByMenuId(int menuId);
List<SysMenu> GetMenusByMenuId(int menuId); List<SysMenu> GetMenusByMenuId(int menuId, long userId);
int AddMenu(SysMenu menu); int AddMenu(SysMenu menu);
int EditMenu(SysMenu menu); int EditMenu(SysMenu menu);
@ -28,14 +28,49 @@ namespace ZR.Service.System.IService
List<SysMenu> SelectMenuTreeByUserId(long userId); List<SysMenu> SelectMenuTreeByUserId(long userId);
List<SysMenu> SelectMenuPermsListByUserId(long userId); //List<SysMenu> SelectMenuPermsListByUserId(long userId);
List<string> SelectMenuPermsByUserId(long userId); List<string> SelectMenuPermsByUserId(long userId);
bool CheckMenuExistRole(long menuId); //bool CheckMenuExistRole(long menuId);
List<RouterVo> BuildMenus(List<SysMenu> menus); List<RouterVo> BuildMenus(List<SysMenu> menus);
List<TreeSelectVo> BuildMenuTreeSelect(List<SysMenu> menus); List<TreeSelectVo> BuildMenuTreeSelect(List<SysMenu> menus);
} }
/// <summary>
/// 角色菜单
/// </summary>
public interface ISysRoleMenuService : IBaseService<SysRoleMenu>
{
bool CheckMenuExistRole(long menuId);
/// <summary>
/// 根据角色获取菜单id
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
List<SysRoleMenu> SelectRoleMenuByRoleId(long roleId);
/// <summary>
/// 根据用户所有角色获取菜单
/// </summary>
/// <param name="roleIds"></param>
/// <returns></returns>
List<SysRoleMenu> SelectRoleMenuByRoleIds(long[] roleIds);
/// <summary>
/// 批量插入用户菜单
/// </summary>
/// <param name="sysRoleMenus"></param>
/// <returns></returns>
int AddRoleMenu(List<SysRoleMenu> sysRoleMenus);
/// <summary>
/// 删除角色与菜单关联
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
int DeleteRoleMenuByRoleId(long roleId);
}
} }

2
ZR.Service/System/IService/ISysRoleService.cs
View File

@ -137,5 +137,7 @@ namespace ZR.Service.System.IService
/// <param name="sysRole">角色信息</param> /// <param name="sysRole">角色信息</param>
/// <returns></returns> /// <returns></returns>
public int UpdateRole(SysRole sysRole); public int UpdateRole(SysRole sysRole);
int UpdateSysRole(SysRole sysRole);
} }
} }

14
ZR.Service/System/IService/ISysUserService.cs
View File

@ -1,4 +1,5 @@
using ZR.Model; using System.Collections.Generic;
using ZR.Model;
using ZR.Model.System; using ZR.Model.System;
using ZR.Model.System.Dto; using ZR.Model.System.Dto;
@ -70,5 +71,16 @@ namespace ZR.Service.System.IService
SysUser Register(RegisterDto dto); SysUser Register(RegisterDto dto);
void CheckUserAllowed(SysUser user); void CheckUserAllowed(SysUser user);
void CheckUserDataScope(long userid, long loginUserId); void CheckUserDataScope(long userid, long loginUserId);
/// <summary>
/// 导入
/// </summary>
/// <param name="users"></param>
/// <returns></returns>
string ImportUsers(List<SysUser> users);
SysUser Login(LoginBodyDto user);
void UpdateLoginInfo(LoginBodyDto user, long userId);
} }
} }

11
ZR.Service/System/SysLoginService.cs
View File

@ -7,7 +7,6 @@ using ZR.Model;
using ZR.Model.System; using ZR.Model.System;
using ZR.Model.System.Dto; using ZR.Model.System.Dto;
using ZR.Repository; using ZR.Repository;
using ZR.Repository.System;
using ZR.Service.System.IService; using ZR.Service.System.IService;
namespace ZR.Service.System namespace ZR.Service.System
@ -18,11 +17,11 @@ namespace ZR.Service.System
[AppService(ServiceType = typeof(ISysLoginService), ServiceLifetime = LifeTime.Transient)] [AppService(ServiceType = typeof(ISysLoginService), ServiceLifetime = LifeTime.Transient)]
public class SysLoginService: BaseService<SysLogininfor>, ISysLoginService public class SysLoginService: BaseService<SysLogininfor>, ISysLoginService
{ {
private readonly SysUserRepository SysUserRepository; private readonly ISysUserService SysUserService;
public SysLoginService(SysUserRepository sysUserRepository) public SysLoginService(ISysUserService sysUserService)
{ {
SysUserRepository = sysUserRepository; SysUserService = sysUserService;
} }
/// <summary> /// <summary>
@ -35,7 +34,7 @@ namespace ZR.Service.System
//密码md5 //密码md5
loginBody.Password = NETCore.Encrypt.EncryptProvider.Md5(loginBody.Password); loginBody.Password = NETCore.Encrypt.EncryptProvider.Md5(loginBody.Password);
SysUser user = SysUserRepository.Login(loginBody); SysUser user = SysUserService.Login(loginBody);
logininfor.UserName = loginBody.Username; logininfor.UserName = loginBody.Username;
logininfor.Status = "1"; logininfor.Status = "1";
logininfor.LoginTime = DateTime.Now; logininfor.LoginTime = DateTime.Now;
@ -56,7 +55,7 @@ namespace ZR.Service.System
logininfor.Status = "0"; logininfor.Status = "0";
logininfor.Msg = "登录成功"; logininfor.Msg = "登录成功";
AddLoginInfo(logininfor); AddLoginInfo(logininfor);
SysUserRepository.UpdateLoginInfo(loginBody, user.UserId); SysUserService.UpdateLoginInfo(loginBody, user.UserId);
return user; return user;
} }

161
ZR.Service/System/SysMenuService.cs
View File

@ -1,13 +1,14 @@
using Infrastructure.Attribute; using Infrastructure.Attribute;
using Infrastructure.Extensions;
using SqlSugar;
using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using ZR.Model.System.Dto;
using ZR.Model.System;
using ZR.Model.System.Vo;
using ZR.Repository.System;
using ZR.Service.System.IService;
using ZR.Common; using ZR.Common;
using Infrastructure.Extensions; using ZR.Model.System;
using ZR.Model.System.Dto;
using ZR.Model.System.Vo;
using ZR.Service.System.IService;
namespace ZR.Service namespace ZR.Service
{ {
@ -17,14 +18,10 @@ namespace ZR.Service
[AppService(ServiceType = typeof(ISysMenuService), ServiceLifetime = LifeTime.Transient)] [AppService(ServiceType = typeof(ISysMenuService), ServiceLifetime = LifeTime.Transient)]
public class SysMenuService : BaseService<SysMenu>, ISysMenuService public class SysMenuService : BaseService<SysMenu>, ISysMenuService
{ {
public SysMenuRepository MenuRepository;
public ISysRoleService SysRoleService; public ISysRoleService SysRoleService;
public SysMenuService( public SysMenuService(ISysRoleService sysRoleService)
SysMenuRepository menuRepository,
ISysRoleService sysRoleService)
{ {
MenuRepository = menuRepository;
SysRoleService = sysRoleService; SysRoleService = sysRoleService;
} }
@ -37,12 +34,12 @@ namespace ZR.Service
List<SysMenu> menuList; List<SysMenu> menuList;
if (SysRoleService.IsAdmin(userId)) if (SysRoleService.IsAdmin(userId))
{ {
menuList = MenuRepository.SelectTreeMenuList(menu); menuList = SelectTreeMenuList(menu);
} }
else else
{ {
var userRoles = SysRoleService.SelectUserRoles(userId); var userRoles = SysRoleService.SelectUserRoles(userId);
menuList = MenuRepository.SelectTreeMenuListByRoles(menu, userRoles); menuList = SelectTreeMenuListByRoles(menu, userRoles);
} }
return menuList; return menuList;
} }
@ -56,12 +53,12 @@ namespace ZR.Service
List<SysMenu> menuList; List<SysMenu> menuList;
if (SysRoleService.IsAdmin(userId)) if (SysRoleService.IsAdmin(userId))
{ {
menuList = MenuRepository.SelectMenuList(menu); menuList = SelectAllMenuList(menu);
} }
else else
{ {
var userRoles = SysRoleService.SelectUserRoles(userId); var userRoles = SysRoleService.SelectUserRoles(userId);
menuList = MenuRepository.SelectMenuListByRoles(menu, userRoles); menuList = SelectMenuListByRoles(menu, userRoles);
} }
return menuList; return menuList;
} }
@ -73,17 +70,29 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public SysMenu GetMenuByMenuId(int menuId) public SysMenu GetMenuByMenuId(int menuId)
{ {
return MenuRepository.SelectMenuById(menuId); return GetFirst(it => it.MenuId == menuId);
} }
/// <summary> /// <summary>
/// 根据菜单id获取菜单列表 /// 根据菜单id获取菜单列表
/// </summary> /// </summary>
/// <param name="menuId"></param> /// <param name="menuId"></param>
/// <param name="userId"></param>
/// <returns></returns> /// <returns></returns>
public List<SysMenu> GetMenusByMenuId(int menuId) public List<SysMenu> GetMenusByMenuId(int menuId, long userId)
{ {
var list = MenuRepository.GetList(f => f.ParentId == menuId).OrderBy(f => f.OrderNum).ToList(); var menuExpression = Expressionable.Create<SysMenu>();
menuExpression.And(c => c.ParentId == menuId);
if (!SysRoleService.IsAdmin(userId))
{
var userRoles = SysRoleService.SelectUserRoles(userId);
var roleMenus = Context.Queryable<SysRoleMenu>()
.Where(r => userRoles.Contains(r.Role_id)).Select(s => s.Menu_id).ToList();
menuExpression.And(c => roleMenus.Contains(c.MenuId));
}
var list = GetList(menuExpression.ToExpression()).OrderBy(f => f.OrderNum).ToList();
Context.ThenMapper(list, item => Context.ThenMapper(list, item =>
{ {
item.SubNum = Context.Queryable<SysMenu>().SetContext(x => x.ParentId, () => item.MenuId, item).Count; item.SubNum = Context.Queryable<SysMenu>().SetContext(x => x.ParentId, () => item.MenuId, item).Count;
@ -98,7 +107,8 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public int AddMenu(SysMenu menu) public int AddMenu(SysMenu menu)
{ {
return MenuRepository.AddMenu(menu); menu.Create_time = DateTime.Now;
return InsertReturnIdentity(menu);
} }
/// <summary> /// <summary>
@ -109,7 +119,7 @@ namespace ZR.Service
public int EditMenu(SysMenu menu) public int EditMenu(SysMenu menu)
{ {
menu.Icon = string.IsNullOrEmpty(menu.Icon) ? "" : menu.Icon; menu.Icon = string.IsNullOrEmpty(menu.Icon) ? "" : menu.Icon;
return MenuRepository.EditMenu(menu); return Update(menu, false);
} }
/// <summary> /// <summary>
@ -119,7 +129,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public int DeleteMenuById(int menuId) public int DeleteMenuById(int menuId)
{ {
return MenuRepository.DeleteMenuById(menuId); return Delete(menuId);
} }
/// <summary> /// <summary>
@ -130,7 +140,7 @@ namespace ZR.Service
public string CheckMenuNameUnique(SysMenu menu) public string CheckMenuNameUnique(SysMenu menu)
{ {
long menuId = menu.MenuId == 0 ? -1 : menu.MenuId; long menuId = menu.MenuId == 0 ? -1 : menu.MenuId;
SysMenu info = MenuRepository.CheckMenuNameUnique(menu); SysMenu info = GetFirst(it => it.MenuName == menu.MenuName && it.ParentId == menu.ParentId);
//if (info != null && menuId != info.menuId && menu.menuName.Equals(info.menuName)) //if (info != null && menuId != info.menuId && menu.menuName.Equals(info.menuName))
//{ //{
@ -146,11 +156,11 @@ namespace ZR.Service
/// <summary> /// <summary>
/// 菜单排序 /// 菜单排序
/// </summary> /// </summary>
/// <param name="menuId"></param> /// <param name="menuDto"></param>
/// <returns></returns> /// <returns></returns>
public int ChangeSortMenu(MenuDto menuDto) public int ChangeSortMenu(MenuDto menuDto)
{ {
return MenuRepository.ChangeSortMenu(menuDto); return Update(new SysMenu() { MenuId = menuDto.MenuId, OrderNum = menuDto.OrderNum }, it => new { it.OrderNum });
} }
/// <summary> /// <summary>
@ -160,7 +170,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public bool HasChildByMenuId(long menuId) public bool HasChildByMenuId(long menuId)
{ {
return MenuRepository.HasChildByMenuId(menuId) > 0; return Count(it => it.ParentId == menuId) > 0;
} }
/// <summary> /// <summary>
@ -173,25 +183,15 @@ namespace ZR.Service
MenuQueryDto dto = new() { Status = "0", MenuTypeIds = "M,C" }; MenuQueryDto dto = new() { Status = "0", MenuTypeIds = "M,C" };
if (SysRoleService.IsAdmin(userId)) if (SysRoleService.IsAdmin(userId))
{ {
return MenuRepository.SelectTreeMenuList(dto); return SelectTreeMenuList(dto);
} }
else else
{ {
List<long> roleIds = SysRoleService.SelectUserRoles(userId); List<long> roleIds = SysRoleService.SelectUserRoles(userId);
return MenuRepository.SelectTreeMenuListByRoles(dto, roleIds); return SelectTreeMenuListByRoles(dto, roleIds);
} }
} }
/// <summary>
/// 查询菜单权限
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public List<SysMenu> SelectMenuPermsListByUserId(long userId)
{
return MenuRepository.SelectMenuPermsByUserId(userId);
}
/// <summary> /// <summary>
/// 查询精确到按钮的操作权限 /// 查询精确到按钮的操作权限
/// </summary> /// </summary>
@ -199,25 +199,96 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public List<string> SelectMenuPermsByUserId(long userId) public List<string> SelectMenuPermsByUserId(long userId)
{ {
var menuList = SelectMenuPermsListByUserId(userId).Where(f => !string.IsNullOrEmpty(f.Perms)); var menus = Context.Queryable<SysMenu, SysRoleMenu, SysUserRole, SysRole>((m, rm, ur, r) => new JoinQueryInfos(
JoinType.Left, m.MenuId == rm.Menu_id,
JoinType.Left, rm.Role_id == ur.RoleId,
JoinType.Left, ur.RoleId == r.RoleId
))
.Where((m, rm, ur, r) => m.Status == "0" && r.Status == "0" && ur.UserId == userId)
.Select((m, rm, ur, r) => m).ToList();
var menuList = menus.Where(f => !string.IsNullOrEmpty(f.Perms));
return menuList.Select(x => x.Perms).Distinct().ToList(); return menuList.Select(x => x.Perms).Distinct().ToList();
} }
#region RoleMenu
/// <summary> /// <summary>
/// 查询菜单使用数量 /// 根据用户查询系统菜单列表
/// </summary> /// </summary>
/// <param name="menuId"></param> /// <param name="menu"></param>
/// <param name="roles">用户角色集合</param>
/// <returns></returns> /// <returns></returns>
public bool CheckMenuExistRole(long menuId) private List<SysMenu> SelectTreeMenuListByRoles(MenuQueryDto menu, List<long> roles)
{ {
return MenuRepository.CheckMenuExistRole(menuId) > 0; var roleMenus = Context.Queryable<SysRoleMenu>()
.Where(r => roles.Contains(r.Role_id))
.Select(f => f.Menu_id).Distinct().ToList();
return Queryable()
.Where(c => roleMenus.Contains(c.MenuId))
.WhereIF(!string.IsNullOrEmpty(menu.MenuName), (c) => c.MenuName.Contains(menu.MenuName))
.WhereIF(!string.IsNullOrEmpty(menu.Visible), (c) => c.Visible == menu.Visible)
.WhereIF(!string.IsNullOrEmpty(menu.Status), (c) => c.Status == menu.Status)
.WhereIF(!string.IsNullOrEmpty(menu.MenuTypeIds), c => menu.MenuTypeIdArr.Contains(c.MenuType))
.OrderBy((c) => new { c.ParentId, c.OrderNum })
.Select(c => c)
.ToTree(it => it.Children, it => it.ParentId, 0);
} }
#endregion /// <summary>
/// 获取所有菜单
/// </summary>
/// <returns></returns>
private List<SysMenu> SelectAllMenuList(MenuQueryDto menu)
{
return Queryable()
.WhereIF(!string.IsNullOrEmpty(menu.MenuName), it => it.MenuName.Contains(menu.MenuName))
.WhereIF(!string.IsNullOrEmpty(menu.Visible), it => it.Visible == menu.Visible)
.WhereIF(!string.IsNullOrEmpty(menu.Status), it => it.Status == menu.Status)
.WhereIF(menu.ParentId != null, it => it.ParentId == menu.ParentId)
.OrderBy(it => new { it.ParentId, it.OrderNum })
.ToList();
}
/// <summary>
/// 根据用户查询系统菜单列表
/// </summary>
/// <param name="sysMenu"></param>
/// <param name="roles">用户角色集合</param>
/// <returns></returns>
private List<SysMenu> SelectMenuListByRoles(MenuQueryDto sysMenu, List<long> roles)
{
var roleMenus = Context.Queryable<SysRoleMenu>()
.Where(r => roles.Contains(r.Role_id));
return Queryable()
.InnerJoin(roleMenus, (c, j) => c.MenuId == j.Menu_id)
.Where((c, j) => c.Status == "0")
.WhereIF(!string.IsNullOrEmpty(sysMenu.MenuName), (c, j) => c.MenuName.Contains(sysMenu.MenuName))
.WhereIF(!string.IsNullOrEmpty(sysMenu.Visible), (c, j) => c.Visible == sysMenu.Visible)
.OrderBy((c, j) => new { c.ParentId, c.OrderNum })
.Select(c => c)
.ToList();
}
/// <summary>
/// 获取所有菜单（菜单管理）
/// </summary>
/// <returns></returns>
public List<SysMenu> SelectTreeMenuList(MenuQueryDto menu)
{
int parentId = menu.ParentId != null ? (int)menu.ParentId : 0;
var list = Queryable()
.WhereIF(!string.IsNullOrEmpty(menu.MenuName), it => it.MenuName.Contains(menu.MenuName))
.WhereIF(!string.IsNullOrEmpty(menu.Visible), it => it.Visible == menu.Visible)
.WhereIF(!string.IsNullOrEmpty(menu.Status), it => it.Status == menu.Status)
.WhereIF(!string.IsNullOrEmpty(menu.MenuTypeIds), it => menu.MenuTypeIdArr.Contains(it.MenuType))
.WhereIF(menu.ParentId != null, it => it.ParentId == menu.ParentId)
.OrderBy(it => new { it.ParentId, it.OrderNum })
.ToTree(it => it.Children, it => it.ParentId, parentId);
return list;
}
#region 方法 #region 方法
///// <summary> ///// <summary>

50
ZR.Service/System/SysRoleMenuService.cs Normal file
View File

@ -0,0 +1,50 @@
using Infrastructure.Attribute;
using System.Collections.Generic;
using System.Linq;
using ZR.Model.System;
using ZR.Service.System.IService;
namespace ZR.Service.System
{
/// <summary>
/// 角色菜单
/// </summary>
[AppService(ServiceType = typeof(ISysRoleMenuService), ServiceLifetime = LifeTime.Transient)]
public class SysRoleMenuService : BaseService<SysRoleMenu>, ISysRoleMenuService
{
public int AddRoleMenu(List<SysRoleMenu> sysRoleMenus)
{
return Insert(sysRoleMenus);
}
public bool CheckMenuExistRole(long menuId)
{
return Count(it => it.Menu_id == menuId) > 0;
}
public int DeleteRoleMenuByRoleId(long roleId)
{
return Delete(roleId);
}
/// <summary>
/// 根据角色获取菜单id
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public List<SysRoleMenu> SelectRoleMenuByRoleId(long roleId)
{
return GetList(f => f.Role_id == roleId);
}
/// <summary>
/// 根据用户所有角色获取菜单
/// </summary>
/// <param name="roleIds"></param>
/// <returns></returns>
public List<SysRoleMenu> SelectRoleMenuByRoleIds(long[] roleIds)
{
return GetList(it => roleIds.Contains(it.Role_id));
}
}
}

100
ZR.Service/System/SysRoleService.cs
View File

@ -1,14 +1,13 @@
using Infrastructure; using Infrastructure;
using Infrastructure.Attribute; using Infrastructure.Attribute;
using Infrastructure.Model; using SqlSugar;
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text;
using ZR.Model; using ZR.Model;
using ZR.Model.System; using ZR.Model.System;
using ZR.Repository.System; using ZR.Repository;
using ZR.Service.System.IService; using ZR.Service.System.IService;
namespace ZR.Service namespace ZR.Service
@ -19,29 +18,43 @@ namespace ZR.Service
[AppService(ServiceType = typeof(ISysRoleService), ServiceLifetime = LifeTime.Transient)] [AppService(ServiceType = typeof(ISysRoleService), ServiceLifetime = LifeTime.Transient)]
public class SysRoleService : BaseService<SysRole>, ISysRoleService public class SysRoleService : BaseService<SysRole>, ISysRoleService
{ {
private SysRoleRepository SysRoleRepository;
private ISysUserRoleService SysUserRoleService; private ISysUserRoleService SysUserRoleService;
private ISysDeptService DeptService; private ISysDeptService DeptService;
private ISysRoleMenuService RoleMenuService;
public SysRoleService( public SysRoleService(
SysRoleRepository sysRoleRepository,
ISysUserRoleService sysUserRoleService, ISysUserRoleService sysUserRoleService,
ISysDeptService deptService) ISysDeptService deptService,
ISysRoleMenuService roleMenuService)
{ {
SysRoleRepository = sysRoleRepository;
SysUserRoleService = sysUserRoleService; SysUserRoleService = sysUserRoleService;
DeptService = deptService; DeptService = deptService;
RoleMenuService = roleMenuService;
} }
/// <summary> /// <summary>
/// 根据条件分页查询角色数据 /// 根据条件分页查询角色数据
/// </summary> /// </summary>
/// <param name="role">角色信息</param> /// <param name="sysRole">角色信息</param>
/// <param name="pager">分页信息</param> /// <param name="pager">分页信息</param>
/// <returns>角色数据集合信息</returns> /// <returns>角色数据集合信息</returns>
public PagedInfo<SysRole> SelectRoleList(SysRole role, PagerInfo pager) public PagedInfo<SysRole> SelectRoleList(SysRole sysRole, PagerInfo pager)
{ {
return SysRoleRepository.SelectRoleList(role, pager); var exp = Expressionable.Create<SysRole>();
exp.And(role => role.DelFlag == "0");
exp.AndIF(!string.IsNullOrEmpty(sysRole.RoleName), role => role.RoleName.Contains(sysRole.RoleName));
exp.AndIF(!string.IsNullOrEmpty(sysRole.Status), role => role.Status == sysRole.Status);
exp.AndIF(!string.IsNullOrEmpty(sysRole.RoleKey), role => role.RoleKey == sysRole.RoleKey);
var query = Context.Queryable<SysRole>()
.Where(exp.ToExpression())
.OrderBy(x => x.RoleSort)
.Select((role) => new SysRole
{
RoleId = role.RoleId.SelectAll(),
UserNum = SqlFunc.Subqueryable<SysUserRole>().Where(f => f.RoleId == role.RoleId).Count()
});
return query.ToPage(pager);
} }
/// <summary> /// <summary>
@ -50,7 +63,10 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public List<SysRole> SelectRoleAll() public List<SysRole> SelectRoleAll()
{ {
return SysRoleRepository.SelectRoleList(); return Queryable()
.Where(role => role.DelFlag == "0")
.OrderBy(role => role.RoleSort)
.ToList();
} }
/// <summary> /// <summary>
@ -60,7 +76,11 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public List<SysRole> SelectRolePermissionByUserId(long userId) public List<SysRole> SelectRolePermissionByUserId(long userId)
{ {
return SysRoleRepository.SelectRolePermissionByUserId(userId); return Queryable()
.Where(role => role.DelFlag == "0")
.Where(it => SqlFunc.Subqueryable<SysUserRole>().Where(s => s.UserId == userId).Any())
.OrderBy(role => role.RoleSort)
.ToList();
} }
/// <summary> /// <summary>
@ -70,7 +90,7 @@ namespace ZR.Service
/// <returns>角色对象信息</returns> /// <returns>角色对象信息</returns>
public SysRole SelectRoleById(long roleId) public SysRole SelectRoleById(long roleId)
{ {
return SysRoleRepository.SelectRoleById(roleId); return GetId(roleId);
} }
/// <summary> /// <summary>
@ -89,17 +109,17 @@ namespace ZR.Service
throw new CustomException($"{role.RoleName}已分配,不能删除"); throw new CustomException($"{role.RoleName}已分配,不能删除");
} }
} }
return SysRoleRepository.DeleteRoleByRoleIds(roleIds); return Delete(roleIds);
} }
/// <summary> /// <summary>
/// 更改角色权限状态 /// 更改角色权限状态
/// </summary> /// </summary>
/// <param name="SysRoleDto"></param> /// <param name="roleDto"></param>
/// <returns></returns> /// <returns></returns>
public int UpdateRoleStatus(SysRole roleDto) public int UpdateRoleStatus(SysRole roleDto)
{ {
return SysRoleRepository.UpdateRoleStatus(roleDto); return Update(roleDto, it => new { it.Status }, f => f.RoleId == roleDto.RoleId);
} }
/// <summary> /// <summary>
@ -110,7 +130,7 @@ namespace ZR.Service
public string CheckRoleKeyUnique(SysRole sysRole) public string CheckRoleKeyUnique(SysRole sysRole)
{ {
long roleId = 0 == sysRole.RoleId ? -1L : sysRole.RoleId; long roleId = 0 == sysRole.RoleId ? -1L : sysRole.RoleId;
SysRole info = SysRoleRepository.CheckRoleKeyUnique(sysRole.RoleKey); SysRole info = GetFirst(it => it.RoleKey == sysRole.RoleKey);
if (info != null && info.RoleId != roleId) if (info != null && info.RoleId != roleId)
{ {
return UserConstants.NOT_UNIQUE; return UserConstants.NOT_UNIQUE;
@ -137,7 +157,8 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public long InsertRole(SysRole sysRole) public long InsertRole(SysRole sysRole)
{ {
sysRole.RoleId = SysRoleRepository.InsertRole(sysRole); sysRole.Create_time = DateTime.Now;
sysRole.RoleId = InsertReturnBigIdentity(sysRole);
//插入角色部门数据 //插入角色部门数据
DeptService.InsertRoleDepts(sysRole); DeptService.InsertRoleDepts(sysRole);
@ -151,7 +172,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public int DeleteRoleMenuByRoleId(long roleId) public int DeleteRoleMenuByRoleId(long roleId)
{ {
return SysRoleRepository.DeleteRoleMenuByRoleId(roleId); return RoleMenuService.DeleteRoleMenuByRoleId(roleId);
} }
/// <summary> /// <summary>
@ -195,7 +216,7 @@ namespace ZR.Service
//添加角色菜单 //添加角色菜单
if (sysRoleMenus.Count > 0) if (sysRoleMenus.Count > 0)
{ {
rows = SysRoleRepository.AddRoleMenu(sysRoleMenus); rows = RoleMenuService.AddRoleMenu(sysRoleMenus);
} }
return rows; return rows;
@ -210,7 +231,7 @@ namespace ZR.Service
{ {
List<string> roles = SelectUserRoleKeys(userid); List<string> roles = SelectUserRoleKeys(userid);
return ((IList)roles).Contains("admin"); return ((IList)roles).Contains(GlobalConstant.AdminRole);
} }
/// <summary> /// <summary>
@ -232,7 +253,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public List<long> SelectUserRoleMenus(long roleId) public List<long> SelectUserRoleMenus(long roleId)
{ {
var list = SysRoleRepository.SelectRoleMenuByRoleId(roleId); var list = RoleMenuService.SelectRoleMenuByRoleId(roleId);
return list.Select(x => x.Menu_id).Distinct().ToList(); return list.Select(x => x.Menu_id).Distinct().ToList();
} }
@ -244,7 +265,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public List<long> SelectRoleMenuByRoleIds(long[] roleIds) public List<long> SelectRoleMenuByRoleIds(long[] roleIds)
{ {
return SysRoleRepository.SelectRoleMenuByRoleIds(roleIds) return RoleMenuService.SelectRoleMenuByRoleIds(roleIds)
.Select(x => x.Menu_id) .Select(x => x.Menu_id)
.Distinct().ToList(); .Distinct().ToList();
} }
@ -256,7 +277,10 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public List<SysRole> SelectUserRoleListByUserId(long userId) public List<SysRole> SelectUserRoleListByUserId(long userId)
{ {
return SysRoleRepository.SelectUserRoleListByUserId(userId); return Context.Queryable<SysUserRole, SysRole>((ur, r) => new JoinQueryInfos(
JoinType.Left, ur.RoleId == r.RoleId
)).Where((ur, r) => ur.UserId == userId)
.Select((ur, r) => r).ToList();
} }
/// <summary> /// <summary>
@ -304,7 +328,7 @@ namespace ZR.Service
var result = UseTran(() => var result = UseTran(() =>
{ {
//修改角色信息 //修改角色信息
SysRoleRepository.UpdateSysRole(sysRole); UpdateSysRole(sysRole);
//删除角色与部门管理 //删除角色与部门管理
DeptService.DeleteRoleDeptByRoleId(sysRole.RoleId); DeptService.DeleteRoleDeptByRoleId(sysRole.RoleId);
//插入角色部门数据 //插入角色部门数据
@ -313,5 +337,29 @@ namespace ZR.Service
return result.IsSuccess ? 1 : 0; return result.IsSuccess ? 1 : 0;
} }
/// <summary>
/// 修改用户角色
/// </summary>
/// <param name="sysRole"></param>
/// <returns></returns>
public int UpdateSysRole(SysRole sysRole)
{
var db = Context;
sysRole.Update_time = db.GetDate();
return db.Updateable<SysRole>()
.SetColumns(it => it.Update_time == sysRole.Update_time)
.SetColumns(it => it.DataScope == sysRole.DataScope)
.SetColumns(it => it.Remark == sysRole.Remark)
.SetColumns(it => it.Update_by == sysRole.Update_by)
//.SetColumns(it => it.MenuCheckStrictly == sysRole.MenuCheckStrictly)
.SetColumns(it => it.DeptCheckStrictly == sysRole.DeptCheckStrictly)
.SetColumnsIF(!string.IsNullOrEmpty(sysRole.RoleName), it => it.RoleName == sysRole.RoleName)
.SetColumnsIF(!string.IsNullOrEmpty(sysRole.RoleKey), it => it.RoleKey == sysRole.RoleKey)
.SetColumnsIF(sysRole.RoleSort >= 0, it => it.RoleSort == sysRole.RoleSort)
.Where(it => it.RoleId == sysRole.RoleId)
.ExecuteCommand();
}
} }
} }

43
ZR.Service/System/SysUserRoleService.cs
View File

@ -1,9 +1,11 @@
using Infrastructure.Attribute; using Infrastructure.Attribute;
using Infrastructure.Extensions;
using SqlSugar;
using System.Collections.Generic; using System.Collections.Generic;
using ZR.Model; using ZR.Model;
using ZR.Model.System; using ZR.Model.System;
using ZR.Model.System.Dto; using ZR.Model.System.Dto;
using ZR.Repository.System; using ZR.Repository;
using ZR.Service.System.IService; using ZR.Service.System.IService;
namespace ZR.Service.System namespace ZR.Service.System
@ -14,12 +16,12 @@ namespace ZR.Service.System
[AppService(ServiceType = typeof(ISysUserRoleService), ServiceLifetime = LifeTime.Transient)] [AppService(ServiceType = typeof(ISysUserRoleService), ServiceLifetime = LifeTime.Transient)]
public class SysUserRoleService : BaseService<SysUserRole>, ISysUserRoleService public class SysUserRoleService : BaseService<SysUserRole>, ISysUserRoleService
{ {
public SysUserRoleRepository SysUserRoleRepository; //public SysUserRoleRepository SysUserRoleRepository;
public SysUserRoleService(SysUserRoleRepository sysUserRoleRepository) //public SysUserRoleService(SysUserRoleRepository sysUserRoleRepository)
{ //{
SysUserRoleRepository = sysUserRoleRepository; // SysUserRoleRepository = sysUserRoleRepository;
} //}
/// <summary> /// <summary>
/// 通过角色ID查询角色使用数量 /// 通过角色ID查询角色使用数量
@ -38,7 +40,7 @@ namespace ZR.Service.System
/// <returns></returns> /// <returns></returns>
public int DeleteUserRoleByUserId(int userId) public int DeleteUserRoleByUserId(int userId)
{ {
return Deleteable().Where(it => it.UserId == userId).ExecuteCommand(); return Delete(it => it.UserId == userId) ? 1 : 0;
} }
/// <summary> /// <summary>
@ -49,7 +51,7 @@ namespace ZR.Service.System
/// <returns></returns> /// <returns></returns>
public int DeleteRoleUserByUserIds(long roleId, List<long> userIds) public int DeleteRoleUserByUserIds(long roleId, List<long> userIds)
{ {
return SysUserRoleRepository.DeleteRoleUserByUserIds(roleId, userIds); return Delete(it => it.RoleId == roleId && userIds.Contains(it.UserId)) ? 1 : 0;
} }
/// <summary> /// <summary>
@ -69,7 +71,11 @@ namespace ZR.Service.System
/// <returns></returns> /// <returns></returns>
public List<SysUser> GetSysUsersByRoleId(long roleId) public List<SysUser> GetSysUsersByRoleId(long roleId)
{ {
return SysUserRoleRepository.GetSysUsersByRoleId(roleId); return Context.Queryable<SysUserRole, SysUser > ((t1, u) => new JoinQueryInfos(
JoinType.Left, t1.UserId == u.UserId))
.Where((t1, u) => t1.RoleId == roleId && u.DelFlag == "0")
.Select((t1, u) => u)
.ToList();
} }
/// <summary> /// <summary>
@ -79,7 +85,15 @@ namespace ZR.Service.System
/// <returns></returns> /// <returns></returns>
public PagedInfo<SysUser> GetSysUsersByRoleId(RoleUserQueryDto roleUserQueryDto) public PagedInfo<SysUser> GetSysUsersByRoleId(RoleUserQueryDto roleUserQueryDto)
{ {
return SysUserRoleRepository.GetSysUsersByRoleId(roleUserQueryDto); //return SysUserRoleRepository.GetSysUsersByRoleId(roleUserQueryDto);
var query = Context.Queryable<SysUserRole, SysUser>((t1, u) => new JoinQueryInfos(
JoinType.Left, t1.UserId == u.UserId))
.Where((t1, u) => t1.RoleId == roleUserQueryDto.RoleId && u.DelFlag == "0");
if (!string.IsNullOrEmpty(roleUserQueryDto.UserName))
{
query = query.Where((t1, u) => u.UserName.Contains(roleUserQueryDto.UserName));
}
return query.Select((t1, u) => u).ToPage(roleUserQueryDto);
} }
/// <summary> /// <summary>
@ -89,7 +103,12 @@ namespace ZR.Service.System
/// <returns></returns> /// <returns></returns>
public PagedInfo<SysUser> GetExcludedSysUsersByRoleId(RoleUserQueryDto roleUserQueryDto) public PagedInfo<SysUser> GetExcludedSysUsersByRoleId(RoleUserQueryDto roleUserQueryDto)
{ {
return SysUserRoleRepository.GetExcludedSysUsersByRoleId(roleUserQueryDto); var query = Context.Queryable<SysUser>()
.Where(it => it.DelFlag == "0")
.Where(it => SqlFunc.Subqueryable<SysUserRole>().Where(s => s.UserId == it.UserId && s.RoleId == roleUserQueryDto.RoleId).NotAny())
.WhereIF(roleUserQueryDto.UserName.IsNotEmpty(), it => it.UserName.Contains(roleUserQueryDto.UserName));
return query.ToPage(roleUserQueryDto);
} }
/// <summary> /// <summary>
@ -115,7 +134,7 @@ namespace ZR.Service.System
/// <returns></returns> /// <returns></returns>
public int InsertRoleUser(RoleUsersCreateDto roleUsersCreateDto) public int InsertRoleUser(RoleUsersCreateDto roleUsersCreateDto)
{ {
List<SysUserRole> userRoles = new List<SysUserRole>(); List<SysUserRole> userRoles = new();
foreach (var item in roleUsersCreateDto.UserIds) foreach (var item in roleUsersCreateDto.UserIds)
{ {
userRoles.Add(new SysUserRole() { RoleId = roleUsersCreateDto.RoleId, UserId = item }); userRoles.Add(new SysUserRole() { RoleId = roleUsersCreateDto.RoleId, UserId = item });

99
ZR.Service/System/SysUserService.cs
View File

@ -1,17 +1,16 @@
using Infrastructure; using Infrastructure;
using Infrastructure.Attribute; using Infrastructure.Attribute;
using Infrastructure.Extensions; using Infrastructure.Extensions;
using Microsoft.AspNetCore.Http; using SqlSugar;
using System; using System;
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text;
using ZR.Common; using ZR.Common;
using ZR.Model; using ZR.Model;
using ZR.Model.System; using ZR.Model.System;
using ZR.Model.System.Dto; using ZR.Model.System.Dto;
using ZR.Repository.System; using ZR.Repository;
using ZR.Service.System.IService; using ZR.Service.System.IService;
namespace ZR.Service namespace ZR.Service
@ -22,18 +21,15 @@ namespace ZR.Service
[AppService(ServiceType = typeof(ISysUserService), ServiceLifetime = LifeTime.Transient)] [AppService(ServiceType = typeof(ISysUserService), ServiceLifetime = LifeTime.Transient)]
public class SysUserService : BaseService<SysUser>, ISysUserService public class SysUserService : BaseService<SysUser>, ISysUserService
{ {
private readonly SysUserRepository UserRepository;
private readonly ISysRoleService RoleService; private readonly ISysRoleService RoleService;
private readonly ISysUserRoleService UserRoleService; private readonly ISysUserRoleService UserRoleService;
private readonly ISysUserPostService UserPostService; private readonly ISysUserPostService UserPostService;
public SysUserService( public SysUserService(
SysUserRepository userRepository,
ISysRoleService sysRoleService, ISysRoleService sysRoleService,
ISysUserRoleService userRoleService, ISysUserRoleService userRoleService,
ISysUserPostService userPostService) ISysUserPostService userPostService)
{ {
UserRepository = userRepository;
RoleService = sysRoleService; RoleService = sysRoleService;
UserRoleService = userRoleService; UserRoleService = userRoleService;
UserPostService = userPostService; UserPostService = userPostService;
@ -45,9 +41,36 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public PagedInfo<SysUser> SelectUserList(SysUser user, PagerInfo pager) public PagedInfo<SysUser> SelectUserList(SysUser user, PagerInfo pager)
{ {
var list = UserRepository.SelectUserList(user, pager); var exp = Expressionable.Create<SysUser>();
exp.AndIF(!string.IsNullOrEmpty(user.UserName), u => u.UserName.Contains(user.UserName));
exp.AndIF(!string.IsNullOrEmpty(user.Status), u => u.Status == user.Status);
exp.AndIF(user.BeginTime != DateTime.MinValue && user.BeginTime != null, u => u.Create_time >= user.BeginTime);
exp.AndIF(user.EndTime != DateTime.MinValue && user.EndTime != null, u => u.Create_time <= user.EndTime);
exp.AndIF(!user.Phonenumber.IsEmpty(), u => u.Phonenumber == user.Phonenumber);
exp.And(u => u.DelFlag == "0");
return list; if (user.DeptId != 0)
{
List<SysDept> depts = Context.Queryable<SysDept>().ToList();
var newDepts = depts.FindAll(delegate (SysDept dept)
{
string[] parentDeptId = dept.Ancestors.Split(",", StringSplitOptions.RemoveEmptyEntries);
return parentDeptId.Contains(user.DeptId.ToString());
});
string[] deptArr = newDepts.Select(x => x.DeptId.ToString()).ToArray();
exp.AndIF(user.DeptId != 0, u => u.DeptId == user.DeptId || deptArr.Contains(u.DeptId.ToString()));
}
var query = Queryable()
.LeftJoin<SysDept>((u, dept) => u.DeptId == dept.DeptId)
.Where(exp.ToExpression())
.Select((u, dept) => new SysUser
{
UserId = u.UserId.SelectAll(),
DeptName = dept.DeptName,
});
return query.ToPage(pager);
} }
/// <summary> /// <summary>
@ -57,7 +80,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public SysUser SelectUserById(long userId) public SysUser SelectUserById(long userId)
{ {
var user = UserRepository.SelectUserById(userId); var user = Queryable().Filter(null, true).Where(f => f.UserId == userId).First();
if (user != null && user.UserId > 0) if (user != null && user.UserId > 0)
{ {
user.Roles = RoleService.SelectUserRoleListByUserId(userId); user.Roles = RoleService.SelectUserRoleListByUserId(userId);
@ -73,7 +96,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public string CheckUserNameUnique(string userName) public string CheckUserNameUnique(string userName)
{ {
int count = UserRepository.CheckUserNameUnique(userName); int count = Count(it => it.UserName == userName);
if (count > 0) if (count > 0)
{ {
return UserConstants.NOT_UNIQUE; return UserConstants.NOT_UNIQUE;
@ -88,7 +111,8 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public long InsertUser(SysUser sysUser) public long InsertUser(SysUser sysUser)
{ {
long userId = UserRepository.AddUser(sysUser); sysUser.Create_time = DateTime.Now;
long userId = Insertable(sysUser).ExecuteReturnIdentity();
sysUser.UserId = userId; sysUser.UserId = userId;
//新增用户角色信息 //新增用户角色信息
UserRoleService.InsertUserRole(sysUser); UserRoleService.InsertUserRole(sysUser);
@ -119,12 +143,25 @@ namespace ZR.Service
UserPostService.Delete(user.UserId); UserPostService.Delete(user.UserId);
// 新增用户与岗位管理 // 新增用户与岗位管理
UserPostService.InsertUserPost(user); UserPostService.InsertUserPost(user);
return UserRepository.UpdateUser(user); return ChangeUser(user);
} }
public int ChangeUser(SysUser user) public int ChangeUser(SysUser user)
{ {
return UserRepository.UpdateUser(user); user.Update_time = DateTime.Now;
return Update(user, t => new
{
t.NickName,
t.Email,
t.Phonenumber,
t.DeptId,
t.Status,
t.Sex,
t.PostIds,
t.Remark,
t.Update_by,
t.Update_time
}, true);
} }
/// <summary> /// <summary>
@ -135,12 +172,17 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public int ResetPwd(long userid, string password) public int ResetPwd(long userid, string password)
{ {
return UserRepository.ResetPwd(userid, password); return Update(new SysUser() { UserId = userid, Password = password }, it => new { it.Password }, f => f.UserId == userid);
} }
/// <summary>
/// 修改用户状态
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public int ChangeUserStatus(SysUser user) public int ChangeUserStatus(SysUser user)
{ {
return UserRepository.ChangeUserStatus(user); return Update(user, it => new { it.Status }, f => f.UserId == user.UserId);
} }
/// <summary> /// <summary>
@ -155,7 +197,7 @@ namespace ZR.Service
UserRoleService.DeleteUserRoleByUserId((int)userid); UserRoleService.DeleteUserRoleByUserId((int)userid);
// 删除用户与岗位关联 // 删除用户与岗位关联
UserPostService.Delete(userid); UserPostService.Delete(userid);
return UserRepository.DeleteUser(userid); return Update(new SysUser() { UserId = userid, DelFlag = "2" }, it => new { it.DelFlag }, f => f.UserId == userid);
} }
/// <summary> /// <summary>
@ -165,7 +207,7 @@ namespace ZR.Service
/// <returns></returns> /// <returns></returns>
public int UpdatePhoto(SysUser user) public int UpdatePhoto(SysUser user)
{ {
return UserRepository.UpdatePhoto(user); return Update(user, it => new { it.Avatar }, f => f.UserId == user.UserId); ;
} }
/// <summary> /// <summary>
@ -192,7 +234,7 @@ namespace ZR.Service
Remark = "用户注册" Remark = "用户注册"
}; };
user.UserId = UserRepository.AddUser(user); user.UserId = Insertable(user).ExecuteReturnIdentity();
return user; return user;
} }
@ -265,5 +307,26 @@ namespace ZR.Service
return msg; return msg;
} }
/// <summary>
/// 登录
/// </summary>
/// <param name="user">登录实体</param>
/// <returns></returns>
public SysUser Login(LoginBodyDto user)
{
return GetFirst(it => it.UserName == user.Username && it.Password == user.Password);
}
/// <summary>
/// 修改登录信息
/// </summary>
/// <param name="user"></param>
/// <param name="userId"></param>
/// <returns></returns>
public void UpdateLoginInfo(LoginBodyDto user, long userId)
{
Update(new SysUser() { LoginIP = user.LoginIP, LoginDate = DateTime.Now, UserId = userId },it => new { it.LoginIP, it.LoginDate });
}
} }
} }