WGShare.API/WGShare.API/Controllers/Backend/UserController.cs

using Mapster;
using Masuit.Tools;
using Masuit.Tools.Security;
using Microsoft.AspNetCore.Components.Forms;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.FileSystemGlobbing.Internal;
using MiniExcelLibs;
using Newtonsoft.Json.Linq;
using SqlSugar;
using System;
using System.Text.RegularExpressions;
using WGShare.API.Controllers.Basic;
using WGShare.API.Helpers;
using WGShare.Domain.DTOs.User;
using WGShare.Domain.Entities;
using WGShare.Domain.FriendlyException;
using WGShare.Domain.GeneralModel;
using Yitter.IdGenerator;

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

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


        [HttpGet("{id}")]
        public async Task<User> GetSingle([FromRoute] string id)
        {
            return await _sqlSugar.Queryable<User>().FirstAsync(x => x.Id == id);
        }

        [HttpGet("list")]
        public async Task<PagedResult<User>> GetPageList([FromQuery] UserSearchDTO searchDTO)
        {
            RefAsync<int> total = 0;

            var list = await _sqlSugar.Queryable<User>()
                .InnerJoin<Role>((u, r) => u.RoleId == r.Id)
                .InnerJoin<Tenant>((u, r, t) => u.TenantId == t.Id)
                .WhereIF(!string.IsNullOrWhiteSpace(searchDTO.keyword),
                u => u.UserName.Contains(searchDTO.keyword) || u.Account.Contains(searchDTO.keyword) || u.Id.Contains(searchDTO.keyword))
                .WhereIF(!string.IsNullOrWhiteSpace(searchDTO.TenantId), u => u.TenantId == searchDTO.TenantId)
                .WhereIF(!string.IsNullOrWhiteSpace(searchDTO.RoleId), u => u.RoleId == searchDTO.RoleId)
                .OrderBy(u => u.Id, OrderByType.Desc)
                //.Where(u => u.IsDelete == false)
                .Select((u, r, t) => new User
                {
                    Id = u.Id.SelectAll(),
                    RoleName = r.RoleName,
                    TenantName = t.TenantName
                })
                .ToPageListAsync(searchDTO.PageIndex, searchDTO.PageSize, total);

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

        [HttpPost]
        public async Task<bool> Add([FromBody] UserInputDTO userInput)
        {
            var entity = userInput.Adapt<User>();
            entity.ScreenShareId = UserShareIdHelper.GenerateUnique8DigitNumber();

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

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

        [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.UserName, x.Account, x.RoleId, x.TenantId }).ExecuteCommandAsync() > 0;
        }

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

        [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>
        /// 权限修改
        /// </summary>
        /// <returns></returns>
        [HttpPut("auth-prem")]
        [Obsolete]
        public async Task EditPremissions([FromBody] List<UserPremInputDTO> inputDTOs)
        {

            var entity = inputDTOs.Adapt<UserPrem>();


            await _sqlSugar.Deleteable<UserPrem>()
                .Where(x => inputDTOs.Select(x => x.UserId).Contains(x.UserId)).ExecuteCommandAsync();


            await _sqlSugar.Insertable(entity).ExecuteCommandAsync();
        }

        /// <summary>
        /// Excel 导入用户
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        [HttpPost("import")]
        public async Task<IActionResult> Import([FromForm] IFormFile file, [FromForm] string tenantId)
        {
            using var stream = file.OpenReadStream();
            var rows = stream.Query<UserExcelInputDto>().ToList();
            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.UtcNow.Ticks}.xlsx";
                _ossHelper.UploadWithExpireTime(fileName, memoryStream, 10);
                var fileUrl = _ossHelper.GetAccessFileUrl(fileName, 1);

                return Ok((isSuccess: false, url: fileUrl));
            }

            var users = rows.Adapt<List<User>>();
            users.ForEach(x =>
            {
                x.Pwd = x.Pwd.MDString();
                x.ScreenShareId = UserShareIdHelper.GenerateUnique8DigitNumber();
                x.TenantId = tenantId;
                x.RoleId = x.RoleId == "管理员" ? "1" : "2";
            });

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

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