netcore/src/Modularity/Extend/NCC.Extend/UserService.cs

using NCC.Common.Core.Manager;
using NCC.Common.Enum;
using NCC.Common.Extension;
using NCC.Common.Filter;
using NCC.Dependency;
using NCC.DynamicApiController;
using NCC.FriendlyException;
using NCC.Extend.Interfaces.User;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using NCC.System.Entitys.Permission;
using NCC.Extend.Entitys.Dto.User;
using NCC.Common.Helper;
using NCC.JsonSerialization;
using NCC.Common.Model.NPOI;
using NCC.Common.Configuration;
using NCC.DataEncryption;
using NCC.ClayObject;
using NCC.Extend.Entitys.lq_jinsanjiao_user;
namespace NCC.Extend.User
{
    /// <summary>
    /// 用户服务
    /// </summary>
    [ApiDescriptionSettings(Tag = "绿纤用户服务", Name = "User", Order = 200)]
    [Route("api/Extend/[controller]")]
    public class UserService : IUserService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<UserEntity> _userRepository;
        private readonly SqlSugarScope _db;
        private readonly IUserManager _userManager;
        /// <summary>
        /// 初始化一个<see cref="UserService"/>类型的新实例
        /// </summary>
        public UserService(
            ISqlSugarRepository<UserEntity> userRepository,
            IUserManager userManager)
        {
            _userRepository = userRepository;
            _db = _userRepository.Context;
            _userManager = userManager;
        }
        #region 获取用户列表
        /// <summary>
        /// 获取用户列表
        /// </summary>
        [HttpGet("")]
        public async Task<dynamic> GetUserList([FromQuery] UserListQueryInput input)
        {
            var sidx = input.sidx == null ? "id" : input.sidx;
            
            DateTime? monthStart = null;
            DateTime? monthLast = null;
            if (!string.IsNullOrWhiteSpace(input.onJobMonth))
            {
                var parts = input.onJobMonth.Split('-');
                if (parts.Length == 2 && int.TryParse(parts[0], out var year) && int.TryParse(parts[1], out var month))
                {
                    if (month >= 1 && month <= 12)
                    {
                        monthStart = new DateTime(year, month, 1);
                        monthLast = new DateTime(year, month, DateTime.DaysInMonth(year, month), 23, 59, 59);
                    }
                }
            }
            
            if (string.IsNullOrWhiteSpace(input.mdid) && !string.IsNullOrWhiteSpace(input.gw))
            {
                var currentUser = await _userManager.GetUserInfo();
                if (currentUser != null && !string.IsNullOrWhiteSpace(currentUser.mdid))
                {
                    input.mdid = currentUser.mdid;
                }
            }
            
            var data = await _db.Queryable<UserEntity, OrganizeEntity, PositionEntity, RoleEntity>((u, o, p, r) => new JoinQueryInfos(
                JoinType.Left, o.Id == SqlFunc.ToString(u.OrganizeId),
                JoinType.Left, p.Id == SqlFunc.ToString(u.PositionId),
                JoinType.Left, r.Id == SqlFunc.ToString(u.RoleId)))
                .WhereIF(!string.IsNullOrEmpty(input.id), u => u.Id.Contains(input.id))
                .WhereIF(!string.IsNullOrEmpty(input.account), u => u.Account.Contains(input.account))
                .WhereIF(!string.IsNullOrEmpty(input.realName), u => u.RealName.Contains(input.realName))
                .WhereIF(!string.IsNullOrEmpty(input.mobilePhone), u => u.MobilePhone.Contains(input.mobilePhone))
                .WhereIF(!string.IsNullOrEmpty(input.mdid), u => u.Mdid == input.mdid)
                .WhereIF(!string.IsNullOrEmpty(input.zw), u => u.Zw.Contains(input.zw))
                .WhereIF(!string.IsNullOrEmpty(input.gw), u => u.Gw.Contains(input.gw))
                .WhereIF(!string.IsNullOrEmpty(input.gwfl), u => u.Gwfl.Contains(input.gwfl))
                .WhereIF(!string.IsNullOrEmpty(input.fyft), u => u.Fyft.Contains(input.fyft))
                .WhereIF(!string.IsNullOrEmpty(input.organizeId), u => u.OrganizeId == input.organizeId)
                .WhereIF(!string.IsNullOrEmpty(input.positionId), u => u.PositionId == input.positionId)
                .WhereIF(!string.IsNullOrEmpty(input.roleId), u => u.RoleId == input.roleId)
                .WhereIF(input.enabledMark.HasValue, u => u.EnabledMark == input.enabledMark)
                .Where(u => u.DeleteMark == null) // 排除已删除的用户
                .WhereIF(monthStart.HasValue && monthLast.HasValue, u => 
                    u.EntryDate != null && u.EntryDate <= monthLast.Value &&
                    (u.LeaveDate == null || u.LeaveDate >= monthStart.Value))
                .Select((u, o, p, r) => new UserListOutput
                {
                    id = u.Id,
                    account = u.Account,
                    realName = u.RealName,
                    nickName = u.NickName,
                    headIcon = u.HeadIcon,
                    gender = u.Gender,
                    birthday = u.Birthday,
                    mobilePhone = u.MobilePhone,
                    telePhone = u.TelePhone,
                    email = u.Email,
                    urgentContacts = u.UrgentContacts,
                    urgentTelePhone = u.UrgentTelePhone,
                    postalAddress = u.PostalAddress,
                    signature = u.Signature,
                    firstLogTime = u.FirstLogTime,
                    prevLogTime = u.PrevLogTime,
                    isAdministrator = u.IsAdministrator,
                    description = u.Description,
                    sortCode = u.SortCode,
                    managerId = u.ManagerId,
                    organizeId = u.OrganizeId,
                    organizeName = o.FullName,
                    positionId = u.PositionId,
                    positionName = p.FullName,
                    roleId = u.RoleId,
                    roleName = r.FullName,
                    portalId = u.PortalId,
                    extensionStr = u.ExtensionStr,
                    openId = u.OpenId,
                    mdid = u.Mdid,
                    mdmc = "", // 门店名称需要关联门店表获取
                    zw = u.Zw,
                    fyft = u.Fyft,
                    gwfl = u.Gwfl,
                    gw = u.Gw,
                    enabledMark = u.EnabledMark,
                    creatorTime = u.CreatorTime,
                    creatorUserId = u.CreatorUserId,
                    entryDate = u.EntryDate,
                    leaveDate = u.LeaveDate
                })
                .MergeTable()
                .OrderBy(sidx + " " + input.sort)
                .ToPagedListAsync(input.currentPage, input.pageSize);
            
            return PageResult<UserListOutput>.SqlSugarPageResult(data);
        }
        #endregion
        #region 获取用户详细信息
        /// <summary>
        /// 获取用户详细信息
        /// </summary>
        [HttpGet("{id}")]
        public async Task<dynamic> GetUserInfo(string id)
        {
            var entity = await _db.Queryable<UserEntity, OrganizeEntity, PositionEntity, RoleEntity>((u, o, p, r) => new JoinQueryInfos(
                JoinType.Left, o.Id == SqlFunc.ToString(u.OrganizeId),
                JoinType.Left, p.Id == SqlFunc.ToString(u.PositionId),
                JoinType.Left, r.Id == SqlFunc.ToString(u.RoleId)))
                .Where(u => u.Id == id && u.DeleteMark == null)
                .Select((u, o, p, r) => new UserListOutput
                {
                    id = u.Id,
                    account = u.Account,
                    realName = u.RealName,
                    nickName = u.NickName,
                    headIcon = u.HeadIcon,
                    gender = u.Gender,
                    birthday = u.Birthday,
                    mobilePhone = u.MobilePhone,
                    telePhone = u.TelePhone,
                    postalAddress = u.PostalAddress,
                    signature = u.Signature,
                    firstLogTime = u.FirstLogTime,
                    prevLogTime = u.PrevLogTime,
                    description = u.Description,
                    managerId = u.ManagerId,
                    organizeId = u.OrganizeId,
                    organizeName = o.FullName,
                    positionId = u.PositionId,
                    positionName = p.FullName,
                    roleId = u.RoleId,
                    roleName = r.FullName,
                    mdid = u.Mdid,
                    mdmc = "", // 门店名称需要关联门店表获取
                    zw = u.Zw,
                    fyft = u.Fyft,
                    gwfl = u.Gwfl,
                    gw = u.Gw,
                    enabledMark = u.EnabledMark
                })
                .MergeTable()
                .FirstAsync();
            
            return entity;
        }
        #endregion
        #region 获取用户下拉选择数据
        /// <summary>
        /// 获取用户下拉选择数据
        /// </summary>
        [HttpGet("Selector")]
        public async Task<dynamic> GetUserSelector([FromQuery] string mdid = null, [FromQuery] string zw = null, [FromQuery] string gw = null)
        {
            var data = await _db.Queryable<UserEntity>()
                .WhereIF(!string.IsNullOrEmpty(mdid), u => u.Mdid == mdid)
                .WhereIF(!string.IsNullOrEmpty(zw), u => u.Zw != null && u.Zw.Contains(zw))
                .WhereIF(!string.IsNullOrEmpty(gw), u => u.Gw == gw)
                .Where(u => u.EnabledMark == 1 && u.DeleteMark == null)
                .Select(u => new
                {
                    id = u.Id,
                    account = u.Account,
                    realName = u.RealName,
                    mobilePhone = u.MobilePhone,
                    mdid = u.Mdid,
                    zw = u.Zw,
                    gw = u.Gw
                })
                .OrderBy(u => u.realName)
                .ToListAsync();
            return data;
        }
        #endregion
  
      #region 获取总经理、经理下拉选择数据
        /// <summary>
        /// 获取用户下拉选择数据
        /// </summary>
        [HttpGet("ManagerSelector")]
        public async Task<dynamic> GetManagerSelector()
        {
            var data = await _db.Queryable<UserEntity>()
                .Where(u => u.Gw == "总经理" || u.Gw == "经理")
                .Where(u => u.EnabledMark == 1 && u.DeleteMark == null)
                .Select(u => new
                {
                    id = u.Id,
                    account = u.Account,
                    realName = u.RealName,
                    mobilePhone = u.MobilePhone,
                    mdid = u.Mdid,
                    zw = u.Zw,
                    gw = u.Gw
                })
                .OrderBy(u => u.realName)
                .ToListAsync();
            return data;
        }
        #endregion
   
    }
}