Asp.Net Core 7.0 基于JWT组织用户角色权限认证（二）

无灵的说

已于 2023-12-04 13:19:42 修改

阅读量210

点赞数 1

文章标签：数据库 .net asp.net 后端

于 2023-11-24 10:52:13 首次发布

本文链接：https://blog.csdn.net/weixin_63568353/article/details/134592275

版权

前言：

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

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

数据库表：

数据库：MYSQL，使用EF-CORE基于仓储模式来进行数据库管理。

该项目管理表之间的关联关系主要是用第三张表来管理，相对来说比较好理解。

结构：

Entity 实体结构：

Manager模块（核心逻辑）：

1. PermissionManager

using AutoMapper;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using org.huage.AuthManagement.BizManager.Redis;
using org.huage.AuthManagement.BizManager.wrapper;
using org.huage.AuthManagement.DataBase.Table;
using org.huage.AuthManagement.Entity.Managers;
using org.huage.AuthManagement.Entity.Model;
using org.huage.AuthManagement.Entity.Request;
using org.huage.AuthManagement.Entity.Response;

namespace org.huage.AuthManagement.BizManager.Manager;

//权限管理
public class PermissionManager : IPermissionManager
{
    private readonly IRepositoryWrapper _wrapper;
    private readonly IRedisManager _redisManager;
    private readonly ILogger<PermissionManager> _logger;
    private readonly IMapper _mapper;

    public PermissionManager(IRepositoryWrapper wrapper, IRedisManager redisManager, ILogger<PermissionManager> logger, IMapper mapper)
    {
        _wrapper = wrapper;
        _redisManager = redisManager;
        _logger = logger;
        _mapper = mapper;
    }

    /// <summary>
    /// 查询所有的权限信息。
    /// </summary>
    /// <returns></returns>
    public async Task<QueryAllPermissionResponse> QueryAllPermissionAsync()
    {
        var response = new QueryAllPermissionResponse();

        try
        {
            //查询缓存
            var permissionModels = await _redisManager.HGetAllValue<PermissionModel>(RedisKeyGenerator.AllRolesRedisKey());
            if (permissionModels.Any())
            {
                response.PermissionModels = permissionModels;
                return response;
            }
            
            //查询数据库
            var permissions = _wrapper.Permission.FindAll().Where(_ => _.IsDeleted == false).ToList();
            var data = _mapper.Map<List<PermissionModel>>(permissions);
            response.PermissionModels = data;

            var permissionsDic = data.ToDictionary(_ => _.Id);
            //添加缓存
            await permissionsDic.ParallelForEachAsync(async permission =>
            {
                var redisKey = RedisKeyGenerator.AllPermissions();
                try
                {
                    foreach (var s in data)
                    {
                        await _redisManager.HashSet(redisKey, permission.Key.ToString(),
                            JsonConvert.SerializeObject(permission.Value));
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e.Message);
                }
            });
        }
        catch (Exception e)
        {
            _logger.LogError($"QueryAllPermissionAsync error: {e.Message}");
            throw;
        }

        return response;
    }

    /// <summary>
    /// 添加权限
    /// </summary>
    /// <param name="request"></param>
    public async Task AddPermissionAsync(AddPermissionRequest request)
    {
        var permission = _mapper.Map<Permission>(request);
        _wrapper.Permission.Create(permission);
        await _wrapper.SaveChangeAsync();
    }
}

2. RoleManager

using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using org.huage.AuthManagement.BizManager.Redis;
using org.huage.AuthManagement.BizManager.wrapper;
using org.huage.AuthManagement.DataBase.Table;
using org.huage.AuthManagement.Entity.Managers;
using org.huage.AuthManagement.Entity.Model;
using org.huage.AuthManagement.Entity.Request;
using org.huage.AuthManagement.Entity.Response;

namespace org.huage.AuthManagement.BizManager.Manager;

//角色管理
public class RoleManager : IRoleManager
{
    private readonly IRepositoryWrapper _wrapper;
    private readonly IRedisManager _redisManager;
    private readonly ILogger<RoleManager> _logger;
    private readonly IMapper _mapper;

