tede_2.0/source/gx_api/GxPress/Service/GxPress.Service.Implement/UserService.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using AutoMapper;
using GxPress.Common.Exceptions;
using GxPress.Common.Page;
using GxPress.Entity;
using GxPress.Repository.Interface;
using GxPress.Request.App.User;
using GxPress.Request.User;
using GxPress.Result.User;
using GxPress.Service.Interface;
using GxPress.Service.Interface.IM;
using Microsoft.AspNetCore.Hosting;
using OfficeOpenXml;
using Datory;
using GxPress.Common.Tools;
using GxPress.Result.App.User;
using GxPress.Repository.Interface.WorkFlow;
using GxPress.Request.App.Flow;
using GxPress.Repository.Interface.WaitHandle;
using GxPress.Request.AddressBookGroup;
using GxPress.Repository.Interface.DepartmentUser;
using GxPress.Repository.Interface.Friends;
using GxPress.EnumConst;
using GxPress.Result.Department;
using GxPress.Service.Interface.Reply;
using GxPress.Repository.Interface.AdminVerify;
using GxPress.Service.Interface.Praise;
using Microsoft.Extensions.Caching.Distributed;
using GxPress.Common.Encrypt;
using Newtonsoft.Json;
using GxPress.Result;


namespace GxPress.Service.Implement
{
    public class UserService : IUserService
    {
        private readonly IUserRepository _userRepository;
        private readonly IDepartmentRepository _departmentRepository;
        private readonly IAddressBookGroupRepository _addressBookGroupRepository;
        private readonly IAddressBookGroupUserRepository addressBookGroupUserRepository;
        private IWebHostEnvironment _webHostEnvironment;
        private readonly IBlacklistUserRepository _blacklistUserRepository;
        private readonly IRoleRepository _roleRepository;
        private readonly IIMService _imService;
        private readonly IMapper _mapper;
        private readonly IFlowRepository _flowRepository;
        private readonly IFlowTodoRepository _flowTodoRepository;
        private readonly IWaitHandleRepository waitHandleRepository;
        private readonly IDepartmentUserRepository departmentUserRepository;
        private readonly IFriendsRepository friendsRepository;
        private readonly IGroupChatUserRepository groupChatUserRepository;
        private readonly IGroupUserRepository groupUserRepository;
        private readonly IOftenContactRepository oftenContactRepository;
        private readonly IAdminVerifyRepository adminVerifyRepository;
        private readonly IReplyService replyService;
        private readonly IPraiseService praiseService;
        private readonly IDistributedCache _cache;
        private readonly IGroupRepository groupRepository;
        private readonly IGroupChatRepository groupChatRepository;

        public UserService(IUserRepository userRepository, IDepartmentRepository departmentRepository,
            IAddressBookGroupRepository addressBookGroupRepository, IBlacklistUserRepository blacklistUserRepository,
            IMapper mapper, IWebHostEnvironment webHostEnvironment,
            IRoleRepository roleRepository, IIMService imService,
            IFlowRepository flowRepository, IFlowTodoRepository flowTodoRepository,
            IWaitHandleRepository waitHandleRepository, IDepartmentUserRepository departmentUserRepository,
            IFriendsRepository friendsRepository, IGroupChatUserRepository groupChatUserRepository,
            IGroupUserRepository groupUserRepository, IAddressBookGroupUserRepository addressBookGroupUserRepository,
            IOftenContactRepository oftenContactRepository, IReplyService replyService,
            IAdminVerifyRepository adminVerifyRepository,
            IPraiseService praiseService, IDistributedCache _cache,
            IGroupRepository groupRepository, IGroupChatRepository groupChatRepository)
        {
            _userRepository = userRepository;
            _departmentRepository = departmentRepository;
            _addressBookGroupRepository = addressBookGroupRepository;
            _blacklistUserRepository = blacklistUserRepository;
            _mapper = mapper;
            _webHostEnvironment = webHostEnvironment;
            _roleRepository = roleRepository;
            _imService = imService;
            _flowRepository = flowRepository;
            _flowTodoRepository = flowTodoRepository;
            this.waitHandleRepository = waitHandleRepository;
            this.departmentUserRepository = departmentUserRepository;
            this.friendsRepository = friendsRepository;
            this.groupChatUserRepository = groupChatUserRepository;
            this.groupUserRepository = groupUserRepository;
            this.addressBookGroupUserRepository = addressBookGroupUserRepository;
            this.oftenContactRepository = oftenContactRepository;
            this.replyService = replyService;
            this.adminVerifyRepository = adminVerifyRepository;
            this.praiseService = praiseService;
            this._cache = _cache;
            this.groupRepository = groupRepository;
            this.groupChatRepository = groupChatRepository;
        }

