579 lines
22 KiB
C#
579 lines
22 KiB
C#
using System.Text.Json;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using MilitaryTrainingManagement.Data;
|
||
using MilitaryTrainingManagement.Models.Entities;
|
||
using MilitaryTrainingManagement.Models.Enums;
|
||
using MilitaryTrainingManagement.Services.Interfaces;
|
||
|
||
namespace MilitaryTrainingManagement.Services.Implementations;
|
||
|
||
/// <summary>
|
||
/// 人员管理服务实现
|
||
/// </summary>
|
||
public class PersonnelService : IPersonnelService
|
||
{
|
||
private readonly ApplicationDbContext _context;
|
||
private readonly IOrganizationService _organizationService;
|
||
private readonly IFileUploadService _fileUploadService;
|
||
private readonly IWorkflowService _workflowService;
|
||
private readonly ILogger<PersonnelService> _logger;
|
||
|
||
public PersonnelService(
|
||
ApplicationDbContext context,
|
||
IOrganizationService organizationService,
|
||
IFileUploadService fileUploadService,
|
||
IWorkflowService workflowService,
|
||
ILogger<PersonnelService> logger)
|
||
{
|
||
_context = context;
|
||
_organizationService = organizationService;
|
||
_fileUploadService = fileUploadService;
|
||
_workflowService = workflowService;
|
||
_logger = logger;
|
||
}
|
||
|
||
public async Task<Personnel?> GetByIdAsync(int id)
|
||
{
|
||
return await _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.Include(p => p.ApprovedByUnit)
|
||
.FirstOrDefaultAsync(p => p.Id == id);
|
||
}
|
||
|
||
public async Task<IEnumerable<Personnel>> GetByUnitAsync(int unitId, bool includeSubordinates = false)
|
||
{
|
||
if (includeSubordinates)
|
||
{
|
||
var subordinates = await _organizationService.GetSubordinatesAsync(unitId);
|
||
var unitIds = subordinates.Select(s => s.Id).ToList();
|
||
unitIds.Add(unitId);
|
||
|
||
return await _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.Include(p => p.ApprovedByUnit)
|
||
.Where(p => unitIds.Contains(p.SubmittedByUnitId))
|
||
.OrderByDescending(p => p.SubmittedAt)
|
||
.ToListAsync();
|
||
}
|
||
|
||
return await _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.Include(p => p.ApprovedByUnit)
|
||
.Where(p => p.SubmittedByUnitId == unitId)
|
||
.OrderByDescending(p => p.SubmittedAt)
|
||
.ToListAsync();
|
||
}
|
||
|
||
public async Task<Personnel> CreateAsync(Personnel personnel)
|
||
{
|
||
personnel.Status = PersonnelStatus.Pending;
|
||
personnel.SubmittedAt = DateTime.UtcNow;
|
||
|
||
_context.Personnel.Add(personnel);
|
||
await _context.SaveChangesAsync();
|
||
return personnel;
|
||
}
|
||
|
||
public async Task<Personnel> UpdateAsync(Personnel personnel)
|
||
{
|
||
_context.Personnel.Update(personnel);
|
||
await _context.SaveChangesAsync();
|
||
return personnel;
|
||
}
|
||
|
||
public async Task<Personnel> ApproveAsync(int personnelId, int approvedByUnitId, PersonnelLevel level)
|
||
{
|
||
var personnel = await _context.Personnel.FindAsync(personnelId);
|
||
if (personnel == null)
|
||
throw new ArgumentException("人员记录不存在");
|
||
|
||
var approvedByUnit = await _context.OrganizationalUnits.FindAsync(approvedByUnitId);
|
||
if (approvedByUnit == null)
|
||
throw new ArgumentException("审批单位不存在");
|
||
|
||
// 验证审批单位层级必须高于或等于人员等级（数值越小层级越高）
|
||
var unitLevelValue = (int)approvedByUnit.Level;
|
||
var personnelLevelValue = (int)level;
|
||
if (unitLevelValue > personnelLevelValue)
|
||
throw new ArgumentException("审批单位层级不足以审批该等级人才");
|
||
|
||
var previousStatus = personnel.Status;
|
||
var previousLevel = personnel.ApprovedLevel;
|
||
|
||
personnel.Status = PersonnelStatus.Approved;
|
||
personnel.ApprovedByUnitId = approvedByUnitId;
|
||
personnel.ApprovedLevel = level;
|
||
personnel.ApprovedAt = DateTime.UtcNow;
|
||
|
||
await _context.SaveChangesAsync();
|
||
|
||
// 记录审批历史
|
||
var userId = await GetUserIdByUnitAsync(approvedByUnitId);
|
||
await RecordApprovalHistoryAsync(personnelId, PersonnelApprovalAction.Approved,
|
||
previousStatus, PersonnelStatus.Approved, previousLevel, level,
|
||
userId, approvedByUnitId, "审批通过");
|
||
|
||
_logger.LogInformation("人员 {PersonnelId} 已被单位 {UnitId} 审批通过，等级：{Level}",
|
||
personnelId, approvedByUnitId, level);
|
||
|
||
return personnel;
|
||
}
|
||
|
||
public async Task<Personnel> RejectAsync(int personnelId, int reviewedByUserId)
|
||
{
|
||
var personnel = await _context.Personnel.FindAsync(personnelId);
|
||
if (personnel == null)
|
||
throw new ArgumentException("人员记录不存在");
|
||
|
||
var previousStatus = personnel.Status;
|
||
|
||
personnel.Status = PersonnelStatus.Rejected;
|
||
await _context.SaveChangesAsync();
|
||
|
||
// 记录审批历史
|
||
await RecordApprovalHistoryAsync(personnelId, PersonnelApprovalAction.Rejected,
|
||
previousStatus, PersonnelStatus.Rejected, null, null,
|
||
reviewedByUserId, null, "审批拒绝");
|
||
|
||
_logger.LogInformation("人员 {PersonnelId} 已被用户 {UserId} 拒绝", personnelId, reviewedByUserId);
|
||
|
||
return personnel;
|
||
}
|
||
|
||
public async Task DeleteAsync(int id)
|
||
{
|
||
var personnel = await _context.Personnel.FindAsync(id);
|
||
if (personnel == null)
|
||
throw new ArgumentException("人员记录不存在");
|
||
|
||
// 删除关联的文件
|
||
if (!string.IsNullOrEmpty(personnel.PhotoPath))
|
||
{
|
||
await _fileUploadService.DeleteFileAsync(personnel.PhotoPath);
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(personnel.SupportingDocuments))
|
||
{
|
||
await _fileUploadService.DeleteFileAsync(personnel.SupportingDocuments);
|
||
}
|
||
|
||
_context.Personnel.Remove(personnel);
|
||
await _context.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("人员记录 {PersonnelId} 已删除", id);
|
||
}
|
||
|
||
public async Task<Personnel> SubmitPersonnelAsync(Personnel personnel, IFormFile? photo, IFormFile? supportingDocument)
|
||
{
|
||
// 验证人员数据完整性
|
||
var validation = await ValidatePersonnelDataAsync(personnel);
|
||
if (!validation.IsValid)
|
||
{
|
||
throw new ArgumentException($"人员数据验证失败：{string.Join(", ", validation.Errors)}");
|
||
}
|
||
|
||
// 处理照片上传
|
||
if (photo != null)
|
||
{
|
||
try
|
||
{
|
||
personnel.PhotoPath = await _fileUploadService.UploadPhotoAsync(photo);
|
||
_logger.LogInformation("人员照片上传成功：{PhotoPath}", personnel.PhotoPath);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "人员照片上传失败");
|
||
throw new InvalidOperationException($"照片上传失败：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
// 处理支持文档上传
|
||
if (supportingDocument != null)
|
||
{
|
||
try
|
||
{
|
||
personnel.SupportingDocuments = await _fileUploadService.UploadDocumentAsync(supportingDocument);
|
||
_logger.LogInformation("支持文档上传成功：{DocumentPath}", personnel.SupportingDocuments);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "支持文档上传失败");
|
||
throw new InvalidOperationException($"支持文档上传失败：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
// 设置提交状态和时间
|
||
personnel.Status = PersonnelStatus.Pending;
|
||
personnel.SubmittedAt = DateTime.UtcNow;
|
||
|
||
_context.Personnel.Add(personnel);
|
||
await _context.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("人员数据提交成功，ID：{PersonnelId}，提交单位：{UnitId}",
|
||
personnel.Id, personnel.SubmittedByUnitId);
|
||
|
||
return personnel;
|
||
}
|
||
|
||
public async Task<PersonnelValidationResult> ValidatePersonnelDataAsync(Personnel personnel)
|
||
{
|
||
var errors = new List<string>();
|
||
|
||
// 验证必填字段
|
||
if (string.IsNullOrWhiteSpace(personnel.Name))
|
||
errors.Add("姓名不能为空");
|
||
|
||
if (string.IsNullOrWhiteSpace(personnel.Position))
|
||
errors.Add("职位不能为空");
|
||
|
||
if (string.IsNullOrWhiteSpace(personnel.Rank))
|
||
errors.Add("军衔不能为空");
|
||
|
||
if (string.IsNullOrWhiteSpace(personnel.Gender))
|
||
errors.Add("性别不能为空");
|
||
|
||
if (string.IsNullOrWhiteSpace(personnel.IdNumber))
|
||
errors.Add("身份证号不能为空");
|
||
|
||
if (personnel.Age <= 0 || personnel.Age > 100)
|
||
errors.Add("年龄必须在1-100之间");
|
||
|
||
if (personnel.SubmittedByUnitId <= 0)
|
||
errors.Add("提交单位不能为空");
|
||
|
||
// 验证身份证号格式（简单验证）
|
||
if (!string.IsNullOrWhiteSpace(personnel.IdNumber))
|
||
{
|
||
if (personnel.IdNumber.Length != 18)
|
||
errors.Add("身份证号必须为18位");
|
||
}
|
||
|
||
// 验证身份证号唯一性
|
||
if (!string.IsNullOrWhiteSpace(personnel.IdNumber))
|
||
{
|
||
var existingPersonnel = await _context.Personnel
|
||
.FirstOrDefaultAsync(p => p.IdNumber == personnel.IdNumber && p.Id != personnel.Id);
|
||
if (existingPersonnel != null)
|
||
errors.Add("身份证号已存在");
|
||
}
|
||
|
||
// 验证提交单位是否存在
|
||
if (personnel.SubmittedByUnitId > 0)
|
||
{
|
||
var unit = await _context.OrganizationalUnits.FindAsync(personnel.SubmittedByUnitId);
|
||
if (unit == null)
|
||
errors.Add("提交单位不存在");
|
||
}
|
||
|
||
return errors.Any() ? PersonnelValidationResult.Failure(errors.ToArray()) : PersonnelValidationResult.Success();
|
||
}
|
||
|
||
public async Task<OrganizationalUnit> GetApprovalTargetUnitAsync(int submittingUnitId)
|
||
{
|
||
var submittingUnit = await _context.OrganizationalUnits
|
||
.Include(u => u.Parent)
|
||
.FirstOrDefaultAsync(u => u.Id == submittingUnitId);
|
||
|
||
if (submittingUnit == null)
|
||
throw new ArgumentException("提交单位不存在");
|
||
|
||
// 审批路由逻辑：提交给上级单位审批
|
||
if (submittingUnit.Parent != null)
|
||
{
|
||
return submittingUnit.Parent;
|
||
}
|
||
|
||
// 如果是师团级别，则自己审批
|
||
if (submittingUnit.Level == OrganizationalLevel.Division)
|
||
{
|
||
return submittingUnit;
|
||
}
|
||
|
||
throw new InvalidOperationException("无法确定审批目标单位");
|
||
}
|
||
|
||
public async Task<bool> CanModifyPersonnelAsync(int personnelId)
|
||
{
|
||
var personnel = await _context.Personnel.FindAsync(personnelId);
|
||
if (personnel == null)
|
||
return false;
|
||
|
||
// 只有待审批状态的人员可以直接修改
|
||
if (personnel.Status == PersonnelStatus.Pending)
|
||
return true;
|
||
|
||
// 已审批的人员需要通过工作流修改
|
||
return false;
|
||
}
|
||
|
||
public async Task<ApprovalRequest> RequestPersonnelModificationAsync(int personnelId, int requestedByUserId, string reason, Personnel modifiedPersonnel)
|
||
{
|
||
var originalPersonnel = await _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.FirstOrDefaultAsync(p => p.Id == personnelId);
|
||
|
||
if (originalPersonnel == null)
|
||
throw new ArgumentException("人员记录不存在");
|
||
|
||
if (originalPersonnel.Status != PersonnelStatus.Approved)
|
||
throw new InvalidOperationException("只能修改已审批的人员记录");
|
||
|
||
var user = await _context.UserAccounts
|
||
.Include(u => u.OrganizationalUnit)
|
||
.FirstOrDefaultAsync(u => u.Id == requestedByUserId);
|
||
|
||
if (user == null)
|
||
throw new ArgumentException("请求用户不存在");
|
||
|
||
// 序列化原始数据和修改数据
|
||
var originalData = JsonSerializer.Serialize(new
|
||
{
|
||
originalPersonnel.Name,
|
||
originalPersonnel.Position,
|
||
originalPersonnel.Rank,
|
||
originalPersonnel.Gender,
|
||
originalPersonnel.IdNumber,
|
||
originalPersonnel.ProfessionalTitle,
|
||
originalPersonnel.EducationLevel,
|
||
originalPersonnel.Age,
|
||
originalPersonnel.Height,
|
||
originalPersonnel.ContactInfo,
|
||
originalPersonnel.Hometown,
|
||
originalPersonnel.TrainingParticipation,
|
||
originalPersonnel.Achievements
|
||
});
|
||
|
||
var requestedChanges = JsonSerializer.Serialize(new
|
||
{
|
||
modifiedPersonnel.Name,
|
||
modifiedPersonnel.Position,
|
||
modifiedPersonnel.Rank,
|
||
modifiedPersonnel.Gender,
|
||
modifiedPersonnel.IdNumber,
|
||
modifiedPersonnel.ProfessionalTitle,
|
||
modifiedPersonnel.EducationLevel,
|
||
modifiedPersonnel.Age,
|
||
modifiedPersonnel.Height,
|
||
modifiedPersonnel.ContactInfo,
|
||
modifiedPersonnel.Hometown,
|
||
modifiedPersonnel.TrainingParticipation,
|
||
modifiedPersonnel.Achievements
|
||
});
|
||
|
||
var request = await _workflowService.CreateModificationRequestAsync(
|
||
ApprovalRequestType.PersonnelModification,
|
||
personnelId,
|
||
requestedByUserId,
|
||
user.OrganizationalUnitId,
|
||
reason,
|
||
originalData,
|
||
requestedChanges);
|
||
|
||
_logger.LogInformation("人员修改请求已创建，ID：{RequestId}，人员ID：{PersonnelId}",
|
||
request.Id, personnelId);
|
||
|
||
return request;
|
||
}
|
||
|
||
public async Task<IEnumerable<Personnel>> GetVisiblePersonnelAsync(int unitId, OrganizationalLevel userLevel)
|
||
{
|
||
// 根据组织层级获取可见的人员
|
||
// 用户只能查看当前和下级组织单位的人员
|
||
var subordinates = await _organizationService.GetSubordinatesAsync(unitId);
|
||
var visibleUnitIds = subordinates.Select(s => s.Id).ToList();
|
||
visibleUnitIds.Add(unitId);
|
||
|
||
var query = _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.Include(p => p.ApprovedByUnit)
|
||
.Where(p => visibleUnitIds.Contains(p.SubmittedByUnitId));
|
||
|
||
// 根据人员等级进一步过滤
|
||
// 用户只能查看等级不高于自己组织层级的人员
|
||
var maxPersonnelLevel = (PersonnelLevel)(int)userLevel;
|
||
query = query.Where(p => p.ApprovedLevel == null || p.ApprovedLevel >= maxPersonnelLevel);
|
||
|
||
return await query.OrderByDescending(p => p.SubmittedAt).ToListAsync();
|
||
}
|
||
|
||
public async Task<Personnel> TransferPersonnelAsync(int personnelId, int targetUnitId, int approvedByUnitId)
|
||
{
|
||
var personnel = await _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.FirstOrDefaultAsync(p => p.Id == personnelId);
|
||
|
||
if (personnel == null)
|
||
throw new ArgumentException("人员记录不存在");
|
||
|
||
if (personnel.Status != PersonnelStatus.Approved)
|
||
throw new InvalidOperationException("只能转移已审批的人员");
|
||
|
||
var targetUnit = await _context.OrganizationalUnits.FindAsync(targetUnitId);
|
||
if (targetUnit == null)
|
||
throw new ArgumentException("目标单位不存在");
|
||
|
||
var approvedByUnit = await _context.OrganizationalUnits.FindAsync(approvedByUnitId);
|
||
if (approvedByUnit == null)
|
||
throw new ArgumentException("审批单位不存在");
|
||
|
||
// 验证审批单位有权限进行跨层级转移
|
||
// 审批单位层级必须高于或等于目标单位层级
|
||
if ((int)approvedByUnit.Level > (int)targetUnit.Level)
|
||
throw new UnauthorizedAccessException("审批单位层级不足以进行此转移");
|
||
|
||
// 更新人员所属单位
|
||
personnel.SubmittedByUnitId = targetUnitId;
|
||
|
||
// 根据新的审批单位重新设置人员等级
|
||
var newLevel = (PersonnelLevel)(int)approvedByUnit.Level;
|
||
personnel.ApprovedLevel = newLevel;
|
||
personnel.ApprovedByUnitId = approvedByUnitId;
|
||
personnel.ApprovedAt = DateTime.UtcNow;
|
||
|
||
await _context.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("人员 {PersonnelId} 已从单位 {FromUnitId} 转移到单位 {ToUnitId}，审批单位：{ApprovedByUnitId}",
|
||
personnelId, personnel.SubmittedByUnit.Id, targetUnitId, approvedByUnitId);
|
||
|
||
return personnel;
|
||
}
|
||
|
||
public async Task<IEnumerable<Personnel>> GetPendingApprovalPersonnelAsync(int unitId)
|
||
{
|
||
// 获取需要当前单位审批的人员（来自下级单位的提交）
|
||
var subordinates = await _organizationService.GetSubordinatesAsync(unitId);
|
||
var subordinateIds = subordinates.Select(s => s.Id).ToList();
|
||
|
||
return await _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.Where(p => subordinateIds.Contains(p.SubmittedByUnitId) && p.Status == PersonnelStatus.Pending)
|
||
.OrderBy(p => p.SubmittedAt)
|
||
.ToListAsync();
|
||
}
|
||
|
||
public async Task<IEnumerable<Personnel>> BatchApprovePersonnelAsync(int[] personnelIds, int approvedByUnitId, PersonnelLevel level)
|
||
{
|
||
var approvedPersonnel = new List<Personnel>();
|
||
|
||
foreach (var personnelId in personnelIds)
|
||
{
|
||
try
|
||
{
|
||
var personnel = await ApproveAsync(personnelId, approvedByUnitId, level);
|
||
approvedPersonnel.Add(personnel);
|
||
|
||
// 记录审批历史
|
||
await RecordApprovalHistoryAsync(personnelId, PersonnelApprovalAction.Approved,
|
||
PersonnelStatus.Pending, PersonnelStatus.Approved, null, level,
|
||
await GetUserIdByUnitAsync(approvedByUnitId), approvedByUnitId, "批量审批通过");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "批量审批人员 {PersonnelId} 失败", personnelId);
|
||
// 继续处理其他人员，不中断整个批量操作
|
||
}
|
||
}
|
||
|
||
return approvedPersonnel;
|
||
}
|
||
|
||
public async Task<IEnumerable<Personnel>> BatchRejectPersonnelAsync(int[] personnelIds, int reviewedByUserId, string reason)
|
||
{
|
||
var rejectedPersonnel = new List<Personnel>();
|
||
|
||
foreach (var personnelId in personnelIds)
|
||
{
|
||
try
|
||
{
|
||
var personnel = await RejectAsync(personnelId, reviewedByUserId);
|
||
rejectedPersonnel.Add(personnel);
|
||
|
||
// 记录审批历史
|
||
await RecordApprovalHistoryAsync(personnelId, PersonnelApprovalAction.Rejected,
|
||
PersonnelStatus.Pending, PersonnelStatus.Rejected, null, null,
|
||
reviewedByUserId, null, reason);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_logger.LogError(ex, "批量拒绝人员 {PersonnelId} 失败", personnelId);
|
||
// 继续处理其他人员，不中断整个批量操作
|
||
}
|
||
}
|
||
|
||
return rejectedPersonnel;
|
||
}
|
||
|
||
public async Task<IEnumerable<PersonnelApprovalHistory>> GetPersonnelApprovalHistoryAsync(int personnelId)
|
||
{
|
||
return await _context.PersonnelApprovalHistories
|
||
.Include(h => h.ReviewedByUser)
|
||
.Include(h => h.ReviewedByUnit)
|
||
.Where(h => h.PersonnelId == personnelId)
|
||
.OrderByDescending(h => h.ReviewedAt)
|
||
.ToListAsync();
|
||
}
|
||
|
||
public async Task<bool> CanApprovePersonnelAsync(int userId, int personnelId)
|
||
{
|
||
var user = await _context.UserAccounts
|
||
.Include(u => u.OrganizationalUnit)
|
||
.FirstOrDefaultAsync(u => u.Id == userId);
|
||
|
||
if (user == null)
|
||
return false;
|
||
|
||
var personnel = await _context.Personnel
|
||
.Include(p => p.SubmittedByUnit)
|
||
.FirstOrDefaultAsync(p => p.Id == personnelId);
|
||
|
||
if (personnel == null || personnel.Status != PersonnelStatus.Pending)
|
||
return false;
|
||
|
||
// 同一单位可以审批自己提交的人员
|
||
if (user.OrganizationalUnitId == personnel.SubmittedByUnitId)
|
||
return true;
|
||
|
||
// 检查用户的组织单位是否是提交单位的上级
|
||
var isParent = await _organizationService.IsParentUnitAsync(user.OrganizationalUnitId, personnel.SubmittedByUnitId);
|
||
|
||
return isParent;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 记录人员审批历史
|
||
/// </summary>
|
||
private async Task RecordApprovalHistoryAsync(int personnelId, PersonnelApprovalAction action,
|
||
PersonnelStatus? previousStatus, PersonnelStatus newStatus,
|
||
PersonnelLevel? previousLevel, PersonnelLevel? newLevel,
|
||
int reviewedByUserId, int? reviewedByUnitId, string? comments)
|
||
{
|
||
var history = new PersonnelApprovalHistory
|
||
{
|
||
PersonnelId = personnelId,
|
||
Action = action,
|
||
PreviousStatus = previousStatus,
|
||
NewStatus = newStatus,
|
||
PreviousLevel = previousLevel,
|
||
NewLevel = newLevel,
|
||
ReviewedByUserId = reviewedByUserId,
|
||
ReviewedByUnitId = reviewedByUnitId,
|
||
Comments = comments,
|
||
ReviewedAt = DateTime.UtcNow
|
||
};
|
||
|
||
_context.PersonnelApprovalHistories.Add(history);
|
||
await _context.SaveChangesAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据单位ID获取用户ID（用于审批历史记录）
|
||
/// </summary>
|
||
private async Task<int> GetUserIdByUnitAsync(int unitId)
|
||
{
|
||
var user = await _context.UserAccounts
|
||
.FirstOrDefaultAsync(u => u.OrganizationalUnitId == unitId);
|
||
|
||
return user?.Id ?? 0; // 如果找不到用户，返回0作为系统操作
|
||
}
|
||
}
|