    public RoleManager(IRedisManager redisManager, ILogger<RoleManager> logger, IMapper mapper,
        IRepositoryWrapper wrapper)
    {
        _redisManager = redisManager;
        _logger = logger;
        _mapper = mapper;
        _wrapper = wrapper;
    }

    /// <summary>
    /// 查询指定页的数据
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    public async Task<List<RoleModel>> QueryRoleByPageAsync(QueryRoleRequest request)
    {
        //考虑分页
        //参数校验,设置错误，返回第一页
        if (request.PageSize <=0 || request.PageNumber<0)
        {
            request.PageNumber = 1;
            request.PageSize = 10;
        }
        //查询数据库,TODO：后面需要考虑查询的页数是否超过最大页数
        var skip = (request.PageNumber - 1) * request.PageSize;
        var schedulers =await _wrapper.Role.FindAll().Where(_ => _.IsDeleted == false).OrderByDescending(_ => _.CreateTime)
            .Skip(skip).Take(request.PageSize).ToListAsync();
        
        return _mapper.Map<List<RoleModel>>(schedulers);
    }
    
    /// <summary>
    /// 查询所有的角色
    /// </summary>
    /// <returns></returns>
    public async Task<QueryAllRolesResponse> QueryAllRolesAsync(QueryAllRolesRequest request)
    {
        var response = new QueryAllRolesResponse();

        try
        {
            //查询缓存
            var allSchedulers = await _redisManager.HGetAllValue<RoleModel>(RedisKeyGenerator.AllRolesRedisKey());
            if (allSchedulers.Any())
            {
                response.RoleModels = allSchedulers;
                return response;
            }
            
            //查询数据库
            var roles = _wrapper.Role.FindAll().Where(_ => _.IsDeleted == false).ToList();
            var data = _mapper.Map<List<RoleModel>>(roles);
            response.RoleModels = data;

            var rolesDic = data.ToDictionary(_ => _.Id);
            //添加缓存
            await rolesDic.ParallelForEachAsync(async role =>
            {
                var redisKey = RedisKeyGenerator.AllRolesRedisKey();
                try
                {
                    foreach (var s in data)
                    {
                        await _redisManager.HashSet(redisKey, role.Key.ToString(),
                            JsonConvert.SerializeObject(role.Value));
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e.Message);
                }
            });
        }
        catch (Exception e)
        {
            _logger.LogError($"QueryAllRolesAsync error: {e.Message}");
            throw;
        }

        return response;
    }


    /// <summary>
    /// 查询角色的权限
    /// </summary>
    /// <param name="roleId"></param>
    /// <returns></returns>
    public async Task<QueryPermissionByRoleIdResponse> QueryPermissionByRoleIdAsync(int roleId)
    {
        var response = new QueryPermissionByRoleIdResponse();
        //查询权限ids
        var permissionIds = await _wrapper.RolePermission
            .FindByCondition(_ => _.RoleId == roleId && _.IsDeleted == false)
            .Select(_ => _.PermissionId).ToListAsync();
        if (permissionIds.Any())
        {
            foreach (var id in permissionIds)
            {
                var permission = _wrapper.Permission.FindByCondition(_ => _.Id == id && _.IsDeleted == false)
                    .FirstOrDefault();
                var permissionModel = _mapper.Map<PermissionModel>(permission);
                response.PermissionModels.Add(permissionModel);
            }
        }

        return response;
    }

    
    /// <summary>
    /// 新增角色
    /// </summary>
    /// <param name="request"></param>
    public async Task AddRoleAsync(AddRoleRequest request)
    {
        //开启事务
        await using var transaction = await _wrapper.StartTransactionAsync();
        try
        {
            if (request.RoleIds.Any())
            {
                //插入角色
                var role = new Role()
                {
                    Name = request.Name,
                    CreateBy= request.CreateBy
                };
                _wrapper.Role.Create(role);
                //这里提前保存是为了拿到数据库中该对象的id.
                await _wrapper.SaveChangeAsync();
                //先插rolePermission表
                foreach (var p in request.RoleIds)
                {
                    var rolePermission = new RolePermission()
                    {
                        RoleId = role.Id,
                        PermissionId = p
                    };
                    _wrapper.RolePermission.Create(rolePermission);
                }
            }
            else
            {
                var role = _mapper.Map<Role>(request);
                _wrapper.Role.Create(role);
            }

            await _wrapper.SaveChangeAsync();
            await transaction.CommitAsync();
        }
        catch (Exception e)
        {
            await transaction.RollbackAsync();
            _logger.LogError("AddRoleAsync error.");
            throw;
        }
    }
}

