devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Asp.Net Core 7.0 基于JWT组织用户角色权限认证（二）_net core jwt 角色、权限设计

作者：笔触狂放9 | 2024-08-16 21:18:32

赞

踩

net core jwt 角色、权限设计

前言：

上一篇我们已经完成了权限校验以及授权的部分，本篇接下来我们分析一下如何基于组织用户角色进行权限管理。

在本项目中，支持建立多组织，同一用户支持在不同组织下授予不同的角色。由于本人是新人，如果有好的见解或者看法欢迎和我沟通，互相学习进步。

数据库表：

数据库：MYSQL，使用EF-CORE基于仓储模式来进行数据库管理。
该项目管理表之间的关联关系主要是用第三张表来管理，相对来说比较好理解。
结构：

Entity 实体结构：

Manager模块（核心逻辑）：

1. PermissionManager
  1. using AutoMapper;
  2. using Microsoft.Extensions.Logging;
  3. using Newtonsoft.Json;
  4. using org.huage.AuthManagement.BizManager.Redis;
  5. using org.huage.AuthManagement.BizManager.wrapper;
  6. using org.huage.AuthManagement.DataBase.Table;
  7. using org.huage.AuthManagement.Entity.Managers;
  8. using org.huage.AuthManagement.Entity.Model;
  9. using org.huage.AuthManagement.Entity.Request;
  10. using org.huage.AuthManagement.Entity.Response;
  11.  
  12. namespace org.huage.AuthManagement.BizManager.Manager;
  13.  
  14. //权限管理
  15. public class PermissionManager : IPermissionManager
  16. {
  17.     private readonly IRepositoryWrapper _wrapper;
  18.     private readonly IRedisManager _redisManager;
  19.     private readonly ILogger<PermissionManager> _logger;
  20.     private readonly IMapper _mapper;
  21.  
  22.     public PermissionManager(IRepositoryWrapper wrapper, IRedisManager redisManager, ILogger<PermissionManager> logger, IMapper mapper)
  23.     {
  24.         _wrapper = wrapper;
  25.         _redisManager = redisManager;
  26.         _logger = logger;
  27.         _mapper = mapper;
  28.     }
  29.  
  30.     /// <summary>
  31.     /// 查询所有的权限信息。
  32.     /// </summary>
  33.     /// <returns></returns>
  34.     public async Task<QueryAllPermissionResponse> QueryAllPermissionAsync()
  35.     {
  36.         var response = new QueryAllPermissionResponse();
  37.  
  38.         try
  39.         {
  40.             //查询缓存
  41.             var permissionModels = await _redisManager.HGetAllValue<PermissionModel>(RedisKeyGenerator.AllRolesRedisKey());
  42.             if (permissionModels.Any())
  43.             {
  44.                 response.PermissionModels = permissionModels;
  45.                 return response;
  46.             }
  47.             
  48.             //查询数据库
  49.             var permissions = _wrapper.Permission.FindAll().Where(_ => _.IsDeleted == false).ToList();
  50.             var data = _mapper.Map<List<PermissionModel>>(permissions);
  51.             response.PermissionModels = data;
  52.  
  53.             var permissionsDic = data.ToDictionary(_ => _.Id);
  54.             //添加缓存
  55.             await permissionsDic.ParallelForEachAsync(async permission =>
  56.             {
  57.                 var redisKey = RedisKeyGenerator.AllPermissions();
  58.                 try
  59.                 {
  60.                     foreach (var s in data)
  61.                     {
  62.                         await _redisManager.HashSet(redisKey, permission.Key.ToString(),
  63.                             JsonConvert.SerializeObject(permission.Value));
  64.                     }
  65.                 }
  66.                 catch (Exception e)
  67.                 {
  68.                     _logger.LogError(e.Message);
  69.                 }
  70.             });
  71.         }
  72.         catch (Exception e)
  73.         {
  74.             _logger.LogError($"QueryAllPermissionAsync error: {e.Message}");
  75.             throw;
  76.         }
  77.  
  78.         return response;
  79.     }
  80.  
  81.     /// <summary>
  82.     /// 添加权限
  83.     /// </summary>
  84.     /// <param name="request"></param>
  85.     public async Task AddPermissionAsync(AddPermissionRequest request)
  86.     {
  87.         var permission = _mapper.Map<Permission>(request);
  88.         _wrapper.Permission.Create(permission);
  89.         await _wrapper.SaveChangeAsync();
  90.     }
  91. }