        /// <summary>
        /// 根据部门ID获取自建ID获取用户列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> FindUser(FindUserRequest request)
        {
            var userInfoResults = new List<UserInfoResult>();
            if (request.TypeId == 1)
            {
                //获取部门
                List<Entity.Department> departments = new List<Entity.Department>();
                foreach (var item in request.ItemId)
                {
                    if (item > 0)
                    {
                        var users = await _userRepository.GetUserByDepartmentIdAsync(item);
                        userInfoResults.AddRange(users.Select(user => _mapper.Map<UserInfoResult>(user)).ToList());
                    }
                    departments = await _departmentRepository.GetDepartmentByPid(item, departments);
                }
                foreach (var department in departments)
                {
                    //获取部门下面的员工
                    var users = await _userRepository.GetUserByDepartmentIdAsync(department.Id);
                    userInfoResults.AddRange(users.Select(user => _mapper.Map<UserInfoResult>(user)).ToList());
                }
            }

            //查询自建用户
            if (request.TypeId == 2)
            {
                var users = new List<User>();
                foreach (var item in request.ItemId)
                {
                    if (item > 0)
                    {
                        users.AddRange(await _addressBookGroupRepository.GetUserByAddressBookGroupIdAsync(item));
                    }

                    users = await _addressBookGroupRepository.GetUserByAddressBookGroupPidAsync(users, item,
                        request.UserId);
                }

                userInfoResults.AddRange(users.Select(user => _mapper.Map<UserInfoResult>(user)).ToList());
            }

            foreach (var item in userInfoResults)
            {
                if (item == null)
                    continue;
                item.AvatarUrl = StringUtils.AddDomainMin(item.AvatarUrl);
            }

            return userInfoResults.Distinct();
        }

        /// <summary>
        /// 根据ID查询用户数据
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="blackUserId"></param>
        /// <returns></returns>
        public async Task<UserDetail> GetUserByIdAsync(int userId, int blackUserId)
        {
            var user = await _userRepository.GetAsync(blackUserId);
            if (user == null)
            {
                throw new BusinessException("用户id有误");
            }
            var userDetail = _mapper.Map<UserDetail>(user);
            // if (user.DepartmentId > 0)
            // {
            //     var department = await _departmentRepository.GetAsync(user.DepartmentId);
            //     userDetail.DepartmentName = department.Name;
            // }
            userDetail.AvatarUrl = StringUtils.AddDomainMin(userDetail.AvatarUrl);
            userDetail.HistoryAvatarUrl = StringUtils.AddDomainMin(userDetail.HistoryAvatarUrl);
            userDetail.IsBlack = await _blacklistUserRepository.FindUserIsBlack(userId, blackUserId);
            return userDetail;
        }

        /// <summary>
        /// 生成excel
        /// </summary>
        /// <returns></returns>
        public async Task<string> ExcelUserAsync(List<int> userIds)
        {
            string sWebRootFolder = _webHostEnvironment.WebRootPath;
            string sFileName = $"{Guid.NewGuid()}.xlsx";
            FileInfo file = new FileInfo(Path.Combine(sWebRootFolder, sFileName));
            using (ExcelPackage package = new ExcelPackage(file))
            {
                // 添加worksheet
                ExcelWorksheet worksheet = package.Workbook.Worksheets.Add("员工信息"); //添加头
                worksheet.Cells[1, 1].Value = "姓名";
                worksheet.Cells[1, 2].Value = "手机号码";
                worksheet.Cells[1, 3].Value = "邮箱"; //添加值
                worksheet.Cells[1, 4].Value = "性别"; //添加值
                worksheet.Cells[1, 5].Value = "部门"; //添加值
                worksheet.Cells[1, 6].Value = "角色"; //添加值
                //获取用户
                var users = await _userRepository.FindAllUserAsync(Q.WhereIn(nameof(User.Id), userIds));
                var enumerable = users as User[] ?? users.ToArray();
                for (int i = 0; i < enumerable.Count(); i++)
                {
                    var index = i + 2;
                    worksheet.Cells["A" + index].Value = enumerable[i].Name;
                    worksheet.Cells["B" + index].Value = enumerable[i].Phone;
                    worksheet.Cells["C" + index].Value = enumerable[i].Email;
                    worksheet.Cells["D" + index].Value = enumerable[i].Gender == "Male" ? "男" : "女";
                    //获取部门
                    var department = await _departmentRepository.GetAsync(enumerable[i].DepartmentId);
                    worksheet.Cells["E" + index].Value = department == null ? "" : department.Name;
                    //获取角色
                    var role = await _roleRepository.GetAsync(enumerable[i].RoleId);
                    worksheet.Cells["F" + index].Value = role == null ? "" : role.Name;
                }

                package.Save();
            }

            return Path.Combine(sWebRootFolder, sFileName);

        }