3. UserManager

using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using org.huage.AuthManagement.BizManager.Helper;
using org.huage.AuthManagement.BizManager.Redis;
using org.huage.AuthManagement.BizManager.wrapper;
using org.huage.AuthManagement.DataBase.Table;
using org.huage.AuthManagement.Entity.Common;
using org.huage.AuthManagement.Entity.Managers;
using org.huage.AuthManagement.Entity.Model;
using org.huage.AuthManagement.Entity.Request;
using org.huage.AuthManagement.Entity.Response;

namespace org.huage.AuthManagement.BizManager.Manager;

//用户管理
public class UserManager : IUserManager
{
    private readonly IRepositoryWrapper _wrapper;
    private readonly IRedisManager _redisManager;
    private readonly ILogger<UserManager> _logger;
    private readonly IMapper _mapper;

    public UserManager(IMapper mapper, ILogger<UserManager> logger, IRedisManager redisManager, IRepositoryWrapper wrapper)
    {
        _mapper = mapper;
        _logger = logger;
        _redisManager = redisManager;
        _wrapper = wrapper;
    }


    /// <summary>
    /// 根据id查询用户
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<UserModel> QueryUserById(int id)
    {
        var user = _wrapper.User.FindByCondition(_=>_.Id==id).FirstOrDefault();
        if (user is null)
            return null;
        
        var userModel = _mapper.Map<UserModel>(user);
        return userModel;
    }

    /// <summary>
    /// 根据手机号查询用户
    /// </summary>
    /// <param name="phone"></param>
    /// <returns></returns>
    public async Task<UserModel> QueryUserByPhone(string phone)
    {
        var user = _wrapper.User.FindByCondition(_=>_.Phone == phone).FirstOrDefault();
        if (user is null)
            return null;
        
        var userModel = _mapper.Map<UserModel>(user);
        return userModel;
    }
    
    /// <summary>
    /// 新增用户,用户至少归属于一个组织
    /// </summary>
    /// <param name="request"></param>
    /// <exception cref="Exception"></exception>
    public async Task<UserModel> AddUserAsync(int organizationId, AddUserRequest request)
    {
        try
        {
            if (string.IsNullOrEmpty(request.UserName) || string.IsNullOrEmpty(request.PassWord))
                throw new UserException("Account and pwd is must.");
            if (string.IsNullOrEmpty(request.Phone))
                throw new UserException("Phone & OrgCode is required");

            //密码加密
            request.PassWord = PwdBCrypt.Encryption(request.PassWord);
            
            //判断用户表是否存在该用户
            var existOrNot = _wrapper.User.FindByCondition(_ => _.Phone.Equals(request.Phone )&& _.UserName.Equals(request.UserName))
                .FirstOrDefault();
            if (existOrNot is not null)
            {
                //判断关联表是否存在该用户
                var organizationUser = _wrapper.OrganizationUser
                    .FindByCondition(_ => _.UserId == existOrNot.Id && _.OrganizationId == organizationId)
                    .FirstOrDefault();
                if (organizationUser is not null)
                {
                    //说明该用户已经存在
                    throw new UserException("该用户已存在");
                }
            }

            //删除缓存
            await _redisManager.DelKey(RedisKeyGenerator.AllUsersRedisKey());
            var user = _mapper.Map<User>(request);
            _wrapper.User.Create(user);
            await _wrapper.SaveChangeAsync();

            //
            await _redisManager.DelKey(RedisKeyGenerator.AllUsersRedisKey());
            
            var userModel = _mapper.Map<UserModel>(user);
            return userModel;
            
        }
        catch (Exception _)
        {
            _logger.LogError($"Excuse AddUserAsync error: {_.Message}");
            throw;
        }
    }

  
    
