WGShare.API/WGShare.API/Controllers/Frontend/UserController.cs

using Mapster;
using Masuit.Tools;
using Masuit.Tools.Security;
using Microsoft.AspNetCore.Mvc;
using Microsoft.VisualBasic;
using MiniExcelLibs;
using SqlSugar;
using System;
using System.Text.RegularExpressions;
using WGShare.API.Controllers.Basic;
using WGShare.API.Helpers;
using WGShare.Domain.Constant;
using WGShare.Domain.DTOs.User;
using WGShare.Domain.Entities;
using WGShare.Domain.FriendlyException;
using WGShare.Domain.GeneralModel;
using Yitter.IdGenerator;

namespace WGShare.API.Controllers.Frontend
{
    [ApiExplorerSettings(GroupName = "frontend")]
    [Route("user")]
    public class UserController : BasicController
    {
        private readonly ISqlSugarClient _sqlSugar;
        private readonly OssHelper _ossHelper;

        public UserController(ISqlSugarClient sqlSugar,
                              OssHelper ossHelper)
        {
            this._sqlSugar = sqlSugar;
            this._ossHelper = ossHelper;
        }


        /// <summary>
        /// 获取用户列表
        /// </summary>
        /// <param name="searchKeywod">用户名 或 账号</param>
        /// <param name="pagedBaseDto">翻页信息</param>
        /// <returns></returns>
        [HttpGet("list")]
        public async Task<PagedResult<UserOutputDTO>> GetUserList([FromQuery] string? searchKeywod, [FromQuery] bool? isOnline, [FromQuery] PagedBaseDto pagedBaseDto)
        {
            RefAsync<int> total = 0;

            // 获取在线用户id
            var onlineUid = RedisHelper.Instance.HKeys(RedisKeyConstant.SessionManage.GetOnlineUserKey(TenantId));

            var list = await _sqlSugar.Queryable<User>()
                .InnerJoin<Role>((u, r) => u.RoleId == r.Id)
                .Where((u, r) => u.IsDelete == false && u.TenantId == TenantId && u.IsAnonymous == false)
                .WhereIF(!string.IsNullOrWhiteSpace(searchKeywod), (u, r) => u.UserName.Contains(searchKeywod) || u.Account.Contains(searchKeywod))
                .WhereIF(isOnline.HasValue && isOnline.Value == true, (u, r) => onlineUid.Contains(u.Id))
                .WhereIF(isOnline.HasValue && isOnline.Value == false, (u, r) => !onlineUid.Contains(u.Id))
                .OrderBy(u => u.Id, OrderByType.Desc)
                .Select((u, r) => new UserOutputDTO
                {
                    Id = u.Id,
                    UserName = u.UserName,
                    Account = u.Account,
                    RoleId = r.Id,
                    RoleName = r.RoleName,
                    ScreenShareId = u.ScreenShareId
                })
               .ToPageListAsync(pagedBaseDto.PageIndex, pagedBaseDto.PageSize, total);


            list.ForEach(x => x.IsOnline = onlineUid.Contains(x.Id));

            return PagedResult<UserOutputDTO>.Create(list, total.Value);
        }


