feixing/Permission.Service/Services/SysUserService.cs

using System.Collections.Generic;
using Permission.Entity.System;
using Permission.Service.IServices;
using System.Linq;
using Permission.Utils.Validate;
using System;
using System.IO;
using AutoMapper;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Permission.Infrastructure.Repositories;
using Permission.Entity.DbContext;
using Permission.Infrastructure.WebControls;
using Permission.Service.DTO.ApiModels;
using Permission.Utils.Converts;

namespace Permission.Service.Services
{
    public class SysUserService : ISysUserService
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly PermissionContext _dbContext;
        private readonly IHostingEnvironment _env;
        private readonly IMapper _mapper;
        private readonly IBaseRepository<SysUser> _sysUserRepository;
        private readonly IBaseRepository<SysRole> _sysRoleRepository;
        private readonly IBaseRepository<SysMenu> _sysMenuRepository;
        private readonly ISysRoleService _sysRoleService;
        private readonly ISysOrganizeService _sysOrganizeService;

        public SysUserService(IUnitOfWork unitOfWork, PermissionContext dbContext, IHostingEnvironment env,IMapper mapper, IBaseRepository<SysUser> sysUserRepository, IBaseRepository<SysRole> sysRoleRepository, IBaseRepository<SysMenu> sysMenuRepository, ISysRoleService sysRoleService, ISysOrganizeService sysOrganizeService)
        {
            this._unitOfWork = unitOfWork;
            this._dbContext = dbContext;
            this._env = env;
            this._mapper = mapper;
            this._sysUserRepository = sysUserRepository;
            this._sysRoleRepository = sysRoleRepository;
            this._sysMenuRepository = sysMenuRepository;
            this._sysRoleService = sysRoleService;
            this._sysOrganizeService = sysOrganizeService;
        }