    /// <summary>
    /// 更新用户信息
    /// </summary>
    /// <param name="request"></param>
    public async Task UpdateUserAsync(UpdateUserRequest request)
    {
        var user = _wrapper.User.FindByCondition(_ => _.Phone == request.Phone && _.IsDeleted == false).FirstOrDefault();
        if (user is null)
        {
            //user not exist
            return;
        }
        if (! string.IsNullOrEmpty(request.PassWord))
        {
            request.PassWord = PwdBCrypt.Encryption(request.PassWord);
        }
        
        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))
        {
            //data not change
            return;
        }
        //set value
        if (!string.IsNullOrEmpty(request.UserName))
        {
            user.UserName = request.UserName;
        }
        if (!string.IsNullOrEmpty(request.PassWord))
        {
            user.PassWord = request.PassWord;
        }
        if (!string.IsNullOrEmpty(request.Phone))
        {
            user.Phone = request.Phone;
        }
        if (!string.IsNullOrEmpty(request.Remark))
        {
            user.Remark = request.Remark;
        }
        user.UpdateTime=DateTime.Now;
        _wrapper.User.Update(user);
        await _wrapper.SaveChangeAsync();
    }

    /// <summary>
    /// 批量删除用户
    /// </summary>
    /// <param name="ids"></param>
    /// <exception cref="Exception"></exception>
    public async Task DeleteBatchUserAsync(List<int> ids)
    {
        var list =await _wrapper.User.FindByCondition(x=>ids.Contains(x.Id)).ToListAsync();
        foreach (var item in list)
        {
            item.IsDeleted = true;
            _wrapper.User.Update(item);
        }
        await _wrapper.SaveChangeAsync();
    }

    /// <summary>
    /// 查询用户拥有的角色
    /// </summary>
    /// <param name="organizationId"></param>
    /// <param name="userId">用户id</param>
    /// <returns></returns>
    public async Task<QueryRoleByUserIdResponse> QueryRoleByUserIdAsync(int organizationId,int userId)
    {
        var response = new QueryRoleByUserIdResponse();
        //拿到角色列表
        var roleIds =await _wrapper.UserRole.FindByCondition(_=>_.UserId==userId && _.OrganizationId==organizationId && _.IsDeleted==false)
            .Select(_=>_.RoleId).ToListAsync();
        if (roleIds.Any())
        {
            foreach (var roleId in roleIds)
            {
                //拿到具体的角色
                var role = _wrapper.Role.FindByCondition(_=>_.Id==roleId && _.IsDeleted==false).FirstOrDefault();
                var roleModel = _mapper.Map<RoleModel>(role);
                response.RoleModels.Add(roleModel);
            }
        }

        return response;
    }
    
    
    /// <summary>
    /// 查询所有的用户
    /// </summary>
    /// <returns></returns>
    public async Task<List<UserModel>> QueryAllUsersAsync()
    {
        var response = new List<UserModel>();
        try
        {
            var allUsers = await _redisManager.HGetAllValue<User>(RedisKeyGenerator.AllUsersRedisKey());
            if (allUsers.Any())
            {
                response = _mapper.Map<List<UserModel>>(allUsers);
                return response;
            }

            //查数据库，并设置redis；
            var users = _wrapper.User.FindAll().Where(_ => _.IsDeleted == false).ToList();
            response = _mapper.Map<List<UserModel>>(users);

            var usersDic = users.ToDictionary(_ => _.Id);

            await usersDic.ParallelForEachAsync(async user =>
            {
                var redisKey = RedisKeyGenerator.AllUsersRedisKey();
                try
                {
                    foreach (var s in users)
                    {
                        await _redisManager.HashSet(redisKey, user.Key.ToString(),
                            JsonConvert.SerializeObject(user.Value));
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e.Message);
                }
            });
        }
        catch (Exception e)
        {
            _logger.LogError("QueryAllUsersAsync error: {e.Message}");
            throw;
        }

        return response;
    }

    public void QueryUserByCondition(QueryUserByConditionRequest request)
    {
        
    }
}

4. OrganizationManager

