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.EnumConst;
using GxPress.Request.App.Flow;
using GxPress.Repository.Interface.WaitHandle;
using GxPress.Request.AddressBookGroup;
using GxPress.Repository.Interface.DepartmentUser;
using GxPress.Repository.Interface.Friends;

namespace GxPress.Service.Implement
{
    public class UserService : IUserService
    {
        private readonly IUserRepository _userRepository;
        private readonly IDepartmentRepository _departmentRepository;
        private readonly IAddressBookGroupRepository _addressBookGroupRepository;
        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;
        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)
        {

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

        /// <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 _flowTodoRepository.GetCountAsync(userId, nameof(TodoTypeConst.ApproverCheck), false,
                    request);
            // 工作我发起的已批复未读数量
            var flowState = new List<string> { FlowState.Checked.GetValue(), FlowState.Denied.GetValue() };
            result.FlowSendUReadCount = await _flowRepository.CountAsync(Q.Where(nameof(Entity.WorkFlow.Flow.UserId), userId).WhereIn(nameof(Entity.WorkFlow.Flow.State), flowState).Where(nameof(Entity.WorkFlow.Flow.IsRead), false).Where(nameof(Entity.WorkFlow.Flow.ProcessId), ">", 0));
            // 工作抄送我的未读数量
            result.FlowCcUReadCount = await _flowTodoRepository.FlowCcUReadCountAsync(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>();
            if (user.DepartmentId > 0)
            {
                var departments = await _departmentRepository.GetAllAsync(Q.Where(nameof(Entity.Department.ParentId), 0));
                var userLinkModelAttributeResult = new List<UserLinkModelAttributeResult>();
                foreach (var item in departments)
                    userLinkModelAttributeResult.Add(new UserLinkModelAttributeResult { Id = item.Id, Name = item.Name });
                userLinkResult.Add(new UserLinkModelResult
                {
                    TypeId = 1,
                    Name = "单位通讯录",
                    Items = userLinkModelAttributeResult
                });
            }
            //系统通讯录
            userLinkResult.Add(
              new UserLinkModelResult
              {
                  TypeId = 2,
                  Name = "系统通讯录",
                  Items = new List<UserLinkModelAttributeResult>{
                        new UserLinkModelAttributeResult{Id=0,Name="我的小组",TypeValue=1},
                        new UserLinkModelAttributeResult{Id=0,Name="我的群聊",TypeValue=2},
                        new UserLinkModelAttributeResult{Id=0,Name="我的课程",TypeValue=3}
                  }
              }
          );
            //自建通讯录
            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 });
            userLinkResult.Add(
                new UserLinkModelResult
                {
                    TypeId = 3,
                    Name = "自建通讯录",
                    Items = systemLinkModelAttributeResults
                }
            );
            //获取用户好友
            var userIds = await friendsRepository.GetFriendsIdsAsync(userId, 0);
            var result = new UserLinkResult()
            {
                Items = userLinkResult,
                FriendUsers = await _userRepository.GetUserInfoResultsAsync(userIds)
            };
            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="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.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);
            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;
        }
    }
}