        /// <summary>
        /// 用户分页列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PagedList<UserResult>> GetPagedListAsync(UserPageSearchRequest request)
        {
            var pagedList = new PagedList<UserResult>
            {
                Total = await GetCountAsync(request.DepartmentId, request.RoleId, request.Keyword)
            };
            var list = await _userRepository.GetPageUserResultAsync(request);
            var items = list.Select(user => _mapper.Map<UserResult>(user)).ToList();
            foreach (var item in items)
            {
                item.AvatarUrl = StringUtils.AddDomain(item.AvatarUrl);
                // var departmentName = string.Empty;
                // //获取部门
                // departmentName =
                //     await _departmentRepository.GetDepartmentFullPathAsync(item.DepartmentId, departmentName);
                // item.DepartmentName = departmentName;
                item.DepartmentIds = await departmentUserRepository.GetDepartmentIdsAsync(item.Id);
                var role = await _roleRepository.GetAsync(item.RoleId);
                if (role != null)
                    item.RoleName = role.Name;
            }

            pagedList.Items = items;
            return pagedList;
        }

        public async Task<int> GetCountAsync(int departmentId, int roleId, string keyword)
        {
            var query = Q.NewQuery();
            if (departmentId > 0)
            {
                var userIds = await departmentUserRepository.GetUserIdsAsync(departmentId);
                query.WhereIn(nameof(User.Id), userIds);
                query.Where(nameof(User.DepartmentId), departmentId);
            }

            if (roleId > 0)
            {
                query.Where(nameof(User.RoleId), roleId);
            }

            if (!string.IsNullOrEmpty(keyword))
            {
                keyword = "%" + keyword + "%";
                query.Where(q =>
                    q.WhereLike(nameof(User.Name), keyword)
                        .OrWhereLike(nameof(User.Email), keyword)
                        .OrWhereLike(nameof(User.Phone), keyword)
                );
            }

            return await _userRepository.CountAsync(query);
        }

        /// <summary>
        /// Set the limit and offset for a given page.
        /// </summary>
        /// <param name="page"></param>
        /// <param name="perPage"></param>
        /// <param name="departmentId"></param>
        /// <param name="roleId"></param>
        /// <param name="keyword"></param>
        /// <returns></returns>
        public async Task<IEnumerable<User>> GetPageListAsync(int page, int perPage, int departmentId, int roleId,
            string keyword)
        {
            var query = Q.ForPage(page, perPage);
            if (departmentId > 0)
            {
                var userIds = await departmentUserRepository.GetUserIdsAsync(departmentId);
                query.WhereIn(nameof(User.Id), userIds);
                //query.Where(nameof(User.DepartmentId), departmentId);
            }

            if (roleId > 0)
            {
                query.Where(nameof(User.RoleId), roleId);
            }

            if (!string.IsNullOrEmpty(keyword))
            {
                keyword = "%" + keyword + "%";
                query.Where(q =>
                    q.WhereLike(nameof(User.Name), keyword)
                        .OrWhereLike(nameof(User.Email), keyword)
                        .OrWhereLike(nameof(User.Phone), keyword)
                );
            }
            return await _userRepository.GetAllAsync(query);
        }