using System.Text.RegularExpressions;
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using org.huage.AuthManagement.BizManager.Redis;
using org.huage.AuthManagement.BizManager.wrapper;
using org.huage.AuthManagement.DataBase.Table;
using org.huage.AuthManagement.Entity.Common;
using org.huage.AuthManagement.Entity.Managers;
using org.huage.AuthManagement.Entity.Model;
using org.huage.AuthManagement.Entity.Request;
using org.huage.AuthManagement.Entity.Response;

namespace org.huage.AuthManagement.BizManager.Manager;

//组织管理
public class OrganizationManager : IOrganizationManager
{
    private readonly IRepositoryWrapper _wrapper;
    private readonly IRedisManager _redisManager;
    private readonly ILogger<OrganizationManager> _logger;
    private readonly IMapper _mapper;
    private readonly IUserManager _userManager;

    public OrganizationManager(IRepositoryWrapper wrapper, IRedisManager redisManager,
        ILogger<OrganizationManager> logger, IMapper mapper,IUserManager userManager)
    {
        _wrapper = wrapper;
        _redisManager = redisManager;
        _logger = logger;
        _mapper = mapper;
        _userManager = userManager;
    }


    /// <summary>
    /// 查询该组织的用户，以及用户对应的角色:
    /// 1.查询该组织下的用户
    /// 2.查询用户角色
    /// </summary>
    /// <param name="organizationId"></param>
    public async Task<QueryOrganizationUserAndRoleResponse> QueryOrganizationAllUserAndRoleAsync(int organizationId)
    {
        var response = new QueryOrganizationUserAndRoleResponse();
        try
        {
            //查询缓存
            var organizationUsers =
                await _redisManager.HGetAllValue<OrganizationUserAndRole>(RedisKeyGenerator.OrganizationAllUserAndRole(organizationId));
            
            if (organizationUsers.Any())
            {
                response.Users = organizationUsers;
                return response;
            }

            //1.从中间表中查询出该组织对应的用户有那些，然后拿到用户信息
            var userIdList = await _wrapper.OrganizationUser
                .FindByCondition(_ => _.OrganizationId == organizationId && _.IsDeleted == false).Select(_ => _.UserId)
                .ToListAsync();
            //2.拿到所有的用户
            if (userIdList.Any())
            {
                foreach (var userId in userIdList)
                {
                    //拿到用户
                    var user = _wrapper.User.FindByCondition(_ => _.Id == userId && _.IsDeleted==false).FirstOrDefault();
                    if (user is null)
                    {
                        continue;
                    }
                    var realUser = _mapper.Map<OrganizationUserAndRole>(user);

                    //拿到该用户的角色id列表
                    var ids = await _wrapper.UserRole
                        .FindByCondition(_ => organizationId == _.OrganizationId && userId == _.UserId)
                        .Select(_ => _.RoleId).ToListAsync();

                    foreach (var id in ids)
                    {
                        //拿到角色
                        var role = _wrapper.Role.FindByCondition(_ => _.Id == id).FirstOrDefault();
                        //添加进入集合
                        var roleModel = _mapper.Map<RoleModel>(role);
                        realUser.RoleModels?.Add(roleModel);
                    }

                    //加入返回结果集
                    response.Users.Add(realUser);
                }
            }

            var userAndRoles = response.Users.ToDictionary(_ => _.Id);

            //添加缓存
            await userAndRoles.ParallelForEachAsync(async ur =>
            {
                var redisKey = RedisKeyGenerator.OrganizationAllUserAndRole(organizationId);
                try
                {
                    foreach (var s in response.Users)
                    {
                        await _redisManager.HashSet(redisKey, RedisKeyGenerator.OrganizationUser(ur.Key),
                            JsonConvert.SerializeObject(ur.Value));
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e.Message);
                }
            });
        }
        catch (Exception e)
        {
            _logger.LogError($"Excuse QueryOrganizationUserAndRole error: {e.Message}");
            throw;
        }

        return response;
    }