2. RoleManager
  1. using AutoMapper;
  2. using Microsoft.EntityFrameworkCore;
  3. using Microsoft.Extensions.Logging;
  4. using Newtonsoft.Json;
  5. using org.huage.AuthManagement.BizManager.Redis;
  6. using org.huage.AuthManagement.BizManager.wrapper;
  7. using org.huage.AuthManagement.DataBase.Table;
  8. using org.huage.AuthManagement.Entity.Managers;
  9. using org.huage.AuthManagement.Entity.Model;
  10. using org.huage.AuthManagement.Entity.Request;
  11. using org.huage.AuthManagement.Entity.Response;
  12.  
  13. namespace org.huage.AuthManagement.BizManager.Manager;
  14.  
  15. //角色管理
  16. public class RoleManager : IRoleManager
  17. {
  18.     private readonly IRepositoryWrapper _wrapper;
  19.     private readonly IRedisManager _redisManager;
  20.     private readonly ILogger<RoleManager> _logger;
  21.     private readonly IMapper _mapper;
  22.  
  23.     public RoleManager(IRedisManager redisManager, ILogger<RoleManager> logger, IMapper mapper,
  24.         IRepositoryWrapper wrapper)
  25.     {
  26.         _redisManager = redisManager;
  27.         _logger = logger;
  28.         _mapper = mapper;
  29.         _wrapper = wrapper;
  30.     }
  31.  
  32.     /// <summary>
  33.     /// 查询指定页的数据
  34.     /// </summary>
  35.     /// <param name="request"></param>
  36.     /// <returns></returns>
  37.     public async Task<List<RoleModel>> QueryRoleByPageAsync(QueryRoleRequest request)
  38.     {
  39.         //考虑分页
  40.         //参数校验,设置错误，返回第一页
  41.         if (request.PageSize <=0 || request.PageNumber<0)
  42.         {
  43.             request.PageNumber = 1;
  44.             request.PageSize = 10;
  45.         }
  46.         //查询数据库,TODO：后面需要考虑查询的页数是否超过最大页数
  47.         var skip = (request.PageNumber - 1) * request.PageSize;
  48.         var schedulers =await _wrapper.Role.FindAll().Where(_ => _.IsDeleted == false).OrderByDescending(_ => _.CreateTime)
  49.             .Skip(skip).Take(request.PageSize).ToListAsync();
  50.         
  51.         return _mapper.Map<List<RoleModel>>(schedulers);
  52.     }
  53.     
  54.     /// <summary>
  55.     /// 查询所有的角色
  56.     /// </summary>
  57.     /// <returns></returns>
  58.     public async Task<QueryAllRolesResponse> QueryAllRolesAsync(QueryAllRolesRequest request)
  59.     {
  60.         var response = new QueryAllRolesResponse();
  61.  
  62.         try
  63.         {
  64.             //查询缓存
  65.             var allSchedulers = await _redisManager.HGetAllValue<RoleModel>(RedisKeyGenerator.AllRolesRedisKey());
  66.             if (allSchedulers.Any())
  67.             {
  68.                 response.RoleModels = allSchedulers;
  69.                 return response;
  70.             }
  71.             
  72.             //查询数据库
  73.             var roles = _wrapper.Role.FindAll().Where(_ => _.IsDeleted == false).ToList();
  74.             var data = _mapper.Map<List<RoleModel>>(roles);
  75.             response.RoleModels = data;
  76.  
  77.             var rolesDic = data.ToDictionary(_ => _.Id);
  78.             //添加缓存
  79.             await rolesDic.ParallelForEachAsync(async role =>
  80.             {
  81.                 var redisKey = RedisKeyGenerator.AllRolesRedisKey();
  82.                 try
  83.                 {
  84.                     foreach (var s in data)
  85.                     {
  86.                         await _redisManager.HashSet(redisKey, role.Key.ToString(),
  87.                             JsonConvert.SerializeObject(role.Value));
  88.                     }
  89.                 }
  90.                 catch (Exception e)
  91.                 {
  92.                     _logger.LogError(e.Message);
  93.                 }
  94.             });
  95.         }
  96.         catch (Exception e)
  97.         {
  98.             _logger.LogError($"QueryAllRolesAsync error: {e.Message}");
  99.             throw;
  100.         }
  101.  
  102.         return response;
  103.     }
  104.  
  105.  
  106.     /// <summary>
  107.     /// 查询角色的权限
  108.     /// </summary>
  109.     /// <param name="roleId"></param>
  110.     /// <returns></returns>
  111.     public async Task<QueryPermissionByRoleIdResponse> QueryPermissionByRoleIdAsync(int roleId)
  112.     {
  113.         var response = new QueryPermissionByRoleIdResponse();
  114.         //查询权限ids
  115.         var permissionIds = await _wrapper.RolePermission
  116.             .FindByCondition(_ => _.RoleId == roleId && _.IsDeleted == false)
  117.             .Select(_ => _.PermissionId).ToListAsync();
  118.         if (permissionIds.Any())
  119.         {
  120.             foreach (var id in permissionIds)
  121.             {
  122.                 var permission = _wrapper.Permission.FindByCondition(_ => _.Id == id && _.IsDeleted == false)
  123.                     .FirstOrDefault();
  124.                 var permissionModel = _mapper.Map<PermissionModel>(permission);
  125.                 response.PermissionModels.Add(permissionModel);
  126.             }
  127.         }
  128.  
  129.         return response;
  130.     }
  131.  
  132.     
  133.     /// <summary>
  134.     /// 新增角色
  135.     /// </summary>
  136.     /// <param name="request"></param>
  137.     public async Task AddRoleAsync(AddRoleRequest request)
  138.     {
  139.         //开启事务
  140.         await using var transaction = await _wrapper.StartTransactionAsync();
  141.         try
  142.         {
  143.             if (request.RoleIds.Any())
  144.             {
  145.                 //插入角色
  146.                 var role = new Role()
  147.                 {
  148.                     Name = request.Name,
  149.                     CreateBy= request.CreateBy
  150.                 };
  151.                 _wrapper.Role.Create(role);
  152.                 //这里提前保存是为了拿到数据库中该对象的id.
  153.                 await _wrapper.SaveChangeAsync();
  154.                 //先插rolePermission表
  155.                 foreach (var p in request.RoleIds)
  156.                 {
  157.                     var rolePermission = new RolePermission()
  158.                     {
  159.                         RoleId = role.Id,
  160.                         PermissionId = p
  161.                     };
  162.                     _wrapper.RolePermission.Create(rolePermission);
  163.                 }
  164.             }
  165.             else
  166.             {
  167.                 var role = _mapper.Map<Role>(request);
  168.                 _wrapper.Role.Create(role);
  169.             }
  170.  
  171.             await _wrapper.SaveChangeAsync();
  172.             await transaction.CommitAsync();
  173.         }
  174.         catch (Exception e)
  175.         {
  176.             await transaction.RollbackAsync();
  177.             _logger.LogError("AddRoleAsync error.");
  178.             throw;
  179.         }
  180.     }
  181. }