        /// <summary>
        /// 新增用户
        /// </summary>
        /// <param name="inputDTO"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<bool> AddUser([FromBody] UserInputDTO inputDTO)
        {
            var user = inputDTO.Adapt<User>();
            //user.Id = YitIdHelper.NextId().ToString();
            user.TenantId = TenantId;
            user.ScreenShareId = UserShareIdHelper.GenerateUnique8DigitNumber();

            if (await _sqlSugar.Queryable<User>().AnyAsync(x => x.Account == user.Account))
            {
                throw Oops.Oh("账号已存在！");
            }

            return await _sqlSugar.Insertable(user).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 修改用户信息
        /// </summary>
        /// <param name="inputDTO"></param>
        /// <returns></returns>
        [HttpPut]
        public async Task<bool> Modify([FromBody] UserInputDTO inputDTO)
        {
            var entity = inputDTO.Adapt<User>();

            if (await _sqlSugar.Queryable<User>().AnyAsync(x => x.Account == entity.Account && x.Id != inputDTO.Id))
            {
                throw Oops.Oh("账号已存在！");
            }

            return await _sqlSugar.Updateable(entity)
                .UpdateColumns(x => new { x.Account, x.UserName, x.RoleId }).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 更改密码
        /// </summary>
        /// <param name="inputDTO"></param>
        /// <returns></returns>
        [HttpPut("pwd")]
        public async Task<bool> ModifyPassword([FromBody] UserChangePwdDTO inputDTO)
        {
            var entity = inputDTO.Adapt<User>();

            return await _sqlSugar.Updateable(entity)
                .UpdateColumns(x => new { x.Pwd }).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 删除用户
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        [HttpDelete]
        public async Task<bool> Delete([FromBody] params string[] ids)
        {
            return await _sqlSugar.Updateable<User>()
                .SetColumns(x => x.IsDelete == true)
                .Where(x => ids.Contains(x.Id)).ExecuteCommandHasChangeAsync();
        }


        /// <summary>
        /// Excel 导入用户
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        [HttpPost("import")]
        public async Task<IActionResult> Import([FromForm] IFormFile file)
        {

            using var stream = file.OpenReadStream();
            var rows = stream.Query<UserExcelInputDto>().ToList();
            rows.RemoveAll(x => x == null || string.IsNullOrWhiteSpace(x.Account));
            if (rows.IsNullOrEmpty())
            {
                throw Oops.Oh("无有效数据，请检查文件数据！");
            }

            var accounts = rows.Select(x => x.Account.Trim());
            var repeatAccount = accounts.GroupBy(x => x).Where(x => x.Count() > 1).Select(x => x.Key).ToHashSet();

            // 去除重复账号
            var distinctAccount = accounts.Except(repeatAccount);

            // 数据库重复账号检查
            var existsAccount = await _sqlSugar.Queryable<User>()
                .Where(x => distinctAccount.Contains(x.Account))
                .Select(x => x.Account)
                .ToListAsync();
            if (!existsAccount.IsNullOrEmpty())
            {
                repeatAccount.UnionWith(existsAccount);
            }

            if (!repeatAccount.IsNullOrEmpty())
            {
                // 重复账号，返回结果Excel   
                foreach (var row in rows)
                {
                    if (repeatAccount.Contains(row.Account))
                    {
                        row.ImportResult = "账号重复";
                    }
                    else
                    {
                        row.ImportResult = "可导入";
                    }
                }
                //FileStreamResult fileStream = null;
                using var memoryStream = new MemoryStream();

                memoryStream.SaveAs(rows);
                memoryStream.Seek(0, SeekOrigin.Begin);

                var fileName = $@"excel/{Regex.Replace(file.FileName, @"\.(xlsx|xls)$", "", RegexOptions.IgnoreCase)}_导入失败_{DateTime.Now.ToString("HHmmss")}.xlsx";
                _ossHelper.UploadWithExpireTime(fileName, memoryStream, 10);
                var fileUrl = _ossHelper.GetAccessFileUrl(fileName, 1);

                return Ok((isSuccess: false, url: fileUrl, msg: "导入失败，请检查原因后重新导入！"));
            }

            var users = rows.Adapt<List<User>>();
            users.ForEach(x =>
            {
                x.Pwd = x.Pwd.MDString();
                x.ScreenShareId = UserShareIdHelper.GenerateUnique8DigitNumber();
                x.TenantId = TenantId;

                var roleId = "2";
                if (x.RoleId == "管理员")
                    roleId = "1";
                else if (x.RoleId == "房间管理员")
                    roleId = "3";
                x.RoleId = roleId;

            });

            await _sqlSugar.Insertable(users).ExecuteCommandAsync();

            return Ok((isSuccess: true, url: "", msg: "导入成功"));
        }

    }
}