        public async Task<PagedList<User>> GetPageListAsync(UserPageSearchRequest request)
        {
            var result = new PagedList<User>();
            var query = Q.ForPage(request.Page, request.PerPage);
            if (request.DepartmentId > 0)
            {
                var userIds = await departmentUserRepository.GetUserIdsAsync(request.DepartmentId);
                query.WhereIn(nameof(User.Id), userIds);
                //query.Where(nameof(User.DepartmentId), request.DepartmentId);
            }

            if (request.RoleId > 0)
            {
                query.Where(nameof(User.RoleId), request.RoleId);
            }

            if (!string.IsNullOrEmpty(request.Keyword))
            {
                request.Keyword = "%" + request.Keyword + "%";
                query.Where(q =>
                    q.WhereLike(nameof(User.Name), request.Keyword)
                        .OrWhereLike(nameof(User.Email), request.Keyword)
                        .OrWhereLike(nameof(User.Phone), request.Keyword)
                );
            }
            result.Items = await _userRepository.GetAllAsync(query);
            result.Total = await _userRepository.CountAsync(query);
            return result;
        }
        /// <summary>
        /// 删除用户
        /// </summary>
        /// <param name="userIds"></param>
        /// <returns></returns>
        public async Task<bool> DeleteUsersAsync(IEnumerable<int> userIds)
        {
            var enumerable = userIds as int[] ?? userIds.ToArray();
            foreach (var userId in enumerable)
            {
                var user = await _userRepository.GetAsync(userId);
                if (user != null)
                {
                    await _imService.DeleteUserAsync(user.ImId);
                }
            }

            return await _userRepository.DeleteUsersAsync(enumerable);
        }
        /// <summary>
        /// 获取用户未读数据
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<UserCountResult> GetUserCountAsync(int userId)
        {
            var result = await _userRepository.GetUserCountAsync(userId);
            #region  私信未读数据
            //我收到的赞
            var praiseCount = await praiseService.GetPraiseUReadCountAsync(userId);
            //回复我的
            var replyUReadCount = await replyService.GetReplyUReadCountAsync(userId);
            //验证信息数量
            var uReadVerifyCount = await adminVerifyRepository.UReadVerifyCountAsync(userId);
            if (uReadVerifyCount > 0)
                uReadVerifyCount = 1;
            if ((praiseCount + replyUReadCount) >= 1)
                replyUReadCount = 1;
            result.UReadChatCount = replyUReadCount + uReadVerifyCount;
            #endregion

            //工作我的审批未操作数量
            var request = new FlowListRequest();
            result.FlowAuditUReadCount = await _userRepository.GetUserUReadFlowTodoCountAsync(userId);
            //待办事项未执行数量
            result.WaitHandleUFinishCount = await waitHandleRepository.GetUFinishAsync(userId);
            return result;
        }
        /// <summary>
        /// 获取用户的通讯录
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<UserLinkResult> GetUserLinkResultAsync(int userId)
        {
            //获取用户
            var user = await _userRepository.GetAsync(userId);
            //单位通讯录
            var userLinkResult = new List<UserLinkModelResult>();
            var departmentIds = await departmentUserRepository.GetDepartmentIdsAsync(userId);
            if (departmentIds.Count() > 0)
            {
                var userLinkModelAttributeResult = new List<UserLinkModelAttributeResult>();
                var departments = await _departmentRepository.GetUserInDepartmentAsync(departmentIds.ToList());
                foreach (var department in departments)
                {
                    //var userInfoResults = await GetUserInfoByDepartentResult(department.Id);
                    userLinkModelAttributeResult.Add(new UserLinkModelAttributeResult
                    {
                        Id = department.Id,
                        Name = department.Name,
                        UserCount = await GetUserInfoByDepartmentCountResult(department.Id, departmentIds),
                        TypeId = UserlinkConst.Work.GetHashCode(),
                        TypeValue = 0,
                    });
                }

                //单位通讯录
                userLinkResult.Add(new UserLinkModelResult
                {
                    TypeId = UserlinkConst.Work.GetHashCode(),
                    Name = UserlinkConst.Work.GetDescriptionOriginal(),
                    Items = userLinkModelAttributeResult
                });
            }
            //系统通讯录  查询我的小组和群聊
            //var groupUserCount=await 
            userLinkResult.Add(
              new UserLinkModelResult
              {
                  TypeId = UserlinkConst.System.GetHashCode(),
                  Name = UserlinkConst.System.GetDescriptionOriginal(),
                  Items = new List<UserLinkModelAttributeResult>{
                        new UserLinkModelAttributeResult{
                        Id=0,
                        Name=UserlinkConst.MyGroup.GetDescriptionOriginal(),
                        TypeValue=UserlinkConst.MyGroup.GetHashCode(),
                        TypeId= UserlinkConst.System.GetHashCode(),
                        UserCount=await groupRepository.GetJoinGroupCountAsync(userId)
                        },
                        new UserLinkModelAttributeResult{
                        Id=0,
                        Name=UserlinkConst.MyGroupChat.GetDescriptionOriginal(),
                        TypeId= UserlinkConst.System.GetHashCode(),
                        TypeValue=UserlinkConst.MyGroupChat.GetHashCode(),
                        UserCount=await groupChatRepository.GetJoinGroupChatCountAsync(userId)
                        }
                  }
              }
          );
            //自建通讯录
            var addressBookGroupList = await _addressBookGroupRepository.GetAddressBookGroupListAsync(
                new AddressBookGroupSearchRequest { ParendId = 0, UserId = userId });
            var systemLinkModelAttributeResults = new List<UserLinkModelAttributeResult>();
            foreach (var item in addressBookGroupList)
                systemLinkModelAttributeResults.Add(new UserLinkModelAttributeResult
                {
                    Id = item.Id,
                    Name = item.GroupName,
                    TypeId = UserlinkConst.My.GetHashCode(),
                    UserCount = item.UserCount
                });
            if (addressBookGroupList.Count() > 0)
                //自建通讯录
                userLinkResult.Add(
                    new UserLinkModelResult
                    {
                        TypeId = UserlinkConst.My.GetHashCode(),
                        Name = UserlinkConst.My.GetDescriptionOriginal(),
                        Items = systemLinkModelAttributeResults
                    }
                );
            userLinkResult.Add(
               //其他
               new UserLinkModelResult
               {
                   TypeId = UserlinkConst.Other.GetHashCode(),
                   Name = UserlinkConst.Other.GetDescriptionOriginal(),
                   Items = new List<UserLinkModelAttributeResult>()
               }
           );
            //获取用户好友
            var userIds = await friendsRepository.GetFriendsIdsAsync(userId, 0);
            var result = new UserLinkResult()
            {
                Items = userLinkResult,
                FriendUsers = await _userRepository.GetUserInfoResultsAsync(userIds),
                LatelyChatUsers = await GetLatelyChatUsersAsync(userId)
            };
            // if (result.FriendUsers != null && result.FriendUsers.Count() > 0)
            //     foreach (var item in result.FriendUsers)
            //         item.AvatarUrl = StringUtils.AddDomainMin(item.AvatarUrl);
            return result;
        }
        /// <summary>
        /// 获取最近聊天用户
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> GetLatelyChatUsersAsync(int userId)
        {
            var userIds = await oftenContactRepository.GetAllAsync(userId);
            var item = await _userRepository.GetUserInfoResultsAsync(userIds);
            foreach (var userInfo in item)
            {
                userInfo.TypeId = 0; userInfo.TypeValue = 0;
            }
            return item;
        }
        /// <summary>
        /// 获取好友列表
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="keyWord"></param>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> GetFriendUserInfoResult(int userId, string keyWord)
        {
            //获取用户好友
            var userIds = await friendsRepository.GetFriendsIdsAsync(userId, 0);
            return await _userRepository.GetUserInfoResultsAsync(userIds, keyWord);
        }
        /// <summary>
        /// 更新用户信息
        /// </summary>
        /// <param name="id"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> UpdateAsync(int id, UserInfoRequest request)
        {
            var user = await _userRepository.GetAsync(id);
            if (user == null) throw new BusinessException("该用户不存在");
            if (request.DepartmentId != null && request.DepartmentId.Count() > 0)
                await departmentUserRepository.AddDepartmentUserAsync(request.DepartmentId, id);
            if (!string.IsNullOrEmpty(request.DepartmentName))
                user.DepartmentName = request.DepartmentName;
            if (!string.IsNullOrEmpty(request.Nick))
                user.Nick = request.Nick;
            if (!string.IsNullOrEmpty(request.Description))
                user.Description = request.Description;
            if (!string.IsNullOrEmpty(request.Gender))
                user.Gender = request.Gender;
            if (!string.IsNullOrEmpty(request.Name))
                user.Name = request.Name;
            if (!string.IsNullOrEmpty(request.Position))
                user.Position = request.Position;
            if (request.RoleId > 0)
                user.RoleId = request.RoleId;
            if (!string.IsNullOrEmpty(request.Signature))
                user.Signature = request.Signature;
            //用户头像
            if (!string.IsNullOrEmpty(request.AvatarUrl))
            {
                user.HistoryAvatarUrl = user.AvatarUrl;
                user.AvatarUrl = StringUtils.RemoveDomain(request.AvatarUrl);
            }
            user.Email = request.Email;
            if (!string.IsNullOrWhiteSpace(request.Phone))
                user.Phone = request.Phone;
            user.QRCoder = StringUtils.RemoveDomain(user.QRCoder);
            if (request.IsDisable > 0)
                user.IsDisable = request.IsDisable == 1;
            if (request.IsFreeze > 0)
                user.IsFreeze = request.IsFreeze == 1;
            if (request.IsVip > 0)
                user.IsVip = request.IsVip == 1;
            if (request.IsLeader > 0)
                user.IsLeader = request.IsLeader == 1;
            if (request.IsMute > 0)
                user.IsMute = request.IsMute == 1;
            if (!string.IsNullOrWhiteSpace(request.DisableTiem))
                user.DisableTiem = Convert.ToDateTime(request.DisableTiem);
            if (request.IsNotice > 0)
                user.IsNotice = request.IsNotice == 1;
            return await _userRepository.UpdateAsync(user);
        }

