scada/BLL/Manager/UserManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using BLL.Dto;
using BLL.Dto.UserDto;
using DAL;
using Helper;
using HZY.Framework.DependencyInjection;
using Mapster;
using Model;
using SqlSugar;

namespace BLL
{
    public class UserManager : IScopedSelfDependency
    {
        private readonly UserService _userService;

        public UserManager(UserService userService)
        {
            _userService = userService;
        }

        public async Task<BaseResult<UserEntity>> LoginAsync(UserLoginDto request)
        {
            if (request == null || string.IsNullOrEmpty(request.UserName) || string.IsNullOrEmpty(request.UserPassword))
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = "用户名或密码不能为空"
                };
            }

            var entity = request.Adapt<UserEntity>();
            var result = await _userService.LoginAsync(entity);

            if (result.Result == SystemEnums.Result.Fail)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = result.Msg
                };
            }
            return result;
        }

        public async Task<BaseResult<UserEntity>> IsUserExistAsync(UserExistDto request)
        {
            var entity = request.Adapt<UserEntity>();
            var result = await _userService.ExistAsync(u => u.UserName == entity.UserName);

            if (!result)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = $"{entity.UserName}不存在"
                };
            }
            return new BaseResult<UserEntity>
            {
                Result = SystemEnums.Result.Success,
                Msg = $"{entity.UserName}已存在"
            };
        }

        public async Task<BaseResult<UserEntity>> AddUserAsync(UserAddDto request)
        {
            if (request == null || string.IsNullOrEmpty(request.UserName) || string.IsNullOrEmpty(request.UserPassword))
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = "用户名或密码不能为空"
                };
            }

            var isExist = await IsUserExistAsync(new UserExistDto { UserName = request.UserName });
            if (isExist.Result==SystemEnums.Result.Success)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = $"{request.UserName}已存在"
                };
            }

            var entity = request.Adapt<UserEntity>();
            var result = await _userService.InsertAsync(entity);
            if (result <= 0)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = $"添加{entity.UserName}失败"
                };
            }
            return new BaseResult<UserEntity>
            {
                Result = SystemEnums.Result.Success,
                Msg = $"添加{entity.UserName}成功",
                Data = new List<UserEntity> { entity }
            };
        }

        public async Task<BaseResult<UserEntity>> UpdateUserAsync(UserUpdateDto request)
        {
            var isExist = await _userService.ExistAsync(u => u.UserName == request.UserName&&u.Id!=request.Id);
            if (isExist)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = $"{request.UserName}已存在"
                };
            }
            
            if (request == null || string.IsNullOrEmpty(request .UserName) || string.IsNullOrEmpty(request.UserPassword))
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = "用户名或密码不能为空"
                };
            }
            var entity = request.Adapt<UserEntity>();
            var result = await _userService.UpdateAsync(entity);
            if (!result)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = $"更新{entity.UserName}失败"
                };
            }
            return new BaseResult<UserEntity>
            {
                Result = SystemEnums.Result.Success,
                Msg = $"更新{entity.UserName}成功",
                Data = new List<UserEntity> { entity }
            };
        }

        public async Task<BaseResult<UserEntity>> DeleteUserAsync(UserDeleteDto request)
        {
            if (request == null )
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = "用户不能为空"
                };
            }
            var entity = request.Adapt<UserEntity>();
            var result = await _userService.DeleteAsync(entity);
            if (!result)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = $"删除{entity.UserName}失败"
                };
            }
            return new BaseResult<UserEntity>
            {
                Result = SystemEnums.Result.Success,
                Msg = $"删除{entity.UserName}成功",
                Data = new List<UserEntity> { entity }
            };
        }

        public async Task<BaseResult<UserEntity>> GetUserListAsync()
        {
            var result = new BaseResult<UserEntity>();
            var users = await _userService.GetListAsync(u => true);
            if (users == null || !users.Any())
            {
                result.Result = SystemEnums.Result.Fail;
                result.Msg = "没有用户信息";
            }
            else
            {
                result.Result = SystemEnums.Result.Success;
                result.Data = users;
            }
            return result;
        }

        public async Task<BaseResult<UserEntity>> GetUserAuthAsync(QueryUserAuthDto request)
        {
            var isExist = await IsUserExistAsync(new UserExistDto { UserName = request.UserName });
            if(isExist.Result == SystemEnums.Result.Fail)
            {
                return new BaseResult<UserEntity>
                {
                    Result = SystemEnums.Result.Fail,
                    Msg = "用户不存在"
                };
            }
            var result = await _userService.GetByOneAsync(u => u.UserName == request.UserName);

            return new BaseResult<UserEntity>
            {
                Result = SystemEnums.Result.Success,
                Msg = "用户存在",
                Data = new List<UserEntity> { result }
            };
        }
    }
}