WeiCloud.Fusion/WeiCloud.Fusion/UC_PlatformServices/UCPlatform.DomainService/RdsUserInfoManagerService.cs

using Common.Shared.Application.BaseModels;
using Common.Shared.Application.SafetyFirePro.RequestDto;
using Common.Shared.Application.SafetyFirePro.ResponseDto;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using UCPlatform.Entities.Model;
using UCPlatform.Store;
using WeiCloud.Core.Extension;
using WeiCloud.Utils.Common;

namespace UCPlatform.DomainService
{
    public class RdsUserInfoManagerService : IRdsUserInfoManagerService
    {
        private readonly ILogger<RdsUserInfoManagerService> _logger;
        private readonly FusionDbContext _fusionDb;

        public RdsUserInfoManagerService(ILogger<RdsUserInfoManagerService> logger, FusionDbContext fusionDb)
        {
            _logger = logger;
            _fusionDb = fusionDb;
        }

        #region 新增/编辑RDS用户信息

        public async Task<ApiResult<bool>> AddorEditRdsUserAsync(AddorEditRdsUserReqDto reqDto)
        {
            try
            {
                // 参数验证
                if (reqDto == null)
                {
                    _logger.LogWarning("AddorEditRdsUserAsync: 请求参数为空");
                    return ApiResult<bool>.IsBadReq("请求参数不能为空");
                }

                // 验证必填字段
                if (string.IsNullOrWhiteSpace(reqDto.RdsUserId))
                {
                    return ApiResult<bool>.IsBadReq("融合通信调度用户ID不能为空");
                }

                if (string.IsNullOrWhiteSpace(reqDto.RdsUserPhorex))
                {
                    return ApiResult<bool>.IsBadReq("手机号不能为空");
                }

                if (string.IsNullOrWhiteSpace(reqDto.RdsUserName))
                {
                    return ApiResult<bool>.IsBadReq("用户名不能为空");
                }

                if (string.IsNullOrWhiteSpace(reqDto.RdsUserAccount))
                {
                    return ApiResult<bool>.IsBadReq("账号不能为空");
                }

                // 根据Id判断是新增还是编辑
                if (reqDto.Id.HasValue && reqDto.Id.Value > 0)
                {
                    // 编辑操作
                    return await EditRdsUserAsync(reqDto);
                }
                else
                {
                    // 新增操作
                    return await AddRdsUserAsync(reqDto);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "AddorEditRdsUserAsync: 处理RDS用户信息时发生异常，请求参数: {@ReqDto}", reqDto);
                return ApiResult<bool>.IsFail("处理RDS用户信息时发生异常");
            }
        }

        private async Task<ApiResult<bool>> AddRdsUserAsync(AddorEditRdsUserReqDto reqDto)
        {
            try
            {
                // 检查唯一约束
                var existingUser = await _fusionDb.RdsSafetyUsers
                    .FirstOrDefaultAsync(u => u.RdsUserId == reqDto.RdsUserId ||
                                             u.RdsUserPhorex == reqDto.RdsUserPhorex ||
                                             u.SafetyUserId == reqDto.SafetyUserId);

                if (existingUser != null)
                {
                    if (existingUser.RdsUserId == reqDto.RdsUserId)
                    {
                        return ApiResult<bool>.IsBadReq("融合通信调度用户ID已存在");
                    }
                    if (existingUser.RdsUserPhorex == reqDto.RdsUserPhorex)
                    {
                        return ApiResult<bool>.IsBadReq("手机号已存在");
                    }
                    if (existingUser.SafetyUserId == reqDto.SafetyUserId)
                    {
                        return ApiResult<bool>.IsBadReq("安消用户ID已存在");
                    }
                }

                // 创建新实体
                var newUser = new RdsSafetyUser
                {
                    SafetyUserId = reqDto.SafetyUserId,
                    RdsUserId = reqDto.RdsUserId,
                    RdsUserType = reqDto.RdsUserType,
                    RdsUserPhorex = reqDto.RdsUserPhorex,
                    RdsUserName = reqDto.RdsUserName,
                    RdsUserAccount = reqDto.RdsUserAccount,
                    Id = UidGenerator.Uid()
                };

                await _fusionDb.RdsSafetyUsers.AddAsync(newUser);
                await _fusionDb.SaveChangesAsync();

                _logger.LogInformation("AddRdsUserAsync: 成功新增RDS用户，用户ID: {UserId}", newUser.Id);
                return ApiResult<bool>.IsSuccess(true);
            }
            catch (DbUpdateException dbEx)
            {
                _logger.LogError(dbEx, "AddRdsUserAsync: 数据库更新异常，请求参数: {@ReqDto}", reqDto);
                return ApiResult<bool>.IsFail("新增RDS用户时操作失败");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "AddRdsUserAsync: 新增RDS用户时发生异常，请求参数: {@ReqDto}", reqDto);
                return ApiResult<bool>.IsFail("新增RDS用户时发生异常");
            }
        }

