1470 lines
48 KiB
C#
1470 lines
48 KiB
C#
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.Extensions.Logging;
|
||
using MiAssessment.Admin.Business.Data;
|
||
using MiAssessment.Admin.Business.Entities;
|
||
using MiAssessment.Admin.Business.Models;
|
||
using MiAssessment.Admin.Business.Models.Assessment;
|
||
using MiAssessment.Admin.Business.Models.Common;
|
||
using MiAssessment.Admin.Business.Services.Interfaces;
|
||
|
||
namespace MiAssessment.Admin.Business.Services;
|
||
|
||
/// <summary>
|
||
/// 测评管理服务实现
|
||
/// </summary>
|
||
public class AssessmentService : IAssessmentService
|
||
{
|
||
private readonly AdminBusinessDbContext _dbContext;
|
||
private readonly ILogger<AssessmentService> _logger;
|
||
|
||
/// <summary>
|
||
/// 测评类型状态名称映射
|
||
/// </summary>
|
||
private static readonly Dictionary<int, string> TypeStatusNames = new()
|
||
{
|
||
{ 0, "已下线" },
|
||
{ 1, "已上线" },
|
||
{ 2, "即将上线" }
|
||
};
|
||
|
||
/// <summary>
|
||
/// 构造函数
|
||
/// </summary>
|
||
/// <param name="dbContext">数据库上下文</param>
|
||
/// <param name="logger">日志记录器</param>
|
||
public AssessmentService(
|
||
AdminBusinessDbContext dbContext,
|
||
ILogger<AssessmentService> logger)
|
||
{
|
||
_dbContext = dbContext;
|
||
_logger = logger;
|
||
}
|
||
|
||
#region 测评类型操作
|
||
|
||
/// <inheritdoc />
|
||
public async Task<PagedResult<AssessmentTypeDto>> GetTypeListAsync(AssessmentTypeQueryRequest request)
|
||
{
|
||
// 构建查询，过滤软删除记录
|
||
var query = _dbContext.AssessmentTypes
|
||
.AsNoTracking()
|
||
.Where(t => !t.IsDeleted);
|
||
|
||
// 名称筛选
|
||
if (!string.IsNullOrWhiteSpace(request.Name))
|
||
{
|
||
query = query.Where(t => t.Name.Contains(request.Name));
|
||
}
|
||
|
||
// 编码筛选
|
||
if (!string.IsNullOrWhiteSpace(request.Code))
|
||
{
|
||
query = query.Where(t => t.Code.Contains(request.Code));
|
||
}
|
||
|
||
// 状态筛选
|
||
if (request.Status.HasValue)
|
||
{
|
||
query = query.Where(t => t.Status == request.Status.Value);
|
||
}
|
||
|
||
// 获取总数
|
||
var total = await query.CountAsync();
|
||
|
||
// 分页查询，按 Sort 降序排列
|
||
var items = await query
|
||
.OrderByDescending(t => t.Sort)
|
||
.ThenByDescending(t => t.CreateTime)
|
||
.Skip(request.Skip)
|
||
.Take(request.PageSize)
|
||
.Select(t => new AssessmentTypeDto
|
||
{
|
||
Id = t.Id,
|
||
Name = t.Name,
|
||
Code = t.Code,
|
||
ImageUrl = t.ImageUrl,
|
||
DetailImageUrl = t.DetailImageUrl,
|
||
IntroContent = t.IntroContent,
|
||
Price = t.Price,
|
||
QuestionCount = t.QuestionCount,
|
||
Sort = t.Sort,
|
||
Status = t.Status,
|
||
StatusName = GetTypeStatusName(t.Status),
|
||
CreateTime = t.CreateTime
|
||
})
|
||
.ToListAsync();
|
||
|
||
return PagedResult<AssessmentTypeDto>.Create(items, total, request.Page, request.PageSize);
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<AssessmentTypeDto> GetTypeByIdAsync(long id)
|
||
{
|
||
var assessmentType = await _dbContext.AssessmentTypes
|
||
.AsNoTracking()
|
||
.Where(t => t.Id == id && !t.IsDeleted)
|
||
.Select(t => new AssessmentTypeDto
|
||
{
|
||
Id = t.Id,
|
||
Name = t.Name,
|
||
Code = t.Code,
|
||
ImageUrl = t.ImageUrl,
|
||
DetailImageUrl = t.DetailImageUrl,
|
||
IntroContent = t.IntroContent,
|
||
Price = t.Price,
|
||
QuestionCount = t.QuestionCount,
|
||
Sort = t.Sort,
|
||
Status = t.Status,
|
||
StatusName = GetTypeStatusName(t.Status),
|
||
CreateTime = t.CreateTime
|
||
})
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (assessmentType == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
return assessmentType;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<long> CreateTypeAsync(CreateAssessmentTypeRequest request)
|
||
{
|
||
// 验证名称必填
|
||
if (string.IsNullOrWhiteSpace(request.Name))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评名称不能为空");
|
||
}
|
||
|
||
// 验证编码必填
|
||
if (string.IsNullOrWhiteSpace(request.Code))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评编码不能为空");
|
||
}
|
||
|
||
// 验证价格必须为正数
|
||
if (request.Price <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "价格必须大于0");
|
||
}
|
||
|
||
// 验证编码唯一性
|
||
if (await IsCodeExistsAsync(request.Code))
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeCodeExists, "测评类型编码已存在");
|
||
}
|
||
|
||
// 创建实体
|
||
var assessmentType = new AssessmentType
|
||
{
|
||
Name = request.Name,
|
||
Code = request.Code,
|
||
ImageUrl = request.ImageUrl,
|
||
DetailImageUrl = request.DetailImageUrl,
|
||
IntroContent = request.IntroContent,
|
||
Price = request.Price,
|
||
QuestionCount = request.QuestionCount,
|
||
Sort = request.Sort,
|
||
Status = request.Status,
|
||
CreateTime = DateTime.Now,
|
||
UpdateTime = DateTime.Now,
|
||
IsDeleted = false
|
||
};
|
||
|
||
_dbContext.AssessmentTypes.Add(assessmentType);
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("创建测评类型成功，ID: {TypeId}, 名称: {Name}, 编码: {Code}",
|
||
assessmentType.Id, assessmentType.Name, assessmentType.Code);
|
||
|
||
return assessmentType.Id;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> UpdateTypeAsync(UpdateAssessmentTypeRequest request)
|
||
{
|
||
// 查找测评类型
|
||
var assessmentType = await _dbContext.AssessmentTypes
|
||
.Where(t => t.Id == request.Id && !t.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (assessmentType == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 验证名称必填
|
||
if (string.IsNullOrWhiteSpace(request.Name))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评名称不能为空");
|
||
}
|
||
|
||
// 验证编码必填
|
||
if (string.IsNullOrWhiteSpace(request.Code))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评编码不能为空");
|
||
}
|
||
|
||
// 验证价格必须为正数
|
||
if (request.Price <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "价格必须大于0");
|
||
}
|
||
|
||
// 验证编码唯一性（排除自身）
|
||
if (await IsCodeExistsAsync(request.Code, request.Id))
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeCodeExists, "测评类型编码已存在");
|
||
}
|
||
|
||
// 更新字段
|
||
assessmentType.Name = request.Name;
|
||
assessmentType.Code = request.Code;
|
||
assessmentType.ImageUrl = request.ImageUrl;
|
||
assessmentType.DetailImageUrl = request.DetailImageUrl;
|
||
assessmentType.IntroContent = request.IntroContent;
|
||
assessmentType.Price = request.Price;
|
||
assessmentType.QuestionCount = request.QuestionCount;
|
||
assessmentType.Sort = request.Sort;
|
||
assessmentType.Status = request.Status;
|
||
assessmentType.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("更新测评类型成功，ID: {TypeId}", assessmentType.Id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> DeleteTypeAsync(long id)
|
||
{
|
||
// 查找测评类型
|
||
var assessmentType = await _dbContext.AssessmentTypes
|
||
.Where(t => t.Id == id && !t.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (assessmentType == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 软删除
|
||
assessmentType.IsDeleted = true;
|
||
assessmentType.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("删除测评类型成功，ID: {TypeId}", id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> UpdateTypeStatusAsync(long id, int status)
|
||
{
|
||
// 查找测评类型
|
||
var assessmentType = await _dbContext.AssessmentTypes
|
||
.Where(t => t.Id == id && !t.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (assessmentType == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 更新状态
|
||
assessmentType.Status = status;
|
||
assessmentType.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("更新测评类型状态成功，ID: {TypeId}, 状态: {Status}", id, status);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> IsCodeExistsAsync(string code, long? excludeId = null)
|
||
{
|
||
var query = _dbContext.AssessmentTypes
|
||
.Where(t => t.Code == code && !t.IsDeleted);
|
||
|
||
if (excludeId.HasValue)
|
||
{
|
||
query = query.Where(t => t.Id != excludeId.Value);
|
||
}
|
||
|
||
return await query.AnyAsync();
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 题目操作
|
||
|
||
/// <summary>
|
||
/// 题目状态名称映射
|
||
/// </summary>
|
||
private static readonly Dictionary<int, string> QuestionStatusNames = new()
|
||
{
|
||
{ 0, "禁用" },
|
||
{ 1, "启用" }
|
||
};
|
||
|
||
/// <inheritdoc />
|
||
public async Task<PagedResult<QuestionDto>> GetQuestionListAsync(QuestionQueryRequest request)
|
||
{
|
||
// 构建查询，过滤软删除记录
|
||
var query = _dbContext.Questions
|
||
.AsNoTracking()
|
||
.Where(q => !q.IsDeleted);
|
||
|
||
// 测评类型筛选
|
||
if (request.AssessmentTypeId.HasValue)
|
||
{
|
||
query = query.Where(q => q.AssessmentTypeId == request.AssessmentTypeId.Value);
|
||
}
|
||
|
||
// 题号筛选
|
||
if (request.QuestionNo.HasValue)
|
||
{
|
||
query = query.Where(q => q.QuestionNo == request.QuestionNo.Value);
|
||
}
|
||
|
||
// 内容筛选
|
||
if (!string.IsNullOrWhiteSpace(request.Content))
|
||
{
|
||
query = query.Where(q => q.Content.Contains(request.Content));
|
||
}
|
||
|
||
// 状态筛选
|
||
if (request.Status.HasValue)
|
||
{
|
||
query = query.Where(q => q.Status == request.Status.Value);
|
||
}
|
||
|
||
// 获取总数
|
||
var total = await query.CountAsync();
|
||
|
||
// 分页查询，按 QuestionNo 升序排列
|
||
var questions = await query
|
||
.OrderBy(q => q.QuestionNo)
|
||
.ThenByDescending(q => q.CreateTime)
|
||
.Skip(request.Skip)
|
||
.Take(request.PageSize)
|
||
.Select(q => new QuestionDto
|
||
{
|
||
Id = q.Id,
|
||
AssessmentTypeId = q.AssessmentTypeId,
|
||
AssessmentTypeName = q.AssessmentType != null ? q.AssessmentType.Name : "",
|
||
QuestionNo = q.QuestionNo,
|
||
Content = q.Content,
|
||
Sort = q.Sort,
|
||
Status = q.Status,
|
||
StatusName = GetQuestionStatusName(q.Status),
|
||
CreateTime = q.CreateTime
|
||
})
|
||
.ToListAsync();
|
||
|
||
// 获取这些题目的分类数量
|
||
if (questions.Count > 0)
|
||
{
|
||
var questionIds = questions.Select(q => q.Id).ToList();
|
||
var categoryCounts = await _dbContext.QuestionCategoryMappings
|
||
.Where(m => questionIds.Contains(m.QuestionId))
|
||
.GroupBy(m => m.QuestionId)
|
||
.Select(g => new { QuestionId = g.Key, Count = g.Count() })
|
||
.ToDictionaryAsync(x => x.QuestionId, x => x.Count);
|
||
|
||
foreach (var question in questions)
|
||
{
|
||
question.CategoryCount = categoryCounts.TryGetValue(question.Id, out var count) ? count : 0;
|
||
}
|
||
}
|
||
|
||
return PagedResult<QuestionDto>.Create(questions, total, request.Page, request.PageSize);
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<QuestionDto> GetQuestionByIdAsync(long id)
|
||
{
|
||
var question = await _dbContext.Questions
|
||
.AsNoTracking()
|
||
.Where(q => q.Id == id && !q.IsDeleted)
|
||
.Select(q => new QuestionDto
|
||
{
|
||
Id = q.Id,
|
||
AssessmentTypeId = q.AssessmentTypeId,
|
||
AssessmentTypeName = q.AssessmentType != null ? q.AssessmentType.Name : "",
|
||
QuestionNo = q.QuestionNo,
|
||
Content = q.Content,
|
||
Sort = q.Sort,
|
||
Status = q.Status,
|
||
StatusName = GetQuestionStatusName(q.Status),
|
||
CreateTime = q.CreateTime
|
||
})
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (question == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNotFound, "题目不存在");
|
||
}
|
||
|
||
return question;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<long> CreateQuestionAsync(CreateQuestionRequest request)
|
||
{
|
||
// 验证测评类型ID必填
|
||
if (request.AssessmentTypeId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评类型ID无效");
|
||
}
|
||
|
||
// 验证题号必填且大于0
|
||
if (request.QuestionNo <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "题号必须大于0");
|
||
}
|
||
|
||
// 验证内容必填
|
||
if (string.IsNullOrWhiteSpace(request.Content))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "题目内容不能为空");
|
||
}
|
||
|
||
// 验证测评类型是否存在
|
||
var assessmentTypeExists = await _dbContext.AssessmentTypes
|
||
.AnyAsync(t => t.Id == request.AssessmentTypeId && !t.IsDeleted);
|
||
if (!assessmentTypeExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 验证题号唯一性（同一测评类型内）
|
||
if (await IsQuestionNoExistsAsync(request.AssessmentTypeId, request.QuestionNo))
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNoExists, "该测评类型下题号已存在");
|
||
}
|
||
|
||
// 创建实体
|
||
var question = new Question
|
||
{
|
||
AssessmentTypeId = request.AssessmentTypeId,
|
||
QuestionNo = request.QuestionNo,
|
||
Content = request.Content,
|
||
Sort = request.Sort,
|
||
Status = request.Status,
|
||
CreateTime = DateTime.Now,
|
||
UpdateTime = DateTime.Now,
|
||
IsDeleted = false
|
||
};
|
||
|
||
_dbContext.Questions.Add(question);
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("创建题目成功，ID: {QuestionId}, 测评类型ID: {TypeId}, 题号: {QuestionNo}",
|
||
question.Id, question.AssessmentTypeId, question.QuestionNo);
|
||
|
||
return question.Id;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> UpdateQuestionAsync(UpdateQuestionRequest request)
|
||
{
|
||
// 查找题目
|
||
var question = await _dbContext.Questions
|
||
.Where(q => q.Id == request.Id && !q.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (question == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNotFound, "题目不存在");
|
||
}
|
||
|
||
// 验证测评类型ID必填
|
||
if (request.AssessmentTypeId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评类型ID无效");
|
||
}
|
||
|
||
// 验证题号必填且大于0
|
||
if (request.QuestionNo <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "题号必须大于0");
|
||
}
|
||
|
||
// 验证内容必填
|
||
if (string.IsNullOrWhiteSpace(request.Content))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "题目内容不能为空");
|
||
}
|
||
|
||
// 验证测评类型是否存在
|
||
var assessmentTypeExists = await _dbContext.AssessmentTypes
|
||
.AnyAsync(t => t.Id == request.AssessmentTypeId && !t.IsDeleted);
|
||
if (!assessmentTypeExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 验证题号唯一性（同一测评类型内，排除自身）
|
||
if (await IsQuestionNoExistsAsync(request.AssessmentTypeId, request.QuestionNo, request.Id))
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNoExists, "该测评类型下题号已存在");
|
||
}
|
||
|
||
// 更新字段
|
||
question.AssessmentTypeId = request.AssessmentTypeId;
|
||
question.QuestionNo = request.QuestionNo;
|
||
question.Content = request.Content;
|
||
question.Sort = request.Sort;
|
||
question.Status = request.Status;
|
||
question.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("更新题目成功，ID: {QuestionId}", question.Id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> DeleteQuestionAsync(long id)
|
||
{
|
||
// 查找题目
|
||
var question = await _dbContext.Questions
|
||
.Where(q => q.Id == id && !q.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (question == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNotFound, "题目不存在");
|
||
}
|
||
|
||
// 软删除
|
||
question.IsDeleted = true;
|
||
question.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("删除题目成功，ID: {QuestionId}", id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> UpdateQuestionStatusAsync(long id, int status)
|
||
{
|
||
// 查找题目
|
||
var question = await _dbContext.Questions
|
||
.Where(q => q.Id == id && !q.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (question == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNotFound, "题目不存在");
|
||
}
|
||
|
||
// 更新状态
|
||
question.Status = status;
|
||
question.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("更新题目状态成功，ID: {QuestionId}, 状态: {Status}", id, status);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<BatchImportResult> BatchImportQuestionsAsync(BatchImportQuestionsRequest request)
|
||
{
|
||
var result = new BatchImportResult
|
||
{
|
||
TotalCount = request.Questions.Count,
|
||
SuccessCount = 0,
|
||
FailedCount = 0,
|
||
Errors = new List<BatchImportError>()
|
||
};
|
||
|
||
// 验证测评类型ID
|
||
if (request.AssessmentTypeId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评类型ID无效");
|
||
}
|
||
|
||
// 验证测评类型是否存在
|
||
var assessmentTypeExists = await _dbContext.AssessmentTypes
|
||
.AnyAsync(t => t.Id == request.AssessmentTypeId && !t.IsDeleted);
|
||
if (!assessmentTypeExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 获取该测评类型下已存在的题号
|
||
var existingQuestionNos = await _dbContext.Questions
|
||
.Where(q => q.AssessmentTypeId == request.AssessmentTypeId && !q.IsDeleted)
|
||
.Select(q => q.QuestionNo)
|
||
.ToListAsync();
|
||
|
||
// 检查导入数据中的重复题号
|
||
var importQuestionNos = new HashSet<int>();
|
||
var questionsToAdd = new List<Question>();
|
||
|
||
for (int i = 0; i < request.Questions.Count; i++)
|
||
{
|
||
var item = request.Questions[i];
|
||
var rowIndex = i + 1;
|
||
|
||
// 验证题号
|
||
if (item.QuestionNo <= 0)
|
||
{
|
||
result.Errors.Add(new BatchImportError
|
||
{
|
||
RowIndex = rowIndex,
|
||
QuestionNo = item.QuestionNo,
|
||
ErrorMessage = "题号必须大于0"
|
||
});
|
||
result.FailedCount++;
|
||
continue;
|
||
}
|
||
|
||
// 验证内容
|
||
if (string.IsNullOrWhiteSpace(item.Content))
|
||
{
|
||
result.Errors.Add(new BatchImportError
|
||
{
|
||
RowIndex = rowIndex,
|
||
QuestionNo = item.QuestionNo,
|
||
ErrorMessage = "题目内容不能为空"
|
||
});
|
||
result.FailedCount++;
|
||
continue;
|
||
}
|
||
|
||
// 检查是否与数据库中已存在的题号重复
|
||
if (existingQuestionNos.Contains(item.QuestionNo))
|
||
{
|
||
result.Errors.Add(new BatchImportError
|
||
{
|
||
RowIndex = rowIndex,
|
||
QuestionNo = item.QuestionNo,
|
||
ErrorMessage = "题号已存在"
|
||
});
|
||
result.FailedCount++;
|
||
continue;
|
||
}
|
||
|
||
// 检查是否与本次导入中的其他题号重复
|
||
if (importQuestionNos.Contains(item.QuestionNo))
|
||
{
|
||
result.Errors.Add(new BatchImportError
|
||
{
|
||
RowIndex = rowIndex,
|
||
QuestionNo = item.QuestionNo,
|
||
ErrorMessage = "导入数据中存在重复题号"
|
||
});
|
||
result.FailedCount++;
|
||
continue;
|
||
}
|
||
|
||
importQuestionNos.Add(item.QuestionNo);
|
||
|
||
// 创建题目实体
|
||
var question = new Question
|
||
{
|
||
AssessmentTypeId = request.AssessmentTypeId,
|
||
QuestionNo = item.QuestionNo,
|
||
Content = item.Content,
|
||
Sort = item.Sort,
|
||
Status = item.Status,
|
||
CreateTime = DateTime.Now,
|
||
UpdateTime = DateTime.Now,
|
||
IsDeleted = false
|
||
};
|
||
|
||
questionsToAdd.Add(question);
|
||
result.SuccessCount++;
|
||
}
|
||
|
||
// 批量添加题目
|
||
if (questionsToAdd.Count > 0)
|
||
{
|
||
_dbContext.Questions.AddRange(questionsToAdd);
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("批量导入题目成功，测评类型ID: {TypeId}, 成功: {SuccessCount}, 失败: {FailedCount}",
|
||
request.AssessmentTypeId, result.SuccessCount, result.FailedCount);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> IsQuestionNoExistsAsync(long assessmentTypeId, int questionNo, long? excludeId = null)
|
||
{
|
||
var query = _dbContext.Questions
|
||
.Where(q => q.AssessmentTypeId == assessmentTypeId && q.QuestionNo == questionNo && !q.IsDeleted);
|
||
|
||
if (excludeId.HasValue)
|
||
{
|
||
query = query.Where(q => q.Id != excludeId.Value);
|
||
}
|
||
|
||
return await query.AnyAsync();
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 报告分类操作
|
||
|
||
/// <summary>
|
||
/// 分类类型名称映射
|
||
/// </summary>
|
||
private static readonly Dictionary<int, string> CategoryTypeNames = new()
|
||
{
|
||
{ 1, "八大智能" },
|
||
{ 2, "个人特质" },
|
||
{ 3, "细分能力" },
|
||
{ 4, "先天学习" },
|
||
{ 5, "学习能力" },
|
||
{ 6, "大脑类型" },
|
||
{ 7, "性格类型" },
|
||
{ 8, "未来能力" }
|
||
};
|
||
|
||
/// <summary>
|
||
/// 计分规则名称映射
|
||
/// </summary>
|
||
private static readonly Dictionary<int, string> ScoreRuleNames = new()
|
||
{
|
||
{ 1, "累加(1-10分)" },
|
||
{ 2, "二值(0/1分)" }
|
||
};
|
||
|
||
/// <inheritdoc />
|
||
public async Task<List<CategoryTreeNode>> GetCategoryTreeAsync(long assessmentTypeId)
|
||
{
|
||
// 获取该测评类型下所有未删除的分类
|
||
var categories = await _dbContext.ReportCategories
|
||
.AsNoTracking()
|
||
.Where(c => c.AssessmentTypeId == assessmentTypeId && !c.IsDeleted)
|
||
.OrderBy(c => c.Sort)
|
||
.ThenBy(c => c.CreateTime)
|
||
.Select(c => new CategoryTreeNode
|
||
{
|
||
Id = c.Id,
|
||
ParentId = c.ParentId,
|
||
AssessmentTypeId = c.AssessmentTypeId,
|
||
Name = c.Name,
|
||
Code = c.Code,
|
||
CategoryType = c.CategoryType,
|
||
CategoryTypeName = GetCategoryTypeName(c.CategoryType),
|
||
ScoreRule = c.ScoreRule,
|
||
ScoreRuleName = GetScoreRuleName(c.ScoreRule),
|
||
Sort = c.Sort,
|
||
CreateTime = c.CreateTime,
|
||
Children = new List<CategoryTreeNode>()
|
||
})
|
||
.ToListAsync();
|
||
|
||
// 构建树形结构
|
||
return BuildCategoryTree(categories);
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<CategoryTreeNode> GetCategoryByIdAsync(long id)
|
||
{
|
||
var category = await _dbContext.ReportCategories
|
||
.AsNoTracking()
|
||
.Where(c => c.Id == id && !c.IsDeleted)
|
||
.Select(c => new CategoryTreeNode
|
||
{
|
||
Id = c.Id,
|
||
ParentId = c.ParentId,
|
||
AssessmentTypeId = c.AssessmentTypeId,
|
||
Name = c.Name,
|
||
Code = c.Code,
|
||
CategoryType = c.CategoryType,
|
||
CategoryTypeName = GetCategoryTypeName(c.CategoryType),
|
||
ScoreRule = c.ScoreRule,
|
||
ScoreRuleName = GetScoreRuleName(c.ScoreRule),
|
||
Sort = c.Sort,
|
||
CreateTime = c.CreateTime,
|
||
Children = new List<CategoryTreeNode>()
|
||
})
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (category == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "分类不存在");
|
||
}
|
||
|
||
return category;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<long> CreateCategoryAsync(CreateCategoryRequest request)
|
||
{
|
||
// 验证名称必填
|
||
if (string.IsNullOrWhiteSpace(request.Name))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类名称不能为空");
|
||
}
|
||
|
||
// 验证编码必填
|
||
if (string.IsNullOrWhiteSpace(request.Code))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类编码不能为空");
|
||
}
|
||
|
||
// 验证分类类型有效性
|
||
if (request.CategoryType < 1 || request.CategoryType > 8)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类类型无效，只能为1-8");
|
||
}
|
||
|
||
// 验证计分规则有效性
|
||
if (request.ScoreRule < 1 || request.ScoreRule > 2)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "计分规则无效，只能为1或2");
|
||
}
|
||
|
||
// 验证测评类型ID
|
||
if (request.AssessmentTypeId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评类型ID无效");
|
||
}
|
||
|
||
// 验证测评类型是否存在
|
||
var assessmentTypeExists = await _dbContext.AssessmentTypes
|
||
.AnyAsync(t => t.Id == request.AssessmentTypeId && !t.IsDeleted);
|
||
if (!assessmentTypeExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 如果有父分类，验证父分类是否存在
|
||
if (request.ParentId > 0)
|
||
{
|
||
var parentExists = await _dbContext.ReportCategories
|
||
.AnyAsync(c => c.Id == request.ParentId && !c.IsDeleted);
|
||
if (!parentExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "父分类不存在");
|
||
}
|
||
}
|
||
|
||
// 创建实体
|
||
var category = new ReportCategory
|
||
{
|
||
AssessmentTypeId = request.AssessmentTypeId,
|
||
ParentId = request.ParentId,
|
||
Name = request.Name,
|
||
Code = request.Code,
|
||
CategoryType = request.CategoryType,
|
||
ScoreRule = request.ScoreRule,
|
||
Sort = request.Sort,
|
||
CreateTime = DateTime.Now,
|
||
UpdateTime = DateTime.Now,
|
||
IsDeleted = false
|
||
};
|
||
|
||
_dbContext.ReportCategories.Add(category);
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("创建分类成功，ID: {CategoryId}, 名称: {Name}, 编码: {Code}",
|
||
category.Id, category.Name, category.Code);
|
||
|
||
return category.Id;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> UpdateCategoryAsync(UpdateCategoryRequest request)
|
||
{
|
||
// 查找分类
|
||
var category = await _dbContext.ReportCategories
|
||
.Where(c => c.Id == request.Id && !c.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (category == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "分类不存在");
|
||
}
|
||
|
||
// 验证名称必填
|
||
if (string.IsNullOrWhiteSpace(request.Name))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类名称不能为空");
|
||
}
|
||
|
||
// 验证编码必填
|
||
if (string.IsNullOrWhiteSpace(request.Code))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类编码不能为空");
|
||
}
|
||
|
||
// 验证分类类型有效性
|
||
if (request.CategoryType < 1 || request.CategoryType > 8)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类类型无效，只能为1-8");
|
||
}
|
||
|
||
// 验证计分规则有效性
|
||
if (request.ScoreRule < 1 || request.ScoreRule > 2)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "计分规则无效，只能为1或2");
|
||
}
|
||
|
||
// 验证测评类型ID
|
||
if (request.AssessmentTypeId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "测评类型ID无效");
|
||
}
|
||
|
||
// 验证测评类型是否存在
|
||
var assessmentTypeExists = await _dbContext.AssessmentTypes
|
||
.AnyAsync(t => t.Id == request.AssessmentTypeId && !t.IsDeleted);
|
||
if (!assessmentTypeExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.AssessmentTypeNotFound, "测评类型不存在");
|
||
}
|
||
|
||
// 如果有父分类，验证父分类是否存在
|
||
if (request.ParentId > 0)
|
||
{
|
||
// 不能将自己设为父分类
|
||
if (request.ParentId == request.Id)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "不能将自己设为父分类");
|
||
}
|
||
|
||
var parentExists = await _dbContext.ReportCategories
|
||
.AnyAsync(c => c.Id == request.ParentId && !c.IsDeleted);
|
||
if (!parentExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "父分类不存在");
|
||
}
|
||
}
|
||
|
||
// 更新字段
|
||
category.AssessmentTypeId = request.AssessmentTypeId;
|
||
category.ParentId = request.ParentId;
|
||
category.Name = request.Name;
|
||
category.Code = request.Code;
|
||
category.CategoryType = request.CategoryType;
|
||
category.ScoreRule = request.ScoreRule;
|
||
category.Sort = request.Sort;
|
||
category.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("更新分类成功，ID: {CategoryId}", category.Id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> DeleteCategoryAsync(long id)
|
||
{
|
||
// 查找分类
|
||
var category = await _dbContext.ReportCategories
|
||
.Where(c => c.Id == id && !c.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (category == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "分类不存在");
|
||
}
|
||
|
||
// 检查是否存在子分类
|
||
if (await HasChildCategoriesAsync(id))
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryHasChildren, "该分类存在子分类，无法删除");
|
||
}
|
||
|
||
// 软删除
|
||
category.IsDeleted = true;
|
||
category.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("删除分类成功，ID: {CategoryId}", id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> HasChildCategoriesAsync(long categoryId)
|
||
{
|
||
return await _dbContext.ReportCategories
|
||
.AnyAsync(c => c.ParentId == categoryId && !c.IsDeleted);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 私有方法
|
||
|
||
/// <summary>
|
||
/// 获取测评类型状态名称
|
||
/// </summary>
|
||
/// <param name="status">状态值</param>
|
||
/// <returns>状态名称</returns>
|
||
private static string GetTypeStatusName(int status)
|
||
{
|
||
return TypeStatusNames.TryGetValue(status, out var name) ? name : "未知";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取题目状态名称
|
||
/// </summary>
|
||
/// <param name="status">状态值</param>
|
||
/// <returns>状态名称</returns>
|
||
private static string GetQuestionStatusName(int status)
|
||
{
|
||
return QuestionStatusNames.TryGetValue(status, out var name) ? name : "未知";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取分类类型名称
|
||
/// </summary>
|
||
/// <param name="categoryType">分类类型值</param>
|
||
/// <returns>分类类型名称</returns>
|
||
private static string GetCategoryTypeName(int categoryType)
|
||
{
|
||
return CategoryTypeNames.TryGetValue(categoryType, out var name) ? name : "未知";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取计分规则名称
|
||
/// </summary>
|
||
/// <param name="scoreRule">计分规则值</param>
|
||
/// <returns>计分规则名称</returns>
|
||
private static string GetScoreRuleName(int scoreRule)
|
||
{
|
||
return ScoreRuleNames.TryGetValue(scoreRule, out var name) ? name : "未知";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 构建分类树形结构
|
||
/// </summary>
|
||
/// <param name="categories">所有分类列表</param>
|
||
/// <returns>树形结构列表（顶级分类）</returns>
|
||
private static List<CategoryTreeNode> BuildCategoryTree(List<CategoryTreeNode> categories)
|
||
{
|
||
// 创建字典以便快速查找
|
||
var categoryDict = categories.ToDictionary(c => c.Id);
|
||
|
||
// 顶级分类列表
|
||
var rootCategories = new List<CategoryTreeNode>();
|
||
|
||
foreach (var category in categories)
|
||
{
|
||
if (category.ParentId == 0)
|
||
{
|
||
// 顶级分类
|
||
rootCategories.Add(category);
|
||
}
|
||
else
|
||
{
|
||
// 子分类，添加到父分类的 Children 列表
|
||
if (categoryDict.TryGetValue(category.ParentId, out var parent))
|
||
{
|
||
parent.Children.Add(category);
|
||
}
|
||
}
|
||
}
|
||
|
||
return rootCategories;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 题目分类映射操作
|
||
|
||
/// <inheritdoc />
|
||
public async Task<List<MappingCategoryDto>> GetMappingsByQuestionAsync(long questionId)
|
||
{
|
||
// 验证题目是否存在
|
||
var questionExists = await _dbContext.Questions
|
||
.AnyAsync(q => q.Id == questionId && !q.IsDeleted);
|
||
if (!questionExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNotFound, "题目不存在");
|
||
}
|
||
|
||
// 获取该题目关联的所有分类
|
||
var mappings = await _dbContext.QuestionCategoryMappings
|
||
.AsNoTracking()
|
||
.Where(m => m.QuestionId == questionId)
|
||
.Join(
|
||
_dbContext.ReportCategories.Where(c => !c.IsDeleted),
|
||
m => m.CategoryId,
|
||
c => c.Id,
|
||
(m, c) => new MappingCategoryDto
|
||
{
|
||
Id = c.Id,
|
||
Name = c.Name,
|
||
Code = c.Code,
|
||
CategoryType = c.CategoryType,
|
||
CategoryTypeName = GetCategoryTypeName(c.CategoryType),
|
||
MappingCreateTime = m.CreateTime
|
||
})
|
||
.OrderBy(c => c.CategoryType)
|
||
.ThenBy(c => c.Name)
|
||
.ToListAsync();
|
||
|
||
return mappings;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<List<MappingQuestionDto>> GetMappingsByCategoryAsync(long categoryId)
|
||
{
|
||
// 验证分类是否存在
|
||
var categoryExists = await _dbContext.ReportCategories
|
||
.AnyAsync(c => c.Id == categoryId && !c.IsDeleted);
|
||
if (!categoryExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "分类不存在");
|
||
}
|
||
|
||
// 获取该分类关联的所有题目
|
||
var mappings = await _dbContext.QuestionCategoryMappings
|
||
.AsNoTracking()
|
||
.Where(m => m.CategoryId == categoryId)
|
||
.Join(
|
||
_dbContext.Questions.Where(q => !q.IsDeleted),
|
||
m => m.QuestionId,
|
||
q => q.Id,
|
||
(m, q) => new { Mapping = m, Question = q })
|
||
.Join(
|
||
_dbContext.AssessmentTypes.Where(t => !t.IsDeleted),
|
||
mq => mq.Question.AssessmentTypeId,
|
||
t => t.Id,
|
||
(mq, t) => new MappingQuestionDto
|
||
{
|
||
Id = mq.Question.Id,
|
||
QuestionNo = mq.Question.QuestionNo,
|
||
Content = mq.Question.Content,
|
||
AssessmentTypeId = mq.Question.AssessmentTypeId,
|
||
AssessmentTypeName = t.Name,
|
||
MappingCreateTime = mq.Mapping.CreateTime
|
||
})
|
||
.OrderBy(q => q.AssessmentTypeId)
|
||
.ThenBy(q => q.QuestionNo)
|
||
.ToListAsync();
|
||
|
||
return mappings;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> BatchUpdateMappingsAsync(BatchUpdateMappingsRequest request)
|
||
{
|
||
// 验证题目ID
|
||
if (request.QuestionId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "题目ID无效");
|
||
}
|
||
|
||
// 验证题目是否存在
|
||
var questionExists = await _dbContext.Questions
|
||
.AnyAsync(q => q.Id == request.QuestionId && !q.IsDeleted);
|
||
if (!questionExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.QuestionNotFound, "题目不存在");
|
||
}
|
||
|
||
// 验证所有分类ID是否存在
|
||
if (request.CategoryIds != null && request.CategoryIds.Count > 0)
|
||
{
|
||
// 去重
|
||
var uniqueCategoryIds = request.CategoryIds.Distinct().ToList();
|
||
|
||
var existingCategoryIds = await _dbContext.ReportCategories
|
||
.Where(c => uniqueCategoryIds.Contains(c.Id) && !c.IsDeleted)
|
||
.Select(c => c.Id)
|
||
.ToListAsync();
|
||
|
||
var invalidCategoryIds = uniqueCategoryIds.Except(existingCategoryIds).ToList();
|
||
if (invalidCategoryIds.Count > 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound,
|
||
$"以下分类ID不存在: {string.Join(", ", invalidCategoryIds)}");
|
||
}
|
||
}
|
||
|
||
// 使用事务确保原子性
|
||
using var transaction = await _dbContext.Database.BeginTransactionAsync();
|
||
try
|
||
{
|
||
// 删除该题目的所有现有映射
|
||
var existingMappings = await _dbContext.QuestionCategoryMappings
|
||
.Where(m => m.QuestionId == request.QuestionId)
|
||
.ToListAsync();
|
||
|
||
if (existingMappings.Count > 0)
|
||
{
|
||
_dbContext.QuestionCategoryMappings.RemoveRange(existingMappings);
|
||
}
|
||
|
||
// 创建新的映射
|
||
if (request.CategoryIds != null && request.CategoryIds.Count > 0)
|
||
{
|
||
var uniqueCategoryIds = request.CategoryIds.Distinct().ToList();
|
||
var newMappings = uniqueCategoryIds.Select(categoryId => new QuestionCategoryMapping
|
||
{
|
||
QuestionId = request.QuestionId,
|
||
CategoryId = categoryId,
|
||
CreateTime = DateTime.Now
|
||
}).ToList();
|
||
|
||
_dbContext.QuestionCategoryMappings.AddRange(newMappings);
|
||
}
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
await transaction.CommitAsync();
|
||
|
||
_logger.LogInformation("批量更新题目分类映射成功，题目ID: {QuestionId}, 分类数量: {CategoryCount}",
|
||
request.QuestionId, request.CategoryIds?.Count ?? 0);
|
||
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
await transaction.RollbackAsync();
|
||
_logger.LogError(ex, "批量更新题目分类映射失败，题目ID: {QuestionId}", request.QuestionId);
|
||
throw new BusinessException(ErrorCodes.SystemError, "批量更新映射失败，请稍后重试");
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 报告结论操作
|
||
|
||
/// <summary>
|
||
/// 结论类型名称映射
|
||
/// </summary>
|
||
private static readonly Dictionary<int, string> ConclusionTypeNames = new()
|
||
{
|
||
{ 1, "最强" },
|
||
{ 2, "较强" },
|
||
{ 3, "较弱" },
|
||
{ 4, "最弱" }
|
||
};
|
||
|
||
/// <inheritdoc />
|
||
public async Task<List<ConclusionDto>> GetConclusionListAsync(long categoryId)
|
||
{
|
||
// 验证分类ID
|
||
if (categoryId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类ID无效");
|
||
}
|
||
|
||
// 验证分类是否存在
|
||
var categoryExists = await _dbContext.ReportCategories
|
||
.AnyAsync(c => c.Id == categoryId && !c.IsDeleted);
|
||
if (!categoryExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "分类不存在");
|
||
}
|
||
|
||
// 获取该分类下的所有结论，按结论类型排序
|
||
var conclusions = await _dbContext.ReportConclusions
|
||
.AsNoTracking()
|
||
.Where(c => c.CategoryId == categoryId && !c.IsDeleted)
|
||
.Join(
|
||
_dbContext.ReportCategories.Where(cat => !cat.IsDeleted),
|
||
c => c.CategoryId,
|
||
cat => cat.Id,
|
||
(c, cat) => new ConclusionDto
|
||
{
|
||
Id = c.Id,
|
||
CategoryId = c.CategoryId,
|
||
CategoryName = cat.Name,
|
||
ConclusionType = c.ConclusionType,
|
||
ConclusionTypeName = GetConclusionTypeName(c.ConclusionType),
|
||
Title = c.Title,
|
||
Content = c.Content,
|
||
CreateTime = c.CreateTime
|
||
})
|
||
.OrderBy(c => c.ConclusionType)
|
||
.ToListAsync();
|
||
|
||
return conclusions;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<ConclusionDto> GetConclusionByIdAsync(long id)
|
||
{
|
||
var conclusion = await _dbContext.ReportConclusions
|
||
.AsNoTracking()
|
||
.Where(c => c.Id == id && !c.IsDeleted)
|
||
.Join(
|
||
_dbContext.ReportCategories.Where(cat => !cat.IsDeleted),
|
||
c => c.CategoryId,
|
||
cat => cat.Id,
|
||
(c, cat) => new ConclusionDto
|
||
{
|
||
Id = c.Id,
|
||
CategoryId = c.CategoryId,
|
||
CategoryName = cat.Name,
|
||
ConclusionType = c.ConclusionType,
|
||
ConclusionTypeName = GetConclusionTypeName(c.ConclusionType),
|
||
Title = c.Title,
|
||
Content = c.Content,
|
||
CreateTime = c.CreateTime
|
||
})
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (conclusion == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ConclusionNotFound, "结论不存在");
|
||
}
|
||
|
||
return conclusion;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<long> CreateConclusionAsync(CreateConclusionRequest request)
|
||
{
|
||
// 验证分类ID
|
||
if (request.CategoryId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类ID无效");
|
||
}
|
||
|
||
// 验证结论类型有效性
|
||
if (request.ConclusionType < 1 || request.ConclusionType > 4)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "结论类型无效，只能为1（最强）、2（较强）、3（较弱）或4（最弱）");
|
||
}
|
||
|
||
// 验证内容必填
|
||
if (string.IsNullOrWhiteSpace(request.Content))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "结论内容不能为空");
|
||
}
|
||
|
||
// 验证分类是否存在
|
||
var categoryExists = await _dbContext.ReportCategories
|
||
.AnyAsync(c => c.Id == request.CategoryId && !c.IsDeleted);
|
||
if (!categoryExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "分类不存在");
|
||
}
|
||
|
||
// 创建实体
|
||
var conclusion = new ReportConclusion
|
||
{
|
||
CategoryId = request.CategoryId,
|
||
ConclusionType = request.ConclusionType,
|
||
Title = request.Title,
|
||
Content = request.Content,
|
||
CreateTime = DateTime.Now,
|
||
UpdateTime = DateTime.Now,
|
||
IsDeleted = false
|
||
};
|
||
|
||
_dbContext.ReportConclusions.Add(conclusion);
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("创建结论成功，ID: {ConclusionId}, 分类ID: {CategoryId}, 结论类型: {ConclusionType}",
|
||
conclusion.Id, conclusion.CategoryId, conclusion.ConclusionType);
|
||
|
||
return conclusion.Id;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> UpdateConclusionAsync(UpdateConclusionRequest request)
|
||
{
|
||
// 查找结论
|
||
var conclusion = await _dbContext.ReportConclusions
|
||
.Where(c => c.Id == request.Id && !c.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (conclusion == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ConclusionNotFound, "结论不存在");
|
||
}
|
||
|
||
// 验证分类ID
|
||
if (request.CategoryId <= 0)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "分类ID无效");
|
||
}
|
||
|
||
// 验证结论类型有效性
|
||
if (request.ConclusionType < 1 || request.ConclusionType > 4)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "结论类型无效，只能为1（最强）、2（较强）、3（较弱）或4（最弱）");
|
||
}
|
||
|
||
// 验证内容必填
|
||
if (string.IsNullOrWhiteSpace(request.Content))
|
||
{
|
||
throw new BusinessException(ErrorCodes.ParamError, "结论内容不能为空");
|
||
}
|
||
|
||
// 验证分类是否存在
|
||
var categoryExists = await _dbContext.ReportCategories
|
||
.AnyAsync(c => c.Id == request.CategoryId && !c.IsDeleted);
|
||
if (!categoryExists)
|
||
{
|
||
throw new BusinessException(ErrorCodes.CategoryNotFound, "分类不存在");
|
||
}
|
||
|
||
// 更新字段
|
||
conclusion.CategoryId = request.CategoryId;
|
||
conclusion.ConclusionType = request.ConclusionType;
|
||
conclusion.Title = request.Title;
|
||
conclusion.Content = request.Content;
|
||
conclusion.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("更新结论成功，ID: {ConclusionId}", conclusion.Id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <inheritdoc />
|
||
public async Task<bool> DeleteConclusionAsync(long id)
|
||
{
|
||
// 查找结论
|
||
var conclusion = await _dbContext.ReportConclusions
|
||
.Where(c => c.Id == id && !c.IsDeleted)
|
||
.FirstOrDefaultAsync();
|
||
|
||
if (conclusion == null)
|
||
{
|
||
throw new BusinessException(ErrorCodes.ConclusionNotFound, "结论不存在");
|
||
}
|
||
|
||
// 软删除
|
||
conclusion.IsDeleted = true;
|
||
conclusion.UpdateTime = DateTime.Now;
|
||
|
||
await _dbContext.SaveChangesAsync();
|
||
|
||
_logger.LogInformation("删除结论成功，ID: {ConclusionId}", id);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取结论类型名称
|
||
/// </summary>
|
||
/// <param name="conclusionType">结论类型值</param>
|
||
/// <returns>结论类型名称</returns>
|
||
private static string GetConclusionTypeName(int conclusionType)
|
||
{
|
||
return ConclusionTypeNames.TryGetValue(conclusionType, out var name) ? name : "未知";
|
||
}
|
||
|
||
#endregion
|
||
}
|