tede/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.Department;

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;
        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)
        {

            _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;
        }

        /// <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 GetPageListAsync(request.Page, request.PerPage, request.DepartmentId, request.RoleId,
                request.Keyword);
            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);
            //工作我的审批未操作数量
            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 = userInfoResults.Count(),
                        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 groupUserRepository.GetUserIntoGroupUserCountAsync(userId)
                        },
                        new UserLinkModelAttributeResult{
                        Id=0,
                        Name=UserlinkConst.MyGroupChat.GetDescriptionOriginal(),
                        TypeId= UserlinkConst.System.GetHashCode(),
                        TypeValue=UserlinkConst.MyGroupChat.GetHashCode(),
                        UserCount=await groupChatUserRepository.GetUserIntoGroupChatUserCountAsync(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>
        /// 根据部门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;
        }
        /// <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.TypeId == 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;
        }
    }
}