    //查询所有的组织
    public async Task<QueryAllOrganizationResponse> QueryAllOrganizationAsync()
    {
        var response = new QueryAllOrganizationResponse();
        try
        {
            //查缓存
            var value = await _redisManager.HGetAllValue<Organization>(RedisKeyGenerator.AllOrganizationsRedisKey());
            if (value.Any())
            {
                response.OrganizationModels = _mapper.Map<List<OrganizationModel>>(value);
                return response;
            }

            //查询数据库
            var organizationList = await _wrapper.Organization.FindByCondition(_ => _.IsDeleted == false).ToListAsync();
            response.OrganizationModels = _mapper.Map<List<OrganizationModel>>(organizationList);

            //设置缓存
            var organizationDic = organizationList.ToDictionary(_ => _.Id);
            await organizationDic.ParallelForEachAsync(async organization =>
            {
                var redisKey = RedisKeyGenerator.AllOrganizationsRedisKey();
                try
                {
                    foreach (var s in organizationDic)
                    {
                        await _redisManager.HashSet(redisKey, organization.Key.ToString(),
                            JsonConvert.SerializeObject(organization.Value));
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e.Message);
                }
            });
        }
        catch (Exception e)
        {
            _logger.LogError($"QueryAllOrganizationAsync error: {e.Message}");
            throw;
        }

        return response;
    }

    /// <summary>
    /// 查询该组织明细
    /// </summary>
    /// <param name="organizationId"></param>
    /// <returns></returns>
    public async Task<OrganizationModel> QueryOrganizationDetailAsync(int organizationId)
    {
        var organization = _wrapper.Organization.FindByCondition(_ => _.Id == organizationId).FirstOrDefault();
        return _mapper.Map<OrganizationModel>(organization);
    }


    /// <summary>
    /// 批量删除
    /// </summary>
    /// <param name="ids"></param>
    public async Task<bool> BatchDeleteOrganizationByIdAsync(List<int> ids)
    {
        if (!ids.Any())
            return false;
        
        foreach (var id in ids)
        {
            var first = _wrapper.Organization.FindByCondition(_ => _.Id == id && _.IsDeleted==false).FirstOrDefault();
            if (first is not null)
            {
                //逻辑删除
                first.IsDeleted = true;
                _wrapper.Organization.Update(first);
                
                //删除关联表organizationUser
                var organizationUserList = await _wrapper.OrganizationUser.FindByCondition(_=>_.OrganizationId==id && _.IsDeleted==false).ToListAsync();
                if (organizationUserList.Any())
                {
                    foreach (var organizationUser in organizationUserList)
                    {
                        //逻辑删除
                        organizationUser.IsDeleted = true;
                        _wrapper.OrganizationUser.Update(organizationUser);
                    }
                }
            }
        }

        return true;

    }

    /// <summary>
    /// 组织添加用户：添加用户的时候，可以选择是否给该用户配角色
    /// </summary>
    /// <summary>
    /// 比如说A组织创建了一个用户a,然后用户表插入了一个用户（手机号唯一），接着在organizationUser表加入一条id, A.ID , a.id的的数据；
    /// 然后我们给该A组织的a用户设置角色的时候，我们去UserRole表加入一条数据：userid,roleId,organizationId.
    ///
    /// 这时候B组织把a也加入自己的组织了，给该用户设置B组织a用户的权限：在UserRole角色表里面加入一条，userid,roleId,organizationId.
    /// 希望解决同一个用户在不同系统拥有不同的权限：逻辑就是组织添加用户的时候，加入organizationUser表，并且需要给其授予角色（默认是游客），也可以从用户表中挑选用户；
    /// </summary>
    public async Task<bool> OrganizationAddUserAsync(AddOrganizationUserRequest request)
    {
        if (!IsValidOrgCode(request.OrganizationId.ToString()))
            throw new OrganizationException("OrganizationId invalid，please fill in valid orgCode");
        if (string.IsNullOrEmpty(request.UserModel.Phone))
            throw new OrganizationException("Phone is required.");

        //开启事务
        await using var transaction = await _wrapper.StartTransactionAsync();

        try
        {
            //添加用户
            var addUser = await _userManager.AddUserAsync(request.OrganizationId, request.UserModel);

            //添加OrganizationUser
            var organizationUserModel = new OrganizationUserModel()
            {
                OrganizationId = request.OrganizationId,
                UserId = addUser.Id
            };
            var organizationUser = _mapper.Map<OrganizationUser>(organizationUserModel);
            _wrapper.OrganizationUser.Create(organizationUser);

            //添加UserRole
            if (request.RoleModels != null && request.RoleModels.Any())
            {
                foreach (var role in request.RoleModels)
                {
                    var userRoleModel = new UserRoleModel()
                    {
                        UserId = addUser.Id,
                        OrganizationId = request.OrganizationId,
                        RoleId = role.Id
                    };
                    var userRole = _mapper.Map<UserRole>(userRoleModel);
                    _wrapper.UserRole.Create(userRole);
                }
            }
            else
            {
                //设置该用户默认角色为游客
                var ur = new UserRoleModel()
                {
                    UserId = addUser.Id,
                    OrganizationId = request.OrganizationId,
                    RoleId = 2
                };
                var userRole = _mapper.Map<UserRole>(ur);
                _wrapper.UserRole.Create(userRole);
            }

            await _wrapper.SaveChangeAsync();

            await transaction.CommitAsync();
        }
        catch (UserException ex)
        {
            await transaction.RollbackAsync();
            _logger.LogError(ex.Message);
            throw;
        }
        catch (Exception e)
        {
            //发生异常回滚
            await transaction.RollbackAsync();
            _logger.LogError($"Excuse OrganizationAddUser error: {e.Message}");
            throw;
        }

        return true;
    }