        public async Task<UserInfoResult> GetUserInfoAsync(int id)
        {
            var result = await _userRepository.GetUserInfoAsync(id);
            result.DepartmentIds = await departmentUserRepository.GetDepartmentIdsAsync(id);
            return result;
        }
        /// <summary>
        /// 查询不是好友的用户
        /// </summary>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> FindUserInfoNoFriendsResultAsync(int userId, string keyword)
        {
            var userIds = await friendsRepository.GetFriendsIdsAsync(userId, -1);
            var userIdsList = userIds.ToList();
            userIdsList.Add(userId);
            //判断是否有部门
            if (await departmentUserRepository.IsExistsAsync(userId))
                //获取部门数据
                userIdsList.AddRange(await departmentUserRepository.GetUserIdsAsync());
            var result = await _userRepository.GetUserInfoNoFriendsResults(keyword, userIdsList);
            return result;
        }
        /// <summary>
        /// 搜索好友和部门用户
        /// </summary>
        /// <param name="keyword"></param>
        /// <param name="userIds"></param>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> GetSearchUserInfoResults(int userId, string keyword)
        {
            var userIds = await friendsRepository.GetFriendsIdsAsync(userId, -1);
            var userIdsList = userIds.ToList();
            userIdsList.Add(userId);
            //判断是否有部门
            if (await departmentUserRepository.IsExistsAsync(userId))
                //获取部门数据
                userIdsList.AddRange(await departmentUserRepository.GetUserIdsAsync());
            var result = await _userRepository.GetSearchUserInfoResults(keyword, userIdsList);
            return result;
        }
        /// <summary>
        /// 用户注册
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> RegisterAsync(RegisterRequest request)
        {
            if (string.IsNullOrEmpty(request.Phone) && (string.IsNullOrEmpty(request.Code) || string.IsNullOrEmpty(request.PassWord)))
                throw new BusinessException("必填项为空");
            var query = Q.NewQuery();
            query.Where(nameof(Entity.User.Phone), request.Phone);
            query.Where(nameof(Entity.User.IsDelete), false);
            if (await _userRepository.ExistsAsync(query))
                throw new BusinessException("手机号码已经存在");
            var key = $"login:{request.Phone}";
            var code = await _cache.GetStringAsync(key);
            if (string.IsNullOrEmpty(code))
                throw new BusinessException("验证码已过期");
            code = code.Replace("\"", "");
            if (!request.Code.Equals(code, StringComparison.OrdinalIgnoreCase))
                throw new BusinessException("验证码错误");
            var user = new Entity.User
            {
                Phone = request.Phone,
                Gender = "Male",
                OpenId = request.OpenId,
                PassWord = string.IsNullOrEmpty(request.PassWord) ? "" : EncryptProvider.Md5(request.PassWord)
            };
            var userId = await _userRepository.InsertAsync(user);
            return userId > 0;
        }