        public bool AddModel(SysUser model)
        {
            try
            {
                model.GuidId = Guid.NewGuid().ToString();
                string defaultpass = "123456";
                model.Password = defaultpass.ToMd5();
                model.IsEnabled = model.IsEnabled != null;
                model.DeleteMark = false;
                model.CreateTime = DateTime.Now;
                var res = _sysUserRepository.Save(model);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public bool ModifyModel(SysUser model)
        {
            try
            {
                var user = _sysUserRepository.Get(model.Id);
                user.RealName = model.RealName;
                user.NickName = model.NickName;
                user.Birthday = model.Birthday;
                user.Gender = model.Gender;
                user.Email = model.Email;
                user.OrganizeId = model.OrganizeId;
                user.DepartmentId = model.DepartmentId;
                user.DutyName = model.DutyName;
                user.MobilePhone = model.MobilePhone;
                user.QQ = model.QQ;
                user.WeChat = model.WeChat;
                user.MSN = model.MSN;
                user.IsEnabled = model.IsEnabled;
                user.Address = model.Address;
                user.Signature = model.Signature;
                user.ModifyTime = DateTime.Now;
                user.ModifyUser = model.ModifyUser;
                user.Remark = model.Remark;
                var res = _sysUserRepository.Update(user);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public bool ModifyPass(SysUser model)
        {
            try
            {
                var user = _sysUserRepository.Get(model.Id);
                user.Password = model.Password;
                var res = _sysUserRepository.Update(user);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void SetUserRoles(int userId, params int[] roleIds)
        {
            try
            {
                var current = _customerById(_dbContext, userId);

                if (roleIds == null)
                {
                    //清空当前用户下所有角色
                    //current.UserRoleList.Clear();
                    current.UserRoles.Clear();
                }
                else
                {
                    //a.用户需要重新设置的权限ID集合。
                    var newRoleIdList = roleIds.ToList();
                    var newRoleList = _sysRoleRepository.LoadAll(m => newRoleIdList.Contains(m.Id) && m.IsEnabled == true && m.DeleteMark == false).ToList();

                    //b.清空当前用户下所有角色
                    //current.UserAuthorizeList.Clear();
                    current.UserRoles.Clear();

                    //c.新集合中剩下的角色信息新增到数据库。
                    UserRole model;
                    newRoleList.ForEach((role) =>
                    {
                        model = new UserRole
                        {
                            GuidId = Guid.NewGuid().ToString(),
                            UserId = userId,
                            RoleId = role.Id,
                            SortCode = role.SortCode,
                            CreateTime = DateTime.Now
                            //CreateUser = "",
                        };
                        //current.UserRoleList.Add(model);
                        current.UserRoles.Add(model);
                    });
                }
                _unitOfWork.SaveChanges();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public SysUser GetUserByAccount(string account)
        {
            try
            {
                if (!account.IsEmpty())
                {
                    var data = _sysUserRepository.Get(m => m.Account == account);
                    return data;
                }
                return null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public SysUser GetUserByMobile(string mobile)
        {
            try
            {
                if (!mobile.IsEmpty())
                {
                    var data = _sysUserRepository.Get(m => m.MobilePhone == mobile);
                    return data;
                }
                return null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public SysUser GetUserByAccountOrMobile(string loginName)
        {
            try
            {
                if (!loginName.IsEmpty())
                {
                    var data = _sysUserRepository.Get(m => m.MobilePhone == loginName || m.Account == loginName);
                    return data;
                }
                return null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public SysUser GetUserByKey(int key)
        {
            try
            {
                if (!key.IsEmpty() || key > 0)
                {
                    var data = _customerById(_dbContext, key);
                    return data;
                }
                return null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public SysUser GetUserOrgByKey(int key)
        {
            try
            {
                if (!key.IsEmpty() || key > 0)
                {
                    var data = _customerOrgById(_dbContext, key);
                    return data;
                }
                return null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public List<SysMenu> UserLoginPermissions(int userId)
        {
            List<int> currentmenuids = new List<int>();

            if (userId.IsEmpty() || userId <= 0)
            {
                return null;
            }
            else
            {
                //原先方式
                //var current = _sysUserRepository.Entities.Include("UserRoleList").Include("UserAuthorizeList").Where(u => u.Id == userId && u.IsEnabled == true && u.DeleteMark == false).FirstOrDefault();
                //获取当前用户信息
                var current = _customerById(_dbContext, userId);

                //获取登陆用户角色信息
                //var rids = current.UserRoleList.Select(ur => ur.RoleId);
                var rids = current.UserRoles.Select(ur => ur.RoleId);

                //获取角色拥有的权限信息
                foreach (var rid in rids)
                {
                    var menus = _sysRoleService.GetMenuIdListByRoleId(rid);
                    currentmenuids.AddRange(menus);
                }

                //获取登陆用户权限信息
                //var userpermissids = current.UserAuthorizeList.Select(ua => ua.MenuId).ToList();
                var userpermissids = current.UserAuthorizes.Select(ua => ua.MenuId).ToList();
                currentmenuids.AddRange(userpermissids);

                var resmenuids = currentmenuids.Distinct();

                var data =
                    _sysMenuRepository.LoadAll(m => resmenuids.Contains(m.Id) && m.IsEnable == true && m.DeleteMark == false)
                    .OrderBy(ms => ms.SortCode)
                    .ToList();

                return data;
            }
        }

        public Page<SysUser> PageList(string keyword, int pageindex, int pagesize)
        {
            try
            {
                //if (keyword.IsEmpty())
                //{
                //    var data = _sysUserRepository.PageList<DateTime>(pageindex, pagesize, u => u.DeleteMark == false, us => us.CreateTime.Value, false);
                //    return data;
                //}
                //else
                //{
                //    var data = _sysUserRepository.PageList<DateTime>(pageindex, pagesize, u => (u.Account.Contains(keyword) || u.RealName.Contains(keyword)) && u.DeleteMark == false, us => us.CreateTime.Value, false);
                //    return data;
                //}

                int total = 0;
                if (keyword.IsEmpty())
                {
                    var data = _sysUserRepository.PageList(pageindex, pagesize, us => us.OrderBy(ur => ur.CreateTime),
                        u => _customerOrgById(_dbContext, u.Id),
                        out total,
                        u => u.DeleteMark == false);

                    return data;
                }
                else
                {
                    var data = _sysUserRepository.PageList(pageindex, pagesize, us => us.OrderBy(ur => ur.CreateTime), u => _customerOrgById(_dbContext, u.Id),
                        out total,
                        u => (u.Account.Contains(keyword) || u.RealName.Contains(keyword)) && u.DeleteMark == false);
                    return data;
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public List<int> GetMenuIdListByUserId(int userId)
        {
            var data =
                _customerById(_dbContext, userId)
                    .UserAuthorizes.Where(m => m.UserId == userId)
                    .Select(m => m.MenuId)
                    .ToList();
            return data;
        }

        public void SetUserAuthorize(int userId, params int[] menuIds)
        {
            var currentUser = _customerById(_dbContext, userId);

            if (menuIds == null)
            {
                //清空当前用户下所有权限
                currentUser.UserAuthorizes.Clear();
            }
            else
            {
                //a.角色需要重新设置的权限ID集合。
                var newMenuIdList = menuIds.ToList();
                var newMenuList = _sysMenuRepository.LoadAll(m => newMenuIdList.Contains(m.Id) && m.IsEnable == true && m.DeleteMark == false).ToList();

                //c.清空当前角色下所有权限
                currentUser.UserAuthorizes.Clear();

                //d.新集合中剩下的授权信息新增到数据库。
                UserAuthorize model;
                newMenuList.ForEach((menu) =>
                {
                    model = new UserAuthorize
                    {
                        GuidId = Guid.NewGuid().ToString(),
                        UserId = userId,
                        MenuId = menu.Id,
                        SortCode = menu.SortCode,
                        CreateTime = DateTime.Now
                        //CreateUser = "",
                    };
                    currentUser.UserAuthorizes.Add(model);
                });
            }
            _unitOfWork.SaveChanges();
        }

        public bool UpdateUsersOpenId(int userId, string openId)
        {
            try
            {
                if (!userId.IsEmpty() || userId > 0)
                {
                    var model = _sysUserRepository.Get(userId);
                    model.Secretkey = openId;
                    return _sysUserRepository.Update(model);
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public List<SysOrganize> GetGroupDepsByOrgId(int userId, int orgId)
        {
            List<SysOrganize> organizes = new List<SysOrganize>();
            try
            {
                if (!userId.IsEmpty() || userId > 0)
                {
                    var user = _customerOrgById(_dbContext, userId);
                    if (!orgId.IsEmpty() || orgId > 0)
                    {
                        if (user.Department != null)
                        {
                            var userdep = user.Department;
                            organizes.Add(userdep);
                        }
                        return organizes;
                    }
                    else
                    {
                        return null;
                    }
                }
                else
                {
                    return null;
                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #region 私有方法

        private static Func<PermissionContext, int, SysUser> _customerById =
            EF.CompileQuery((PermissionContext db, int userId) => db.SysUsers
                                  .Include(u => u.UserRoles)
                                  .Include(u => u.UserAuthorizes)
                                  .FirstOrDefault(c => c.Id == userId));

        private static Func<PermissionContext, int, SysUser> _customerOrgById =
            EF.CompileQuery((PermissionContext db, int userId) => db.SysUsers
                .Include(u => u.Organize)
                .Include(u => u.Department)
                .FirstOrDefault(c => c.Id == userId));


        #endregion

        #region api

        public bool UpdateUserModelApi(UserModel userModel)
        {
            try
            {
                var model = _mapper.Map<SysUser>(userModel);
                if (userModel.HeadBytes != null)
                {
                    var headcontent = StringBase64.Base64Formart(userModel.HeadBytes);
                    if (!headcontent.IsEmpty())
                    {
                        var headBytes = Convert.FromBase64String(headcontent);
                        var webRootInfo = _env.WebRootPath;
                        var basePath = System.IO.Path.Combine(webRootInfo, "HeadImgs");
                        if (!Directory.Exists(basePath))
                        {
                            Directory.CreateDirectory(basePath);
                        }
                        var imgPath = Path.Combine(basePath, userModel.UserId + ".jpg");
                        var fs = new FileStream(imgPath, FileMode.Create, FileAccess.Write);
                        var bw = new BinaryWriter(fs);
                        bw.Write(headBytes);
                        bw.Close();
                        fs.Close();
                        model.HeadIcon = "/HeadImgs/" + userModel.UserId + ".jpg";
                    }
                }
                if (!string.IsNullOrEmpty(model.HeadIcon))
                {
                    model.HeadIcon = "/HeadImgs/" + userModel.UserId + ".jpg";
                }
                var res = this.ModifyModel(model);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public UserModel GetUsersByIdApi(string userId)
        {
            try
            {
                if (!userId.IsEmpty())
                {
                    var user = _customerOrgById(_dbContext, int.Parse(userId));
                    var data = _mapper.Map<UserModel>(user);
                    return data;
                }
                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public bool CheckLoginApi(string loginname, string loginpass, out string msg, out UserModel userModel)
        {
            bool flag = false;
            if (loginname.IsEmpty() || loginpass.IsEmpty())
            {
                userModel = null;
                msg = "请求失败，缺少必要参数。";
                flag = false;
            }

            var usermodel = this.GetUserByAccountOrMobile(loginname);
            if (usermodel == null)
            {
                //SysLogger.Info(2, loginModel.Account, HttpContext.GetOperIp(), "登陆失败！该账户不存在，请重新输入。");
                userModel = null;
                msg = "该账户不存在，请重新输入。";
                flag = false;
            }
            if (usermodel.IsEnabled != true)
            {
                //SysLogger.Info(2, loginModel.Account, HttpContext.GetOperIp(), "登陆失败！该账户已被禁用，请联系管理员。");
                userModel = null;
                msg = "该账户已被禁用，请联系管理员。";
                flag = false;
            }
            string pass = loginpass.ToMd5();
            if (!usermodel.Password.Equals(pass))
            {
                //LogHelper.Write(Level.Info, "系统登录", "密码错误", userEntity.Account, userEntity.RealName);
                //SysLogger.Info(2, loginModel.Account, HttpContext.GetOperIp(), "登陆失败！密码错误，请重新输入。");
                userModel = null;
                msg = "密码错误，请重新输入。";
                flag = false;
            }
            else
            {
                var loginuser = _customerOrgById(_dbContext, usermodel.Id);
                var model = _mapper.Map<UserModel>(loginuser);
                string openId = string.Empty;
                if (model.Secretkey.IsEmpty())
                {

                    string newOpenId = Guid.NewGuid().ToString() + DateTime.Now.ToString("yyyyMMddhhmmss");
                    //更新至数据库
                    bool addopen = this.UpdateUsersOpenId(model.UserId, newOpenId);
                    if (addopen)
                    {
                        openId = newOpenId;
                    }
                    else
                    {
                        openId = "";
                    }
                }
                else
                {
                    openId = model.Secretkey;
                }
                model.Secretkey = openId;
                flag = true;
                msg = "登陆成功！";
                userModel = model;
            }
            return flag;
        }

        public IEnumerable<DepUserModel> GetUsersByOrgIdApi(int orgId)
        {
            List<DepUserModel> data = null;
            try
            {
                if (orgId.IsEmpty())
                {
                    return null;
                }
                else
                {
                    //获取机构下部门列表
                    var deps = _sysOrganizeService.GetDepsByOrgId(orgId);
                    data = new List<DepUserModel>();
                    if (deps.Any())
                    {
                        foreach (var dep in deps)
                        {
                            var users = _sysOrganizeService.GetUsersByOrgId(dep.Id).ToList();
                            if (users.Any())
                            {
                                var depUser = new DepUserModel
                                {
                                    OrgId = orgId,
                                    DepId = dep.Id,
                                    DepName = dep.FullName,
                                    SortCode = dep.SortCode,
                                    Status = dep.IsEnabled == true ? 1 : 0,
                                    CreateTime = dep.CreateTime,
                                    CreateName = dep.CreateUser,
                                    Description = dep.Remark,
                                    UserModels = _mapper.Map<List<UserModel>>(users)
                                };
                                data.Add(depUser);
                            }
                        }
                        return data;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public IEnumerable<DepUserModel> GetGroupUsersByOrgIdApi(int userId, int orgId)
        {
            List<DepUserModel> data = null;
            try
            {
                if (orgId.IsEmpty() || userId.IsEmpty())
                {
                    return null;
                }
                else
                {
                    //获取机构下部门列表
                    var deps = this.GetGroupDepsByOrgId(userId, orgId);
                    data = new List<DepUserModel>();
                    if (deps.Any())
                    {
                        foreach (var dep in deps)
                        {
                            var users = _sysOrganizeService.GetUsersByOrgId(dep.Id).ToList();
                            if (users.Any())
                            {
                                var depUser = new DepUserModel
                                {
                                    OrgId = orgId,
                                    DepId = dep.Id,
                                    DepName = dep.FullName,
                                    SortCode = dep.SortCode,
                                    Status = dep.IsEnabled == true ? 1 : 0,
                                    CreateTime = dep.CreateTime,
                                    CreateName = dep.CreateUser,
                                    Description = dep.Remark,
                                    UserModels = _mapper.Map<List<UserModel>>(users)
                                };
                                data.Add(depUser);
                            }
                        }
                        return data;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #endregion
    }
}