    /// <summary>
    /// 新增组织
    /// </summary>
    /// <param name="request"></param>
    /// <exception cref="Exception"></exception>
    public async Task AddOrganizationAsync(AddOrganizationRequest request)
    {
        try
        {
            //params check
            if (string.IsNullOrEmpty(request.OrgCode) ||
                string.IsNullOrEmpty(request.Name))
            {
                throw new OrganizationException("组织名称和组织注册编码不能为空");
            }

            if (string.IsNullOrEmpty(request.Version))
            {
                request.Version = "v1";
            }

            //mapping
            var organization = _mapper.Map<Organization>(request);
            _wrapper.Organization.Create(organization);
            await _wrapper.SaveChangeAsync();
        }
        catch (Exception e)
        {
            _logger.LogError($"Excuse AddOrganization error: {e.Message}");
            throw;
        }
    }

    /// <summary>
    /// 判断传进来的营业执照是否有效,这里可以根据自己的业务具体实现,当前假设为邮箱
    /// </summary>
    /// <param name="orgCode"></param>
    /// <returns></returns>
    private bool IsValidOrgCode(string orgCode)
    {
        var regex = new Regex("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
        return regex.IsMatch(orgCode);
    }
}

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

目录接口：

Example ：OrganizationController

namespace org.huage.AuthManagement.Api.Controllers;
[ApiController]
[Route("/[controller]/[action]")]
public class OrganizationController : Controller
{
    private readonly IOrganizationManager _organizationManager;
    private readonly ILogger<OrganizationController> _logger;

    public OrganizationController(IOrganizationManager organizationManager, ILogger<OrganizationController> logger)
    {
        _organizationManager = organizationManager;
        _logger = logger;
    }
    
    
    [HttpPost]
    public async Task<bool> OrganizationAddUser(AddOrganizationUserRequest request)
    {
        try
        {
            return await _organizationManager.OrganizationAddUserAsync(request);
        }
        catch (OrganizationException ex)
        {
            _logger.LogError(
                $"Error in org.huage.Service.OrganizationManager.OrganizationController.OrganizationAddUser. {ex.Message}");
            throw;
        }
        catch (Exception e)
        {
            var organizationExceptionException = new OrganizationException(e.Message);
            _logger.LogError(
                $"Error in org.huage.Service.OrganizationManager.OrganizationController.OrganizationAddUser.");
            throw organizationExceptionException;
        }
    }
}

测试：基于Swagger测试

Example:

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

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

无灵的说

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
Asp.Net Core 7.0 基于JWT组织用户角色权限认证（二）

上一篇我们已经完成了权限校验以及授权的部分，本篇接下来我们分析一下如何基于组织用户角色进行权限管理。在本项目中，支持建立多组织，同一用户支持在不同组织下授予不同的角色。由于本人是新人，如果有好的见解或者看法欢迎和我沟通，互相学习进步。
复制链接

扫一扫