3. UserManager
  1. using AutoMapper;
  2. using Microsoft.EntityFrameworkCore;
  3. using Microsoft.Extensions.Logging;
  4. using Newtonsoft.Json;
  5. using org.huage.AuthManagement.BizManager.Helper;
  6. using org.huage.AuthManagement.BizManager.Redis;
  7. using org.huage.AuthManagement.BizManager.wrapper;
  8. using org.huage.AuthManagement.DataBase.Table;
  9. using org.huage.AuthManagement.Entity.Common;
  10. using org.huage.AuthManagement.Entity.Managers;
  11. using org.huage.AuthManagement.Entity.Model;
  12. using org.huage.AuthManagement.Entity.Request;
  13. using org.huage.AuthManagement.Entity.Response;
  14.  
  15. namespace org.huage.AuthManagement.BizManager.Manager;
  16.  
  17. //用户管理
  18. public class UserManager : IUserManager
  19. {
  20.     private readonly IRepositoryWrapper _wrapper;
  21.     private readonly IRedisManager _redisManager;
  22.     private readonly ILogger<UserManager> _logger;
  23.     private readonly IMapper _mapper;
  24.  
  25.     public UserManager(IMapper mapper, ILogger<UserManager> logger, IRedisManager redisManager, IRepositoryWrapper wrapper)
  26.     {
  27.         _mapper = mapper;
  28.         _logger = logger;
  29.         _redisManager = redisManager;
  30.         _wrapper = wrapper;
  31.     }
  32.  
  33.  
  34.     /// <summary>
  35.     /// 根据id查询用户
  36.     /// </summary>
  37.     /// <param name="id"></param>
  38.     /// <returns></returns>
  39.     public async Task<UserModel> QueryUserById(int id)
  40.     {
  41.         var user = _wrapper.User.FindByCondition(_=>_.Id==id).FirstOrDefault();
  42.         if (user is null)
  43.             return null;
  44.         
  45.         var userModel = _mapper.Map<UserModel>(user);
  46.         return userModel;
  47.     }
  48.  
  49.     /// <summary>
  50.     /// 根据手机号查询用户
  51.     /// </summary>
  52.     /// <param name="phone"></param>
  53.     /// <returns></returns>
  54.     public async Task<UserModel> QueryUserByPhone(string phone)
  55.     {
  56.         var user = _wrapper.User.FindByCondition(_=>_.Phone == phone).FirstOrDefault();
  57.         if (user is null)
  58.             return null;
  59.         
  60.         var userModel = _mapper.Map<UserModel>(user);
  61.         return userModel;
  62.     }
  63.     
  64.     /// <summary>
  65.     /// 新增用户,用户至少归属于一个组织
  66.     /// </summary>
  67.     /// <param name="request"></param>
  68.     /// <exception cref="Exception"></exception>
  69.     public async Task<UserModel> AddUserAsync(int organizationId, AddUserRequest request)
  70.     {
  71.         try
  72.         {
  73.             if (string.IsNullOrEmpty(request.UserName) || string.IsNullOrEmpty(request.PassWord))
  74.                 throw new UserException("Account and pwd is must.");
  75.             if (string.IsNullOrEmpty(request.Phone))
  76.                 throw new UserException("Phone & OrgCode is required");
  77.  
  78.             //密码加密
  79.             request.PassWord = PwdBCrypt.Encryption(request.PassWord);
  80.             
  81.             //判断用户表是否存在该用户
  82.             var existOrNot = _wrapper.User.FindByCondition(_ => _.Phone.Equals(request.Phone )&& _.UserName.Equals(request.UserName))
  83.                 .FirstOrDefault();
  84.             if (existOrNot is not null)
  85.             {
  86.                 //判断关联表是否存在该用户
  87.                 var organizationUser = _wrapper.OrganizationUser
  88.                     .FindByCondition(_ => _.UserId == existOrNot.Id && _.OrganizationId == organizationId)
  89.                     .FirstOrDefault();
  90.                 if (organizationUser is not null)
  91.                 {
  92.                     //说明该用户已经存在
  93.                     throw new UserException("该用户已存在");
  94.                 }
  95.             }
  96.  
  97.             //删除缓存
  98.             await _redisManager.DelKey(RedisKeyGenerator.AllUsersRedisKey());
  99.             var user = _mapper.Map<User>(request);
  100.             _wrapper.User.Create(user);
  101.             await _wrapper.SaveChangeAsync();
  102.  
  103.             //
  104.             await _redisManager.DelKey(RedisKeyGenerator.AllUsersRedisKey());
  105.             
  106.             var userModel = _mapper.Map<UserModel>(user);
  107.             return userModel;
  108.             
  109.         }
  110.         catch (Exception _)
  111.         {
  112.             _logger.LogError($"Excuse AddUserAsync error: {_.Message}");
  113.             throw;
  114.         }
  115.     }
  116.  
  117.   
  118.     
  119.     /// <summary>
  120.     /// 更新用户信息
  121.     /// </summary>
  122.     /// <param name="request"></param>
  123.     public async Task UpdateUserAsync(UpdateUserRequest request)
  124.     {
  125.         var user = _wrapper.User.FindByCondition(_ => _.Phone == request.Phone && _.IsDeleted == false).FirstOrDefault();
  126.         if (user is null)
  127.         {
  128.             //user not exist
  129.             return;
  130.         }
  131.         if (! string.IsNullOrEmpty(request.PassWord))
  132.         {
  133.             request.PassWord = PwdBCrypt.Encryption(request.PassWord);
  134.         }
  135.         
  136.         if (string.Equals(user.UserName,request.UserName) && string.Equals(user.PassWord,request.PassWord) && string.Equals(user.Phone,request.Phone) && string.Equals(user.Remark,request.Remark))
  137.         {
  138.             //data not change
  139.             return;
  140.         }
  141.         //set value
  142.         if (!string.IsNullOrEmpty(request.UserName))
  143.         {
  144.             user.UserName = request.UserName;
  145.         }
  146.         if (!string.IsNullOrEmpty(request.PassWord))
  147.         {
  148.             user.PassWord = request.PassWord;
  149.         }
  150.         if (!string.IsNullOrEmpty(request.Phone))
  151.         {
  152.             user.Phone = request.Phone;
  153.         }
  154.         if (!string.IsNullOrEmpty(request.Remark))
  155.         {
  156.             user.Remark = request.Remark;
  157.         }
  158.         user.UpdateTime=DateTime.Now;
  159.         _wrapper.User.Update(user);
  160.         await _wrapper.SaveChangeAsync();
  161.     }
  162.  
  163.     /// <summary>
  164.     /// 批量删除用户
  165.     /// </summary>
  166.     /// <param name="ids"></param>
  167.     /// <exception cref="Exception"></exception>
  168.     public async Task DeleteBatchUserAsync(List<int> ids)
  169.     {
  170.         var list =await _wrapper.User.FindByCondition(x=>ids.Contains(x.Id)).ToListAsync();
  171.         foreach (var item in list)
  172.         {
  173.             item.IsDeleted = true;
  174.             _wrapper.User.Update(item);
  175.         }
  176.         await _wrapper.SaveChangeAsync();
  177.     }
  178.  
  179.     /// <summary>
  180.     /// 查询用户拥有的角色
  181.     /// </summary>
  182.     /// <param name="organizationId"></param>
  183.     /// <param name="userId">用户id</param>
  184.     /// <returns></returns>
  185.     public async Task<QueryRoleByUserIdResponse> QueryRoleByUserIdAsync(int organizationId,int userId)
  186.     {
  187.         var response = new QueryRoleByUserIdResponse();
  188.         //拿到角色列表
  189.         var roleIds =await _wrapper.UserRole.FindByCondition(_=>_.UserId==userId && _.OrganizationId==organizationId && _.IsDeleted==false)
  190.             .Select(_=>_.RoleId).ToListAsync();
  191.         if (roleIds.Any())
  192.         {
  193.             foreach (var roleId in roleIds)
  194.             {
  195.                 //拿到具体的角色
  196.                 var role = _wrapper.Role.FindByCondition(_=>_.Id==roleId && _.IsDeleted==false).FirstOrDefault();
  197.                 var roleModel = _mapper.Map<RoleModel>(role);
  198.                 response.RoleModels.Add(roleModel);
  199.             }
  200.         }
  201.  
  202.         return response;
  203.     }
  204.     
  205.     
  206.     /// <summary>
  207.     /// 查询所有的用户
  208.     /// </summary>
  209.     /// <returns></returns>
  210.     public async Task<List<UserModel>> QueryAllUsersAsync()
  211.     {
  212.         var response = new List<UserModel>();
  213.         try
  214.         {
  215.             var allUsers = await _redisManager.HGetAllValue<User>(RedisKeyGenerator.AllUsersRedisKey());
  216.             if (allUsers.Any())
  217.             {
  218.                 response = _mapper.Map<List<UserModel>>(allUsers);
  219.                 return response;
  220.             }
  221.  
  222.             //查数据库，并设置redis；
  223.             var users = _wrapper.User.FindAll().Where(_ => _.IsDeleted == false).ToList();
  224.             response = _mapper.Map<List<UserModel>>(users);
  225.  
  226.             var usersDic = users.ToDictionary(_ => _.Id);
  227.  
  228.             await usersDic.ParallelForEachAsync(async user =>
  229.             {
  230.                 var redisKey = RedisKeyGenerator.AllUsersRedisKey();
  231.                 try
  232.                 {
  233.                     foreach (var s in users)
  234.                     {
  235.                         await _redisManager.HashSet(redisKey, user.Key.ToString(),
  236.                             JsonConvert.SerializeObject(user.Value));
  237.                     }
  238.                 }
  239.                 catch (Exception e)
  240.                 {
  241.                     _logger.LogError(e.Message);
  242.                 }
  243.             });
  244.         }
  245.         catch (Exception e)
  246.         {
  247.             _logger.LogError("QueryAllUsersAsync error: {e.Message}");
  248.             throw;
  249.         }
  250.  
  251.         return response;
  252.     }
  253.  
  254.     public void QueryUserByCondition(QueryUserByConditionRequest request)
  255.     {
  256.         
  257.     }
  258. }