        /// <summary>
        /// 用户注册
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<AppResultJson<UserSignInResult>> JsonRegisterAsync(RegisterRequest request)
        {
            var result = new AppResultJson<UserSignInResult>()
            {
                Code = StatusCodeConst.SucceedCode.GetHashCode(),
                Success = true
            };
            if (string.IsNullOrEmpty(request.Phone) && (string.IsNullOrEmpty(request.Code) || string.IsNullOrEmpty(request.PassWord)))
            {
                result.Code = StatusCodeConst.ErrorCode.GetHashCode();
                result.Msg = "必填项为空";
                result.Success = false;
                return result;
            }
            var query = Q.NewQuery();
            query.Where(nameof(Entity.User.Phone), request.Phone);
            query.Where(nameof(Entity.User.IsDelete), false);
            if (await _userRepository.ExistsAsync(query))
            {
                result.Code = StatusCodeConst.RegisterCode.GetHashCode();
                result.Success = false;
                result.Msg = "手机号码已经存在";
                return result;
            }
            var key = $"login:{request.Phone}";
            var code = await _cache.GetStringAsync(key);
            if (string.IsNullOrEmpty(code))
            {
                result.Code = StatusCodeConst.ErrorCode.GetHashCode();
                result.Success = false;
                result.Msg = "验证码已过期";
                return result;
            }
            code = code.Replace("\"", "");
            if (!request.Code.Equals(code, StringComparison.OrdinalIgnoreCase))
            {
                result.Code = StatusCodeConst.ErrorCode.GetHashCode();
                result.Success = false;
                result.Msg = "验证码错误";
                return result;
            }
            var user = new Entity.User
            {
                Phone = request.Phone,
                Gender = "Male",
                OpenId = request.OpenId,
                PassWord = string.IsNullOrEmpty(request.PassWord) ? "" : EncryptProvider.Md5(request.PassWord)
            };
            var userId = await _userRepository.InsertAsync(user);
            return result;
        }
        /// <summary>
        /// 用户注册
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> FindPasswordAsync(RegisterRequest request)
        {
            if (string.IsNullOrEmpty(request.Phone) || string.IsNullOrEmpty(request.Code) || string.IsNullOrEmpty(request.PassWord))
                throw new BusinessException("必填项为空");
            var query = Q.NewQuery();
            query.Where(nameof(Entity.User.Phone), request.Phone);
            if (!await _userRepository.ExistsAsync(query))
                throw new BusinessException("手机号码不经存在");
            var key = $"login:{request.Phone}";
            var code = _cache.GetString(key).Replace("\"", "");
            if (string.IsNullOrEmpty(code))
                throw new BusinessException("验证码已过期");
            if (!request.Code.Equals(code, StringComparison.OrdinalIgnoreCase))
                throw new BusinessException("验证码错误");
            var user = await _userRepository.GetAsync(query);
            user.PassWord = EncryptProvider.Md5(request.PassWord);
            return await _userRepository.UpdateAsync(user);
        }
        /// <summary>
        /// 根据部门ID获取用户
        /// </summary>
        /// <param name="departentId"></param>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> GetUserInfoByDepartentResult(int departentId)
        {
            var departentList = new List<DepartmentResult>();
            var departent = await _departmentRepository.GetDepartmentById(departentId, departentList);
            var userIds = await departmentUserRepository.GetUserIdsAsync(departent.Select(n => n.Id));
            var result = await _userRepository.GetUserInfoResultsAsync(userIds);
            return result;
        }