        private async Task<ApiResult<bool>> EditRdsUserAsync(AddorEditRdsUserReqDto reqDto)
        {
            try
            {
                // 查找现有用户
                var existingUser = await _fusionDb.RdsSafetyUsers
                    .FirstOrDefaultAsync(u => u.Id == reqDto.Id!.Value);

                if (existingUser == null)
                {
                    _logger.LogWarning("EditRdsUserAsync: 未找到要编辑的RDS用户，ID: {UserId}", reqDto.Id!.Value);
                    return ApiResult<bool>.IsBadReq("未找到要编辑的RDS用户");
                }

                // 检查唯一约束（排除当前用户）
                var duplicateUser = await _fusionDb.RdsSafetyUsers
                    .FirstOrDefaultAsync(u => u.Id != reqDto.Id!.Value &&
                                             (u.RdsUserId == reqDto.RdsUserId ||
                                              u.RdsUserPhorex == reqDto.RdsUserPhorex ||
                                              u.SafetyUserId == reqDto.SafetyUserId));

                if (duplicateUser != null)
                {
                    if (duplicateUser.RdsUserId == reqDto.RdsUserId)
                    {
                        return ApiResult<bool>.IsBadReq("融合通信调度用户已存在");
                    }
                    if (duplicateUser.RdsUserPhorex == reqDto.RdsUserPhorex)
                    {
                        return ApiResult<bool>.IsBadReq("手机号已存在");
                    }
                    if (duplicateUser.SafetyUserId == reqDto.SafetyUserId)
                    {
                        return ApiResult<bool>.IsBadReq("安消用户已存在");
                    }
                }

                // 更新用户信息
                existingUser.SafetyUserId = reqDto.SafetyUserId;
                existingUser.RdsUserId = reqDto.RdsUserId;
                existingUser.RdsUserType = reqDto.RdsUserType;
                existingUser.RdsUserPhorex = reqDto.RdsUserPhorex;
                existingUser.RdsUserName = reqDto.RdsUserName;
                existingUser.RdsUserAccount = reqDto.RdsUserAccount;

                _fusionDb.RdsSafetyUsers.Update(existingUser);
                await _fusionDb.SaveChangesAsync();

                _logger.LogInformation("EditRdsUserAsync: 成功编辑RDS用户，用户ID: {UserId}", reqDto.Id!.Value);
                return ApiResult<bool>.IsSuccess(true);
            }
            catch (DbUpdateException dbEx)
            {
                _logger.LogError(dbEx, "EditRdsUserAsync: 数据库更新异常，请求参数: {@ReqDto}", reqDto);
                return ApiResult<bool>.IsFail("编辑RDS用户时数据库操作失败");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "EditRdsUserAsync: 编辑RDS用户时发生异常，请求参数: {@ReqDto}", reqDto);
                return ApiResult<bool>.IsFail("编辑RDS用户时发生异常");
            }
        }

        #endregion 新增/编辑RDS用户信息

        public async Task<ApiResult<bool>> DeleteRdsUserAsync(RdsUserReqDto dto)
        {
            ApiResult<bool> result = new ApiResult<bool>();
            try
            {
                if (dto == null)
                {
                    return ApiResult<bool>.IsBadReq("请求参数不能为空");
                }

                var userInfo = await _fusionDb.RdsSafetyUsers
          .AsNoTracking()
          .WhereIf(dto.RdsUserId != null, u => u.RdsUserId == dto.RdsUserId)
          .WhereIf(dto.SafetyUserId != null, u => u.SafetyUserId == dto.SafetyUserId)
          .FirstOrDefaultAsync();
                if (userInfo == null)
                {
                    return ApiResult<bool>.IsNoFound("未找到对应的RDS用户信息");
                }

                _fusionDb.RdsSafetyUsers.Remove(userInfo);
                await _fusionDb.SaveChangesAsync();
                return ApiResult<bool>.IsSuccess(true, "删除RDS用户信息成功");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "DeleteRdsUserAsync: 删除RDS用户信息时发生异常，请求参数: {@Dto}", dto);
                return ApiResult<bool>.IsFail("删除RDS用户信息时发生异常");
            }
        }

        public async Task<ApiResult<List<RdsUserInfoResDto>>> GetRdsUserInfo(RdsUserReqDto dto)
        {
            try
            {
                if (dto == null)
                {
                    return ApiResult<List<RdsUserInfoResDto>>.IsBadReq("请求参数不能为空");
                }

                var query = _fusionDb.RdsSafetyUsers.AsNoTracking();

                // 根据SafetyUserId条件查询
                if (dto.SafetyUserId.HasValue && dto.SafetyUserId.Value > 0)
                {
                    query = query.Where(u => u.SafetyUserId == dto.SafetyUserId.Value);
                }

                // 根据RdsUserId条件查询
                if (!string.IsNullOrWhiteSpace(dto.RdsUserId))
                {
                    query = query.Where(u => u.RdsUserId == dto.RdsUserId);
                }

                var users = await query.ToListAsync();

                if (users == null || users.Count == 0)
                {
                    _logger.LogInformation("GetRdsUserInfo: 未找到匹配条件的RDS用户信息，查询条件: {@Dto}", dto);
                    return ApiResult<List<RdsUserInfoResDto>>.IsSuccess(new List<RdsUserInfoResDto>());
                }

                // 映射到响应DTO
                var result = users.Select(u => new RdsUserInfoResDto
                {
                    Id = u.Id,
                    SafetyUserId = u.SafetyUserId,
                    RdsUserId = u.RdsUserId,
                    RdsUserType = u.RdsUserType,
                    RdsUserPhorex = u.RdsUserPhorex,
                    RdsUserName = u.RdsUserName,
                    RdsUserAccount = u.RdsUserAccount
                }).ToList();

                _logger.LogInformation("GetRdsUserInfo: 查询成功，返回{Count}条记录", result.Count);
                return ApiResult<List<RdsUserInfoResDto>>.IsSuccess(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "GetRdsUserInfo: 查询RDS用户信息时发生异常，查询条件: {@Dto}", dto);
                return ApiResult<List<RdsUserInfoResDto>>.IsFail("查询RDS用户信息时发生异常");
            }
        }
    }
}