4. OrganizationManager
  1. using System.Text.RegularExpressions;
  2. using AutoMapper;
  3. using Microsoft.EntityFrameworkCore;
  4. using Microsoft.Extensions.Logging;
  5. using Newtonsoft.Json;
  6. using org.huage.AuthManagement.BizManager.Redis;
  7. using org.huage.AuthManagement.BizManager.wrapper;
  8. using org.huage.AuthManagement.DataBase.Table;
  9. using org.huage.AuthManagement.Entity.Common;
  10. using org.huage.AuthManagement.Entity.Managers;
  11. using org.huage.AuthManagement.Entity.Model;
  12. using org.huage.AuthManagement.Entity.Request;
  13. using org.huage.AuthManagement.Entity.Response;
  14.  
  15. namespace org.huage.AuthManagement.BizManager.Manager;
  16.  
  17. //组织管理
  18. public class OrganizationManager : IOrganizationManager
  19. {
  20.     private readonly IRepositoryWrapper _wrapper;
  21.     private readonly IRedisManager _redisManager;
  22.     private readonly ILogger<OrganizationManager> _logger;
  23.     private readonly IMapper _mapper;
  24.     private readonly IUserManager _userManager;
  25.  
  26.     public OrganizationManager(IRepositoryWrapper wrapper, IRedisManager redisManager,
  27.         ILogger<OrganizationManager> logger, IMapper mapper,IUserManager userManager)
  28.     {
  29.         _wrapper = wrapper;
  30.         _redisManager = redisManager;
  31.         _logger = logger;
  32.         _mapper = mapper;
  33.         _userManager = userManager;
  34.     }
  35.  
  36.  
  37.     /// <summary>
  38.     /// 查询该组织的用户，以及用户对应的角色:
  39.     /// 1.查询该组织下的用户
  40.     /// 2.查询用户角色
  41.     /// </summary>
  42.     /// <param name="organizationId"></param>
  43.     public async Task<QueryOrganizationUserAndRoleResponse> QueryOrganizationAllUserAndRoleAsync(int organizationId)
  44.     {
  45.         var response = new QueryOrganizationUserAndRoleResponse();
  46.         try
  47.         {
  48.             //查询缓存
  49.             var organizationUsers =
  50.                 await _redisManager.HGetAllValue<OrganizationUserAndRole>(RedisKeyGenerator.OrganizationAllUserAndRole(organizationId));
  51.             
  52.             if (organizationUsers.Any())
  53.             {
  54.                 response.Users = organizationUsers;
  55.                 return response;
  56.             }
  57.  
  58.             //1.从中间表中查询出该组织对应的用户有那些，然后拿到用户信息
  59.             var userIdList = await _wrapper.OrganizationUser
  60.                 .FindByCondition(_ => _.OrganizationId == organizationId && _.IsDeleted == false).Select(_ => _.UserId)
  61.                 .ToListAsync();
  62.             //2.拿到所有的用户
  63.             if (userIdList.Any())
  64.             {
  65.                 foreach (var userId in userIdList)
  66.                 {
  67.                     //拿到用户
  68.                     var user = _wrapper.User.FindByCondition(_ => _.Id == userId && _.IsDeleted==false).FirstOrDefault();
  69.                     if (user is null)
  70.                     {
  71.                         continue;
  72.                     }
  73.                     var realUser = _mapper.Map<OrganizationUserAndRole>(user);
  74.  
  75.                     //拿到该用户的角色id列表
  76.                     var ids = await _wrapper.UserRole
  77.                         .FindByCondition(_ => organizationId == _.OrganizationId && userId == _.UserId)
  78.                         .Select(_ => _.RoleId).ToListAsync();
  79.  
  80.                     foreach (var id in ids)
  81.                     {
  82.                         //拿到角色
  83.                         var role = _wrapper.Role.FindByCondition(_ => _.Id == id).FirstOrDefault();
  84.                         //添加进入集合
  85.                         var roleModel = _mapper.Map<RoleModel>(role);
  86.                         realUser.RoleModels?.Add(roleModel);
  87.                     }
  88.  
  89.                     //加入返回结果集
  90.                     response.Users.Add(realUser);
  91.                 }
  92.             }
  93.  
  94.             var userAndRoles = response.Users.ToDictionary(_ => _.Id);
  95.  
  96.             //添加缓存
  97.             await userAndRoles.ParallelForEachAsync(async ur =>
  98.             {
  99.                 var redisKey = RedisKeyGenerator.OrganizationAllUserAndRole(organizationId);
  100.                 try
  101.                 {
  102.                     foreach (var s in response.Users)
  103.                     {
  104.                         await _redisManager.HashSet(redisKey, RedisKeyGenerator.OrganizationUser(ur.Key),
  105.                             JsonConvert.SerializeObject(ur.Value));
  106.                     }
  107.                 }
  108.                 catch (Exception e)
  109.                 {
  110.                     _logger.LogError(e.Message);
  111.                 }
  112.             });
  113.         }
  114.         catch (Exception e)
  115.         {
  116.             _logger.LogError($"Excuse QueryOrganizationUserAndRole error: {e.Message}");
  117.             throw;
  118.         }
  119.  
  120.         return response;
  121.     }
  122.  
  123.  
  124.     //查询所有的组织
  125.     public async Task<QueryAllOrganizationResponse> QueryAllOrganizationAsync()
  126.     {
  127.         var response = new QueryAllOrganizationResponse();
  128.         try
  129.         {
  130.             //查缓存
  131.             var value = await _redisManager.HGetAllValue<Organization>(RedisKeyGenerator.AllOrganizationsRedisKey());
  132.             if (value.Any())
  133.             {
  134.                 response.OrganizationModels = _mapper.Map<List<OrganizationModel>>(value);
  135.                 return response;
  136.             }
  137.  
  138.             //查询数据库
  139.             var organizationList = await _wrapper.Organization.FindByCondition(_ => _.IsDeleted == false).ToListAsync();
  140.             response.OrganizationModels = _mapper.Map<List<OrganizationModel>>(organizationList);
  141.  
  142.             //设置缓存
  143.             var organizationDic = organizationList.ToDictionary(_ => _.Id);
  144.             await organizationDic.ParallelForEachAsync(async organization =>
  145.             {
  146.                 var redisKey = RedisKeyGenerator.AllOrganizationsRedisKey();
  147.                 try
  148.                 {
  149.                     foreach (var s in organizationDic)
  150.                     {
  151.                         await _redisManager.HashSet(redisKey, organization.Key.ToString(),
  152.                             JsonConvert.SerializeObject(organization.Value));
  153.                     }
  154.                 }
  155.                 catch (Exception e)
  156.                 {
  157.                     _logger.LogError(e.Message);
  158.                 }
  159.             });
  160.         }
  161.         catch (Exception e)
  162.         {
  163.             _logger.LogError($"QueryAllOrganizationAsync error: {e.Message}");
  164.             throw;
  165.         }
  166.  
  167.         return response;
  168.     }
  169.  
  170.     /// <summary>
  171.     /// 查询该组织明细
  172.     /// </summary>
  173.     /// <param name="organizationId"></param>
  174.     /// <returns></returns>
  175.     public async Task<OrganizationModel> QueryOrganizationDetailAsync(int organizationId)
  176.     {
  177.         var organization = _wrapper.Organization.FindByCondition(_ => _.Id == organizationId).FirstOrDefault();
  178.         return _mapper.Map<OrganizationModel>(organization);
  179.     }
  180.  
  181.  
  182.     /// <summary>
  183.     /// 批量删除
  184.     /// </summary>
  185.     /// <param name="ids"></param>
  186.     public async Task<bool> BatchDeleteOrganizationByIdAsync(List<int> ids)
  187.     {
  188.         if (!ids.Any())
  189.             return false;
  190.         
  191.         foreach (var id in ids)
  192.         {
  193.             var first = _wrapper.Organization.FindByCondition(_ => _.Id == id && _.IsDeleted==false).FirstOrDefault();
  194.             if (first is not null)
  195.             {
  196.                 //逻辑删除
  197.                 first.IsDeleted = true;
  198.                 _wrapper.Organization.Update(first);
  199.                 
  200.                 //删除关联表organizationUser
  201.                 var organizationUserList = await _wrapper.OrganizationUser.FindByCondition(_=>_.OrganizationId==id && _.IsDeleted==false).ToListAsync();
  202.                 if (organizationUserList.Any())
  203.                 {
  204.                     foreach (var organizationUser in organizationUserList)
  205.                     {
  206.                         //逻辑删除
  207.                         organizationUser.IsDeleted = true;
  208.                         _wrapper.OrganizationUser.Update(organizationUser);
  209.                     }
  210.                 }
  211.             }
  212.         }
  213.  
  214.         return true;
  215.  
  216.     }
  217.  
  218.     /// <summary>
  219.     /// 组织添加用户：添加用户的时候，可以选择是否给该用户配角色
  220.     /// </summary>
  221.     /// <summary>
  222.     /// 比如说A组织创建了一个用户a,然后用户表插入了一个用户（手机号唯一），接着在organizationUser表加入一条id, A.ID , a.id的的数据；
  223.     /// 然后我们给该A组织的a用户设置角色的时候，我们去UserRole表加入一条数据：userid,roleId,organizationId.
  224.     ///
  225.     /// 这时候B组织把a也加入自己的组织了，给该用户设置B组织a用户的权限：在UserRole角色表里面加入一条，userid,roleId,organizationId.
  226.     /// 希望解决同一个用户在不同系统拥有不同的权限：逻辑就是组织添加用户的时候，加入organizationUser表，并且需要给其授予角色（默认是游客），也可以从用户表中挑选用户；
  227.     /// </summary>
  228.     public async Task<bool> OrganizationAddUserAsync(AddOrganizationUserRequest request)
  229.     {
  230.         if (!IsValidOrgCode(request.OrganizationId.ToString()))
  231.             throw new OrganizationException("OrganizationId invalid，please fill in valid orgCode");
  232.         if (string.IsNullOrEmpty(request.UserModel.Phone))
  233.             throw new OrganizationException("Phone is required.");
  234.  
  235.         //开启事务
  236.         await using var transaction = await _wrapper.StartTransactionAsync();
  237.  
  238.         try
  239.         {
  240.             //添加用户
  241.             var addUser = await _userManager.AddUserAsync(request.OrganizationId, request.UserModel);
  242.  
  243.             //添加OrganizationUser
  244.             var organizationUserModel = new OrganizationUserModel()
  245.             {
  246.                 OrganizationId = request.OrganizationId,
  247.                 UserId = addUser.Id
  248.             };
  249.             var organizationUser = _mapper.Map<OrganizationUser>(organizationUserModel);
  250.             _wrapper.OrganizationUser.Create(organizationUser);
  251.  
  252.             //添加UserRole
  253.             if (request.RoleModels != null && request.RoleModels.Any())
  254.             {
  255.                 foreach (var role in request.RoleModels)
  256.                 {
  257.                     var userRoleModel = new UserRoleModel()
  258.                     {
  259.                         UserId = addUser.Id,
  260.                         OrganizationId = request.OrganizationId,
  261.                         RoleId = role.Id
  262.                     };
  263.                     var userRole = _mapper.Map<UserRole>(userRoleModel);
  264.                     _wrapper.UserRole.Create(userRole);
  265.                 }
  266.             }
  267.             else
  268.             {
  269.                 //设置该用户默认角色为游客
  270.                 var ur = new UserRoleModel()
  271.                 {
  272.                     UserId = addUser.Id,
  273.                     OrganizationId = request.OrganizationId,
  274.                     RoleId = 2
  275.                 };
  276.                 var userRole = _mapper.Map<UserRole>(ur);
  277.                 _wrapper.UserRole.Create(userRole);
  278.             }
  279.  
  280.             await _wrapper.SaveChangeAsync();
  281.  
  282.             await transaction.CommitAsync();
  283.         }
  284.         catch (UserException ex)
  285.         {
  286.             await transaction.RollbackAsync();
  287.             _logger.LogError(ex.Message);
  288.             throw;
  289.         }
  290.         catch (Exception e)
  291.         {
  292.             //发生异常回滚
  293.             await transaction.RollbackAsync();
  294.             _logger.LogError($"Excuse OrganizationAddUser error: {e.Message}");
  295.             throw;
  296.         }
  297.  
  298.         return true;
  299.     }
  300.  
  301.  
  302.     /// <summary>
  303.     /// 新增组织
  304.     /// </summary>
  305.     /// <param name="request"></param>
  306.     /// <exception cref="Exception"></exception>
  307.     public async Task AddOrganizationAsync(AddOrganizationRequest request)
  308.     {
  309.         try
  310.         {
  311.             //params check
  312.             if (string.IsNullOrEmpty(request.OrgCode) ||
  313.                 string.IsNullOrEmpty(request.Name))
  314.             {
  315.                 throw new OrganizationException("组织名称和组织注册编码不能为空");
  316.             }
  317.  
  318.             if (string.IsNullOrEmpty(request.Version))
  319.             {
  320.                 request.Version = "v1";
  321.             }
  322.  
  323.             //mapping
  324.             var organization = _mapper.Map<Organization>(request);
  325.             _wrapper.Organization.Create(organization);
  326.             await _wrapper.SaveChangeAsync();
  327.         }
  328.         catch (Exception e)
  329.         {
  330.             _logger.LogError($"Excuse AddOrganization error: {e.Message}");
  331.             throw;
  332.         }
  333.     }
  334.  
  335.     /// <summary>
  336.     /// 判断传进来的营业执照是否有效,这里可以根据自己的业务具体实现,当前假设为邮箱
  337.     /// </summary>
  338.     /// <param name="orgCode"></param>
  339.     /// <returns></returns>
  340.     private bool IsValidOrgCode(string orgCode)
  341.     {
  342.         var regex = new Regex("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
  343.         return regex.IsMatch(orgCode);
  344.     }
  345. }

Api模块：暴露接口，程序启动

目录接口：

Example ：OrganizationController
  1. namespace org.huage.AuthManagement.Api.Controllers;
  2. [ApiController]
  3. [Route("/[controller]/[action]")]
  4. public class OrganizationController : Controller
  5. {
  6.     private readonly IOrganizationManager _organizationManager;
  7.     private readonly ILogger<OrganizationController> _logger;
  8.  
  9.     public OrganizationController(IOrganizationManager organizationManager, ILogger<OrganizationController> logger)
  10.     {
  11.         _organizationManager = organizationManager;
  12.         _logger = logger;
  13.     }
  14.     
  15.     
  16.     [HttpPost]
  17.     public async Task<bool> OrganizationAddUser(AddOrganizationUserRequest request)
  18.     {
  19.         try
  20.         {
  21.             return await _organizationManager.OrganizationAddUserAsync(request);
  22.         }
  23.         catch (OrganizationException ex)
  24.         {
  25.             _logger.LogError(
  26.                 $"Error in org.huage.Service.OrganizationManager.OrganizationController.OrganizationAddUser. {ex.Message}");
  27.             throw;
  28.         }
  29.         catch (Exception e)
  30.         {
  31.             var organizationExceptionException = new OrganizationException(e.Message);
  32.             _logger.LogError(
  33.                 $"Error in org.huage.Service.OrganizationManager.OrganizationController.OrganizationAddUser.");
  34.             throw organizationExceptionException;
  35.         }
  36.     }
  37. }

 

测试：基于Swagger测试

Example: 

备注：查全量数据的时候都集成了Redis，经过postman本地测试，基本所有接口响应时间都可以控制在50ms内，基于Redis查全量数据的时候能控制在10ms以内。

完整项目地址：(整理中，后续贴上)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/989877
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号