        public async Task<int> GetUserInfoByDepartmentCountResult(int departentId, IEnumerable<int> departmentIds)
        {
            var departentList = new List<DepartmentResult>();
            var departent = await _departmentRepository.GetDepartmentById(departentId, departentList);
            var departents = departent.Where(n => departmentIds.Contains(n.Id));
            var userIds = await departmentUserRepository.GetUserIdsAsync(departents.Select(n => n.Id));
            var result = await _userRepository.GetUserInfoResultsAsync(userIds);
            return result.Count();
        }
        /// <summary>
        /// 获取群聊和小组的用户
        /// </summary>
        /// <param name="typeValue"></param>
        /// <param name="id"></param>
        /// <param name="keyword"></param>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> GetGroupOrGroupChatUserInfosResult(UserInfoByGroupoRoGroupChatResult request)
        {
            if (request.Id == 0)
                return await GetAllGroupOrGroupChatUserInfosResult(request);
            //群聊
            if (request.TypeValue == UserlinkConst.MyGroupChat.GetHashCode())
            {
                var groupChatUsers = await groupChatUserRepository.GetAllAsync(Q.Where(nameof(Entity.GroupChatUser.GroupChatId), request.Id));
                var result = await _userRepository.GetSearchUserInfoResults(request.Keyword, groupChatUsers.Select(n => n.UserId));
                return result;
            }
            //小组
            if (request.TypeValue == UserlinkConst.MyGroup.GetHashCode())
            {
                var groupUsers = await groupUserRepository.GetAllAsync(Q.Where(nameof(Entity.GroupUser.GroupId), request.Id));
                var result = await _userRepository.GetSearchUserInfoResults(request.Keyword, groupUsers.Select(n => n.UserId));
                return result;
            }
            //自建小组
            if (request.TypeValue == UserlinkConst.My.GetHashCode())
            {
                var addressGroupUsers = await addressBookGroupUserRepository.GetAllAsync(Q.Where(nameof(Entity.AddressBookGroupUser.AddressBookGroupId), request.Id));
                var result = await _userRepository.GetSearchUserInfoResults(request.Keyword, addressGroupUsers.Select(n => n.UserId));
                return result;
            }
            return null;
        }
        /// <summary>
        /// 获取群聊和小组的用户
        /// </summary>
        /// <param name="typeValue"></param>
        /// <param name="id"></param>
        /// <param name="keyword"></param>
        /// <returns></returns>
        public async Task<IEnumerable<UserInfoResult>> GetAllGroupOrGroupChatUserInfosResult(UserInfoByGroupoRoGroupChatResult request)
        {
            //群聊
            if (request.TypeValue == UserlinkConst.MyGroupChat.GetHashCode())
            {
                var groupIds = await groupChatUserRepository.GetAllAsync(Q.Where(nameof(Entity.GroupChatUser.UserId), request.UserId));
                var groupChatUsers = await groupChatUserRepository.GetAllAsync(Q.WhereIn(nameof(Entity.GroupChatUser.GroupChatId), groupIds.Select(n => n.GroupChatId)));
                var result = await _userRepository.GetSearchUserInfoResults(request.Keyword, groupChatUsers.Select(n => n.UserId));
                return result;
            }
            //小组
            if (request.TypeValue == UserlinkConst.MyGroup.GetHashCode())
            {
                var groupIds = await groupUserRepository.GetAllAsync(Q.Where(nameof(Entity.GroupUser.UserId), request.UserId));
                var groupUsers = await groupUserRepository.GetAllAsync(Q.WhereIn(nameof(Entity.GroupUser.GroupId), groupIds.Select(n => n.GroupId)));
                var result = await _userRepository.GetSearchUserInfoResults(request.Keyword, groupUsers.Select(n => n.UserId));
                return result;
            }
            //自建小组
            if (request.TypeValue == UserlinkConst.My.GetHashCode())
            {
                var addressBookGroupIds = await addressBookGroupUserRepository.GetAllAsync(Q.Where(nameof(Entity.AddressBookGroupUser.UserId), request.UserId));
                var addressGroupUsers = await addressBookGroupUserRepository.GetAllAsync(Q.WhereIn(nameof(Entity.AddressBookGroupUser.AddressBookGroupId), addressBookGroupIds.Select(n => n.AddressBookGroupId)));
                var result = await _userRepository.GetSearchUserInfoResults(request.Keyword, addressGroupUsers.Select(n => n.UserId));
                return result;
            }
            return null;
        }
        /// <summary>
        /// 添加用户
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<int> InsertUserAsync(UserInfoRequest request)
        {
            var user = new Entity.User()
            {
                Phone = request.Phone,
                Name = request.Name,
                Nick = request.Nick,
                IsNotice = request.IsNotice == 1,
                RoleId = request.RoleId,
                Gender = request.Gender,
                Email = request.Email,
                Signature = request.Signature,
                Description = request.Description,
                Position = request.Position
            };
            if (user == null) throw new Exception("用户不能为空");
            //if (string.IsNullOrEmpty(user.Name)) throw new Exception("用户不能为空");

            if (!string.IsNullOrEmpty(user.Phone) &&
                await _userRepository.ExistsAsync(Q.Where(nameof(User.Phone), user.Phone).Where(nameof(User.IsDelete), false)))
            {
                throw new Exception("用户手机号已存在，请更换手机号");
            }
            if (request.DepartmentId.Count() == 0)
                throw new Exception("请选择部门");

            //头像处理
            user.AvatarUrl = StringUtils.RemoveDomain(user.AvatarUrl);
            user.IsUpload = false;
            user.Id = await _userRepository.InsertAsync(user);
            //插入部门
            await departmentUserRepository.AddDepartmentUserAsync(request.DepartmentId, user.Id);
            user = await _userRepository.GetAsync(user.Id);
            //创建二维码
            var qrCodeData = new { key = QRCodeTypeConst.UserInfo, value = user.Guid };
            var resultPath =
                FileHelper.SaveQRCodeFile(StringUtils.GetWebRootPath(_webHostEnvironment.WebRootPath),
                    JsonConvert.SerializeObject(qrCodeData));
            user.QRCoder = resultPath.RelativePath;
            await _userRepository.UpdateAsync(user);
            return user.Id;
        }

        /// <summary>
        /// 更新excel用户数据
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> UpdateUserExcelAsync(List<User> request)
        {
            try
            {
                var departmentReuslt = new Request.Department.DepartmentUserInRequest()
                {
                    UserIds = new List<int>(),
                    DepartmentId = 0
                };
                foreach (var item in request)
                {
                    var user = await _userRepository.GetAsync(Q.Where(nameof(User.Phone), item.Phone));
                    if (user != null)
                    {
                        continue;
                    }
                    var userId = await _userRepository.InsertAsync(item);
                    user = await _userRepository.GetAsync(userId);
                    var resultPath =
                        FileHelper.SaveQRCodeFile(StringUtils.GetWebRootPath(_webHostEnvironment.WebRootPath), item.Guid);
                    user.QRCoder = resultPath.RelativePath;
                    await _userRepository.UpdateAsync(user);
                    await _userRepository.CreateMiUserAsync(item);
                    departmentReuslt.UserIds.Add(userId);
                    departmentReuslt.DepartmentId = item.DepartmentId;
                }
                //插入部门
                await departmentUserRepository.AddDepartmentUserAsync(departmentReuslt);
            }
            catch (Exception e)
            {
                throw new BusinessException(e.Message);
            }

            return true;
        }
    }
}