You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
918 lines
49 KiB
918 lines
49 KiB
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using NPOI.SS.Formula.Functions;
|
|
using Org.BouncyCastle.Math.EC.Rfc7748;
|
|
using Shentun.WebPeis.AppointPatientRegisters;
|
|
using Shentun.WebPeis.DiseaseRiskLevels;
|
|
using Shentun.WebPeis.Enums;
|
|
using Shentun.WebPeis.Models;
|
|
using Shentun.WebPeis.Persons;
|
|
using Shentun.WebPeis.SysParmValues;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Volo.Abp;
|
|
using Volo.Abp.Application.Services;
|
|
using Volo.Abp.Domain.Entities;
|
|
using Volo.Abp.Domain.Repositories;
|
|
using Volo.Abp.Uow;
|
|
|
|
namespace Shentun.WebPeis.QuestionRegisters
|
|
{
|
|
[ApiExplorerSettings(GroupName = "Work")]
|
|
[Authorize]
|
|
public class QuestionRegisterAppService : ApplicationService
|
|
{
|
|
private readonly IRepository<QuestionRegister> _repository;
|
|
private readonly IRepository<QuestionRegisterItem> _questionRegisterItemRepository;
|
|
private readonly IRepository<QuestionRegisterAnswer> _questionRegisterAnswerRrepository;
|
|
private readonly IRepository<Question> _questionRepository;
|
|
private readonly IRepository<QuestionAnswer> _questionAnswerRepository;
|
|
private readonly IRepository<QuestionSubjectType> _questionSubjectTypeRepository;
|
|
private readonly IRepository<DiseaseRisk> _diseaseRiskRepository;
|
|
private readonly IRepository<DiseaseRiskLevel> _diseaseRiskLevelRepository;
|
|
private readonly IRepository<QuestionAnswerRiskLevel> _questionAnswerRiskLevelRepository;
|
|
private readonly IRepository<QuestionAnswerAsbitem> _questionAnswerAsbitemRepository;
|
|
private readonly IRepository<Asbitem> _asbitemRepository;
|
|
private readonly IRepository<Person> _personRepository;
|
|
private readonly QuestionRegisterManager _questionRegisterManager;
|
|
private readonly IUnitOfWorkManager _unitOfWorkManager;
|
|
private readonly SysParmValueManager _sysParmValueManager;
|
|
private readonly PersonManager _personManager;
|
|
public QuestionRegisterAppService(IRepository<QuestionRegister> repository,
|
|
IRepository<QuestionRegisterItem> questionRegisterItemRepository,
|
|
IRepository<QuestionRegisterAnswer> questionRegisterAnswerRrepository,
|
|
IRepository<Question> questionRepository,
|
|
IRepository<QuestionAnswer> questionAnswerRepository,
|
|
QuestionRegisterManager questionRegisterManager,
|
|
IUnitOfWorkManager unitOfWorkManager,
|
|
IRepository<QuestionSubjectType> questionSubjectTypeRepository,
|
|
IRepository<DiseaseRisk> diseaseRiskRepository,
|
|
IRepository<DiseaseRiskLevel> diseaseRiskLevelRepository,
|
|
IRepository<QuestionAnswerRiskLevel> questionAnswerRiskLevelRepository,
|
|
IRepository<QuestionAnswerAsbitem> questionAnswerAsbitemRepository,
|
|
IRepository<Asbitem> asbitemRepository,
|
|
SysParmValueManager sysParmValueManager,
|
|
IRepository<Person> personRepository,
|
|
PersonManager personManager)
|
|
{
|
|
_repository = repository;
|
|
_questionRegisterItemRepository = questionRegisterItemRepository;
|
|
_questionRegisterAnswerRrepository = questionRegisterAnswerRrepository;
|
|
_questionRepository = questionRepository;
|
|
_questionAnswerRepository = questionAnswerRepository;
|
|
_questionRegisterManager = questionRegisterManager;
|
|
_unitOfWorkManager = unitOfWorkManager;
|
|
_questionSubjectTypeRepository = questionSubjectTypeRepository;
|
|
_diseaseRiskRepository = diseaseRiskRepository;
|
|
_diseaseRiskLevelRepository = diseaseRiskLevelRepository;
|
|
_questionAnswerRiskLevelRepository = questionAnswerRiskLevelRepository;
|
|
_questionAnswerAsbitemRepository = questionAnswerAsbitemRepository;
|
|
_asbitemRepository = asbitemRepository;
|
|
_sysParmValueManager = sysParmValueManager;
|
|
_personRepository = personRepository;
|
|
_personManager = personManager;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取人员问卷
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/QuestionRegister/GetByPersonId")]
|
|
public async Task<QuestionRegisterDto> GetByPersonIdAsync(PersonIdInputDto input)
|
|
{
|
|
|
|
var questions = await _questionRepository.GetListAsync(o => o.IsActive == 'Y');
|
|
var questionAnswers = await _questionAnswerRepository.GetListAsync();
|
|
var questionRegister = (await _repository.GetQueryableAsync())
|
|
.Where(o => o.PersonId == input.PersonId)
|
|
.OrderByDescending(o => o.CreationTime)
|
|
.FirstOrDefault();
|
|
|
|
var personEntity = await _personRepository.FirstOrDefaultAsync(f => f.PersonId == input.PersonId);
|
|
if (personEntity == null)
|
|
{
|
|
throw new UserFriendlyException("人员不存在");
|
|
}
|
|
|
|
|
|
|
|
QuestionRegisterDto questionRegisterDto;
|
|
questionRegisterDto = await GetBasicDataAsync(input, personEntity.SexId);
|
|
if (questionRegister == null)
|
|
{
|
|
return questionRegisterDto;
|
|
}
|
|
questionRegisterDto.QuestionRegisterId = questionRegister.QuestionRegisterId;
|
|
//已登记过
|
|
var questionRegisterItems = (from questionRegisterItem in await _questionRegisterItemRepository.GetQueryableAsync()
|
|
join questionRegisterAnswer in await _questionRegisterAnswerRrepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionRegisterItemId equals questionRegisterAnswer.QuestionRegisterItemId
|
|
where questionRegisterItem.QuestionRegisterId == questionRegister.QuestionRegisterId
|
|
select new
|
|
{
|
|
questionRegisterItem,
|
|
questionRegisterAnswer,
|
|
}).ToList();
|
|
|
|
|
|
foreach (var questionRegisterItemDto in questionRegisterDto.QuestionRegisterItems)
|
|
{
|
|
var questionRegisterItemEntity = questionRegisterItems.Where(o =>
|
|
o.questionRegisterItem.QuestionId == questionRegisterItemDto.QuestionId).FirstOrDefault();
|
|
if (questionRegisterItemEntity != null)
|
|
{
|
|
questionRegisterItemDto.QuestionRegisterItemId = questionRegisterItemEntity.questionRegisterItem.QuestionRegisterItemId;
|
|
}
|
|
foreach (var questionRegisterAnswer in questionRegisterItemDto.QuestionRegisterAnswers)
|
|
{
|
|
var answer = questionRegisterItems.Where(
|
|
o => o.questionRegisterAnswer.QuestionAnswerId == questionRegisterAnswer.QuestionAnswerId)
|
|
.SingleOrDefault();
|
|
if (answer != null)
|
|
{
|
|
questionRegisterAnswer.IsSelected = 'Y';
|
|
questionRegisterAnswer.Content = answer.questionRegisterAnswer.Content;
|
|
|
|
}
|
|
foreach (var childQuestionRegisterAnswer in questionRegisterAnswer.Childs)
|
|
{
|
|
answer = questionRegisterItems.Where(
|
|
o => o.questionRegisterAnswer.QuestionAnswerId == childQuestionRegisterAnswer.QuestionAnswerId)
|
|
.SingleOrDefault();
|
|
if (answer != null)
|
|
{
|
|
childQuestionRegisterAnswer.IsSelected = 'Y';
|
|
childQuestionRegisterAnswer.Content = answer.questionRegisterAnswer.Content;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return questionRegisterDto;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取生育计划、危险因素、疾病等列表
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/QuestionRegister/GetSubjectTypeListByPersonId")]
|
|
public async Task<List<PersonSubjectTypeDto>> GetSubjectTypeListByPersonIdAsync(PersonIdInputDto input)
|
|
{
|
|
var questionRegister = (await _repository.GetQueryableAsync())
|
|
.Where(o => o.PersonId == input.PersonId)
|
|
.OrderByDescending(o => o.CreationTime)
|
|
.FirstOrDefault();
|
|
if (questionRegister == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var questionRegisterItems = (from questionRegisterItem in await _questionRegisterItemRepository.GetQueryableAsync()
|
|
join questionRegisterAnswer in await _questionRegisterAnswerRrepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionRegisterItemId equals questionRegisterAnswer.QuestionRegisterItemId
|
|
join questionAnswer in await _questionAnswerRepository.GetQueryableAsync()
|
|
on questionRegisterAnswer.QuestionAnswerId equals questionAnswer.QuestionAnswerId
|
|
join question in await _questionRepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionId equals question.QuestionId
|
|
join questionSubjectType in await _questionSubjectTypeRepository.GetQueryableAsync()
|
|
on question.QuestionSubjectTypeId equals questionSubjectType.QuestionSubjectTypeId
|
|
where questionRegisterItem.QuestionRegisterId == questionRegister.QuestionRegisterId
|
|
orderby questionSubjectType.DisplayOrder
|
|
select new
|
|
{
|
|
questionSubjectType,
|
|
questionRegisterItem,
|
|
questionRegisterAnswer,
|
|
questionAnswer
|
|
}).ToList();
|
|
|
|
var personSubjectTypeDtos = questionRegisterItems.GroupBy(o => o.questionSubjectType)
|
|
.Select(o => new PersonSubjectTypeDto()
|
|
{
|
|
QuestionSubjectTypeId = o.Key.QuestionSubjectTypeId,
|
|
QuestionSubjectTypeName = o.Key.QuestionSubjectTypeName,
|
|
DisplayOrder = o.Key.DisplayOrder
|
|
}).ToList();
|
|
foreach (var personSubjectTypeDto in personSubjectTypeDtos)
|
|
{
|
|
var questionSubjectTypeItems = questionRegisterItems.Where(o =>
|
|
o.questionSubjectType.QuestionSubjectTypeId == personSubjectTypeDto.QuestionSubjectTypeId)
|
|
.OrderBy(o => o.questionAnswer.DisplayOrder).ToList();
|
|
foreach (var questionRegisterItem in questionSubjectTypeItems)
|
|
{
|
|
if (questionRegisterItem.questionAnswer.IsNone == 'Y')
|
|
{
|
|
continue;
|
|
}
|
|
if (questionRegisterItems.Where(o =>
|
|
(o.questionAnswer.PathCode.StartsWith(questionRegisterItem.questionAnswer.PathCode + ".") &&
|
|
questionRegisterItem.questionAnswer.PathCode.Length == 5)).Any())
|
|
{
|
|
continue;
|
|
}
|
|
string answer;
|
|
if (questionRegisterItem.questionAnswer.AnswerResultType == AnswerResultTypeFlag.Choice)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(questionRegisterItem.questionAnswer.Aliases))
|
|
{
|
|
answer = questionRegisterItem.questionAnswer.QuestionAnswerName;
|
|
}
|
|
else
|
|
{
|
|
answer = questionRegisterItem.questionAnswer.Aliases;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answer = questionRegisterItem.questionRegisterAnswer.Content;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(answer))
|
|
{
|
|
continue;
|
|
}
|
|
personSubjectTypeDto.Answers.Add(new PersonSubjectTypeQuestionAnswer()
|
|
{
|
|
QuestionAnswerName = answer,
|
|
DisplayOrder = questionRegisterItem.questionAnswer.DisplayOrder,
|
|
});
|
|
}
|
|
}
|
|
|
|
//超重信息
|
|
var isOverweight = await _personManager.IsOverweight(input.PersonId);
|
|
if (isOverweight)
|
|
{
|
|
//危险因素编码是03
|
|
var personSubjectTypeDto = personSubjectTypeDtos.Where(o => o.QuestionSubjectTypeId == "03").Single();
|
|
var questionAnswerOverweightCodeStr = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "question_answer_overweight_code");
|
|
if (!Guid.TryParse(questionAnswerOverweightCodeStr, out var questionAnswerOverweightCode))
|
|
{
|
|
throw new UserFriendlyException("在系统参数中超重编码维护不正确");
|
|
}
|
|
var questionAnswer = await _questionAnswerRepository.GetAsync(o => o.QuestionAnswerId == questionAnswerOverweightCode);
|
|
personSubjectTypeDto.Answers.Add(new PersonSubjectTypeQuestionAnswer()
|
|
{
|
|
QuestionAnswerName = questionAnswer.QuestionAnswerName,
|
|
DisplayOrder = questionAnswer.DisplayOrder,
|
|
});
|
|
}
|
|
return personSubjectTypeDtos;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取问卷结果列表
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/QuestionRegister/GetQuestionRegisterListByPersonId")]
|
|
public async Task<List<QuestionRegisterItemResultDto>> GetQuestionRegisterListByPersonIdAsync(PersonIdInputDto input)
|
|
{
|
|
var questionRegister = (await _repository.GetQueryableAsync())
|
|
.Where(o => o.PersonId == input.PersonId)
|
|
.OrderByDescending(o => o.CreationTime)
|
|
.FirstOrDefault();
|
|
if (questionRegister == null)
|
|
{
|
|
return null;
|
|
}
|
|
var questionRegisterItems = (from questionRegisterItem in await _questionRegisterItemRepository.GetQueryableAsync()
|
|
join questionRegisterAnswer in await _questionRegisterAnswerRrepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionRegisterItemId equals questionRegisterAnswer.QuestionRegisterItemId
|
|
join questionAnswer in await _questionAnswerRepository.GetQueryableAsync()
|
|
on questionRegisterAnswer.QuestionAnswerId equals questionAnswer.QuestionAnswerId
|
|
join question in await _questionRepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionId equals question.QuestionId
|
|
join questionSubjectType in await _questionSubjectTypeRepository.GetQueryableAsync()
|
|
on question.QuestionSubjectTypeId equals questionSubjectType.QuestionSubjectTypeId
|
|
where questionRegisterItem.QuestionRegisterId == questionRegister.QuestionRegisterId
|
|
orderby questionSubjectType.DisplayOrder, question.DisplayOrder
|
|
select new
|
|
{
|
|
questionSubjectType,
|
|
question,
|
|
questionRegisterItem,
|
|
questionRegisterAnswer,
|
|
questionAnswer
|
|
}).ToList();
|
|
var questions = questionRegisterItems.GroupBy(o => o.question)
|
|
.Select(o => new QuestionRegisterItemResultDto()
|
|
{
|
|
QuestionId = o.Key.QuestionId,
|
|
QuestionName = o.Key.QuestionName,
|
|
DisplayOrder = o.Key.DisplayOrder
|
|
}).ToList();
|
|
|
|
foreach (var question in questions)
|
|
{
|
|
var questionAnswers = questionRegisterItems.Where(o =>
|
|
o.question.QuestionId == question.QuestionId)
|
|
.OrderBy(o => o.questionAnswer.DisplayOrder).ToList();
|
|
foreach (var questionRegisterItem in questionAnswers)
|
|
{
|
|
if (questionRegisterItems.Where(o =>
|
|
(o.questionAnswer.PathCode.StartsWith(questionRegisterItem.questionAnswer.PathCode + ".") &&
|
|
questionRegisterItem.questionAnswer.PathCode.Length == 5)).Any())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string answer;
|
|
if (questionRegisterItem.questionAnswer.AnswerResultType == AnswerResultTypeFlag.Choice)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(questionRegisterItem.questionAnswer.Aliases))
|
|
{
|
|
answer = questionRegisterItem.questionAnswer.QuestionAnswerName;
|
|
}
|
|
else
|
|
{
|
|
answer = questionRegisterItem.questionAnswer.Aliases;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answer = questionRegisterItem.questionRegisterAnswer.Content;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(answer))
|
|
{
|
|
continue;
|
|
}
|
|
question.Answers.Add(new QuestionRegisterItemResultAnswer()
|
|
{
|
|
Answer = answer,
|
|
DisplayOrder = questionRegisterItem.questionAnswer.DisplayOrder,
|
|
});
|
|
}
|
|
}
|
|
|
|
return questions;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取疾病风险列表
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/QuestionRegister/GetDiseaseRiskListByPersonId")]
|
|
public async Task<List<QuestionRegisterDiseaseRiskDto>> GetDiseaseRiskListByPersonIdAsync(PersonIdInputDto input)
|
|
{
|
|
var questionRegister = (await _repository.GetQueryableAsync())
|
|
.Where(o => o.PersonId == input.PersonId)
|
|
.OrderByDescending(o => o.CreationTime)
|
|
.FirstOrDefault();
|
|
|
|
if (questionRegister == null)
|
|
{
|
|
return null;
|
|
}
|
|
//获取人员登记问卷
|
|
var questionRegisterItems = (from questionRegisterItem in await _questionRegisterItemRepository.GetQueryableAsync()
|
|
join questionRegisterAnswer in await _questionRegisterAnswerRrepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionRegisterItemId equals questionRegisterAnswer.QuestionRegisterItemId
|
|
join questionAnswer in await _questionAnswerRepository.GetQueryableAsync()
|
|
on questionRegisterAnswer.QuestionAnswerId equals questionAnswer.QuestionAnswerId
|
|
join question in await _questionRepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionId equals question.QuestionId
|
|
join questionSubjectType in await _questionSubjectTypeRepository.GetQueryableAsync()
|
|
on question.QuestionSubjectTypeId equals questionSubjectType.QuestionSubjectTypeId
|
|
where questionRegisterItem.QuestionRegisterId == questionRegister.QuestionRegisterId
|
|
orderby questionSubjectType.DisplayOrder, question.DisplayOrder
|
|
select new
|
|
{
|
|
questionSubjectType,
|
|
question,
|
|
questionRegisterItem,
|
|
questionRegisterAnswer,
|
|
questionAnswer
|
|
}).ToList();
|
|
//获取疾病风险基础字典信息
|
|
var diseaseRisks = (from diseaseRisk in await _diseaseRiskRepository.GetQueryableAsync()
|
|
join diseaseRiskLevel in await _diseaseRiskLevelRepository.GetQueryableAsync()
|
|
on diseaseRisk.DiseaseRiskId equals diseaseRiskLevel.DiseaseRiskId into emptyDiseaseRiskLevel
|
|
from haveDiseaseRiskLevel in emptyDiseaseRiskLevel.DefaultIfEmpty()
|
|
join questionAnswerRiskLevel in await _questionAnswerRiskLevelRepository.GetQueryableAsync()
|
|
on haveDiseaseRiskLevel.DiseaseRiskLevelId equals questionAnswerRiskLevel.DiseaseRiskLevelId into emptyQuestionAnswerRiskLevel
|
|
from haveQuestionAnswerRiskLevel in emptyQuestionAnswerRiskLevel.DefaultIfEmpty()
|
|
orderby diseaseRisk.DisplayOrder
|
|
select new
|
|
{
|
|
diseaseRisk,
|
|
haveDiseaseRiskLevel,
|
|
haveQuestionAnswerRiskLevel
|
|
}).ToList();
|
|
|
|
var questionRegisterDiseaseRiskDtos = diseaseRisks.GroupBy(o => o.diseaseRisk)
|
|
.Select(o => new QuestionRegisterDiseaseRiskDto()
|
|
{
|
|
DiseaseRiskId = o.Key.DiseaseRiskId,
|
|
DiseaseRiskName = o.Key.DiseaseRiskName,
|
|
DisplayOrder = o.Key.DisplayOrder
|
|
}).ToList();
|
|
|
|
//超重信息
|
|
var isOverweight = await _personManager.IsOverweight(input.PersonId);
|
|
QuestionAnswer overweightQuestionAnswer = null;
|
|
if (isOverweight)
|
|
{
|
|
var questionAnswerOverweightCodeStr = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "question_answer_overweight_code");
|
|
if (!Guid.TryParse(questionAnswerOverweightCodeStr, out var questionAnswerOverweightCode))
|
|
{
|
|
throw new UserFriendlyException("在系统参数中超重编码维护不正确");
|
|
}
|
|
overweightQuestionAnswer = await _questionAnswerRepository.GetAsync(o => o.QuestionAnswerId == questionAnswerOverweightCode);
|
|
|
|
}
|
|
|
|
foreach (var diseaseRisk in questionRegisterDiseaseRiskDtos)
|
|
{
|
|
//疾病级别必须按优先级别排序，取顺序最高的作为最高风险级
|
|
var diseaseRiskLevels = diseaseRisks.Where(o => o.diseaseRisk.DiseaseRiskId == diseaseRisk.DiseaseRiskId
|
|
&& o.haveDiseaseRiskLevel != null)
|
|
.OrderByDescending(o => o.haveDiseaseRiskLevel == null ? 1 : o.haveDiseaseRiskLevel.DisplayOrder).ToList();
|
|
DiseaseRiskLevel matchDiseaseRiskLevel = null;
|
|
foreach (var diseaseRiskLevel in diseaseRiskLevels)
|
|
{
|
|
if (questionRegisterItems.Where(o => diseaseRiskLevel.haveQuestionAnswerRiskLevel != null &&
|
|
o.questionRegisterAnswer.QuestionAnswerId ==
|
|
diseaseRiskLevel.haveQuestionAnswerRiskLevel.QuestionAnswerId).Any())
|
|
{
|
|
if (diseaseRiskLevel.haveDiseaseRiskLevel != null)
|
|
{
|
|
matchDiseaseRiskLevel = diseaseRiskLevel.haveDiseaseRiskLevel;
|
|
break;
|
|
}
|
|
|
|
}
|
|
//超重
|
|
if (overweightQuestionAnswer != null && diseaseRiskLevel.haveQuestionAnswerRiskLevel != null)
|
|
{
|
|
if (diseaseRiskLevel.haveQuestionAnswerRiskLevel.QuestionAnswerId == overweightQuestionAnswer.QuestionAnswerId)
|
|
{
|
|
matchDiseaseRiskLevel = diseaseRiskLevel.haveDiseaseRiskLevel;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (matchDiseaseRiskLevel == null)
|
|
{
|
|
//因为是倒叙排序，所以最后一个疾病风险就是最低级别疾病风险
|
|
matchDiseaseRiskLevel = diseaseRiskLevels.LastOrDefault() == null ? null : diseaseRiskLevels.LastOrDefault().haveDiseaseRiskLevel;
|
|
}
|
|
if (matchDiseaseRiskLevel == null)
|
|
{
|
|
diseaseRisk.DiseaseRiskLevelName = "低危";
|
|
}
|
|
else
|
|
{
|
|
diseaseRisk.DiseaseRiskLevelId = matchDiseaseRiskLevel.DiseaseRiskLevelId;
|
|
diseaseRisk.DiseaseRiskLevelName = matchDiseaseRiskLevel.DiseaseRiskLevelName;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
return questionRegisterDiseaseRiskDtos;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取人员单个疾病风险明细
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/QuestionRegister/GetDiseaseRiskByPersonDiseaseRiskId")]
|
|
public async Task<QuestionRegisterDiseaseRiskSingleDto> GetDiseaseRiskByPersonDiseaseRiskIdAsync(PersonDiseaseRiskIdInputDto input)
|
|
{
|
|
if (input == null) { throw new UserFriendlyException("input参数不能为空"); }
|
|
|
|
var questionRegister = (await _repository.GetQueryableAsync())
|
|
.Where(o => o.PersonId == input.PersonId)
|
|
.OrderByDescending(o => o.CreationTime)
|
|
.FirstOrDefault();
|
|
|
|
if (questionRegister == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var diseaseRisk = await _diseaseRiskRepository.GetAsync(o => o.DiseaseRiskId == input.DiseaseRiskId);
|
|
var diseaseRiskLevels = (await _diseaseRiskLevelRepository.GetListAsync(o => o.DiseaseRiskId == input.DiseaseRiskId))
|
|
.OrderBy(o => o.DisplayOrder);
|
|
|
|
//获取人员疾病风险列表
|
|
var diseaseRiskList = await GetDiseaseRiskListByPersonIdAsync(new PersonIdInputDto() { PersonId = input.PersonId });
|
|
var personDiseaseRisk = diseaseRiskList.Where(o => o.DiseaseRiskId == input.DiseaseRiskId).First();
|
|
var diseaseRiskLevel = diseaseRiskLevels.Where(o => o.DiseaseRiskLevelId == personDiseaseRisk.DiseaseRiskLevelId).FirstOrDefault();
|
|
|
|
var asbitems = (from questionRegisterItem in await _questionRegisterItemRepository.GetQueryableAsync()
|
|
join questionRegisterAnswer in await _questionRegisterAnswerRrepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionRegisterItemId equals questionRegisterAnswer.QuestionRegisterItemId
|
|
join questionAnswerAsbitem in await _questionAnswerAsbitemRepository.GetQueryableAsync()
|
|
on questionRegisterAnswer.QuestionAnswerId equals questionAnswerAsbitem.QuestionAnswerId
|
|
join asbitem in await _asbitemRepository.GetQueryableAsync()
|
|
on questionAnswerAsbitem.AsbitemId equals asbitem.AsbitemId
|
|
join questionAnswerRiskLevel in await _questionAnswerRiskLevelRepository.GetQueryableAsync()
|
|
on questionAnswerAsbitem.QuestionAnswerId equals questionAnswerRiskLevel.QuestionAnswerId
|
|
where questionRegisterItem.QuestionRegisterId == questionRegister.QuestionRegisterId &&
|
|
questionAnswerRiskLevel.DiseaseRiskLevelId == diseaseRiskLevel.DiseaseRiskLevelId
|
|
orderby asbitem.DisplayOrder
|
|
select asbitem).Distinct().ToList();
|
|
|
|
var questionRegisterDiseaseRiskSingleDto = new QuestionRegisterDiseaseRiskSingleDto()
|
|
{
|
|
DiseaseRiskId = diseaseRisk.DiseaseRiskId,
|
|
DiseaseRiskName = diseaseRisk.DiseaseRiskName,
|
|
DiseaseRiskLevelId = personDiseaseRisk.DiseaseRiskLevelId,
|
|
DiseaseRiskLevelName = personDiseaseRisk.DiseaseRiskLevelName,
|
|
Explain = diseaseRiskLevel.Explain,
|
|
Suggestion = diseaseRiskLevel.Suggestion,
|
|
DiseaseRiskLevels = diseaseRiskLevels.Select(o => new DiseaseRiskLevelDto()
|
|
{
|
|
DiseaseRiskLevelId = o.DiseaseRiskLevelId,
|
|
DiseaseRiskLevelName = o.DiseaseRiskLevelName,
|
|
DisplayOrder = o.DisplayOrder,
|
|
}).ToList(),
|
|
Asbitems = asbitems.Select(o => new QuestionRegisterDiseaseRiskAsbitem()
|
|
{
|
|
AsbitemId = o.AsbitemId,
|
|
AsbitemName = o.AsbitemName,
|
|
DisplayOrder = o.DisplayOrder
|
|
}).ToList()
|
|
};
|
|
|
|
//超重信息
|
|
|
|
var isOverweight = await _personManager.IsOverweight(input.PersonId);
|
|
QuestionAnswer overweightQuestionAnswer = null;
|
|
if (isOverweight)
|
|
{
|
|
var questionAnswerOverweightCodeStr = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "question_answer_overweight_code");
|
|
if (!Guid.TryParse(questionAnswerOverweightCodeStr, out var questionAnswerOverweightCode))
|
|
{
|
|
throw new UserFriendlyException("在系统参数中超重编码维护不正确");
|
|
}
|
|
overweightQuestionAnswer = await _questionAnswerRepository.GetAsync(o => o.QuestionAnswerId == questionAnswerOverweightCode);
|
|
var questionAnswerRiskLevel = await _questionAnswerRiskLevelRepository.FindAsync(o => o.QuestionAnswerId == overweightQuestionAnswer.QuestionAnswerId &&
|
|
o.DiseaseRiskLevelId == diseaseRiskLevel.DiseaseRiskLevelId);
|
|
if (questionAnswerRiskLevel != null)
|
|
{
|
|
var questionAnswerAsbitems = (from questionAnswerAsbitem in await _questionAnswerAsbitemRepository.GetQueryableAsync()
|
|
join asbitem in await _asbitemRepository.GetQueryableAsync()
|
|
on questionAnswerAsbitem.AsbitemId equals asbitem.AsbitemId
|
|
where questionAnswerAsbitem.QuestionAnswerId == overweightQuestionAnswer.QuestionAnswerId
|
|
select asbitem).ToList();
|
|
|
|
foreach (var questionAnswerAsbitem in questionAnswerAsbitems)
|
|
{
|
|
if (!questionRegisterDiseaseRiskSingleDto.Asbitems.Where(o => o.AsbitemId == questionAnswerAsbitem.AsbitemId).Any())
|
|
{
|
|
questionRegisterDiseaseRiskSingleDto.Asbitems.Add(new QuestionRegisterDiseaseRiskAsbitem()
|
|
{
|
|
AsbitemId = questionAnswerAsbitem.AsbitemId,
|
|
AsbitemName = questionAnswerAsbitem.AsbitemName,
|
|
DisplayOrder = questionAnswerAsbitem.DisplayOrder
|
|
});
|
|
}
|
|
}
|
|
|
|
questionRegisterDiseaseRiskSingleDto.Answers.Add(new QuestionRegisterItemResultAnswer()
|
|
{
|
|
Answer = overweightQuestionAnswer.QuestionAnswerName,
|
|
DisplayOrder = overweightQuestionAnswer.DisplayOrder,
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
|
|
var questionRegisterItems = (from questionRegisterItem in await _questionRegisterItemRepository.GetQueryableAsync()
|
|
join questionRegisterAnswer in await _questionRegisterAnswerRrepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionRegisterItemId equals questionRegisterAnswer.QuestionRegisterItemId
|
|
join questionAnswer in await _questionAnswerRepository.GetQueryableAsync()
|
|
on questionRegisterAnswer.QuestionAnswerId equals questionAnswer.QuestionAnswerId
|
|
join question in await _questionRepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionId equals question.QuestionId
|
|
join questionSubjectType in await _questionSubjectTypeRepository.GetQueryableAsync()
|
|
on question.QuestionSubjectTypeId equals questionSubjectType.QuestionSubjectTypeId
|
|
join questionAnswerRiskLevel in await _questionAnswerRiskLevelRepository.GetQueryableAsync()
|
|
on questionAnswer.QuestionAnswerId equals questionAnswerRiskLevel.QuestionAnswerId
|
|
where questionRegisterItem.QuestionRegisterId == questionRegister.QuestionRegisterId &&
|
|
questionAnswerRiskLevel.DiseaseRiskLevelId == diseaseRiskLevel.DiseaseRiskLevelId &&
|
|
questionAnswer.IsNone == 'N'
|
|
orderby questionSubjectType.DisplayOrder
|
|
select new
|
|
{
|
|
questionSubjectType,
|
|
questionRegisterItem,
|
|
questionRegisterAnswer,
|
|
questionAnswer
|
|
}).ToList();
|
|
|
|
foreach (var questionRegisterItem in questionRegisterItems)
|
|
{
|
|
if (questionRegisterItems.Where(o =>
|
|
(o.questionAnswer.PathCode.StartsWith(questionRegisterItem.questionAnswer.PathCode + ".") &&
|
|
questionRegisterItem.questionAnswer.PathCode.Length == 5)).Any())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string answer;
|
|
if (questionRegisterItem.questionAnswer.AnswerResultType == AnswerResultTypeFlag.Choice)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(questionRegisterItem.questionAnswer.Aliases))
|
|
{
|
|
answer = questionRegisterItem.questionAnswer.QuestionAnswerName;
|
|
}
|
|
else
|
|
{
|
|
answer = questionRegisterItem.questionAnswer.Aliases;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answer = questionRegisterItem.questionRegisterAnswer.Content;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(answer))
|
|
{
|
|
continue;
|
|
}
|
|
questionRegisterDiseaseRiskSingleDto.Answers.Add(new QuestionRegisterItemResultAnswer()
|
|
{
|
|
Answer = answer,
|
|
DisplayOrder = questionRegisterItem.questionAnswer.DisplayOrder,
|
|
});
|
|
|
|
}
|
|
|
|
|
|
return questionRegisterDiseaseRiskSingleDto;
|
|
}
|
|
/// <summary>
|
|
/// 创建问卷
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/QuestionRegister/Create")]
|
|
public async Task CreateAsync(QuestionRegisterDto input)
|
|
{
|
|
|
|
var questionRegister = new QuestionRegister();
|
|
questionRegister.PersonId = input.PersonId;
|
|
questionRegister = await _questionRegisterManager.CreateAsync(questionRegister);
|
|
|
|
questionRegister.QuestionRegisterItems = new List<QuestionRegisterItem>();
|
|
|
|
foreach (var questionRegisterItemDto in input.QuestionRegisterItems)
|
|
{
|
|
foreach (var questionRegisterAnswerDto in questionRegisterItemDto.QuestionRegisterAnswers)
|
|
{
|
|
if (questionRegisterAnswerDto.IsSelected == 'Y')
|
|
{
|
|
var questionRegisterItem = questionRegister.QuestionRegisterItems
|
|
.Where(o => o.QuestionId == questionRegisterItemDto.QuestionId).FirstOrDefault();
|
|
if (questionRegisterItem == null)
|
|
{
|
|
questionRegisterItem = new QuestionRegisterItem()
|
|
{
|
|
QuestionRegisterItemId = questionRegisterItemDto.QuestionRegisterItemId,
|
|
QuestionRegisterId = questionRegister.QuestionRegisterId,
|
|
QuestionId = questionRegisterItemDto.QuestionId,
|
|
};
|
|
questionRegister.QuestionRegisterItems.Add(questionRegisterItem);
|
|
// await _questionRegisterItemRepository.InsertAsync(questionRegisterItem);
|
|
}
|
|
var questionRegisterAnswer = new QuestionRegisterAnswer()
|
|
{
|
|
QuestionRegisterAnswerId = GuidGenerator.Create(),
|
|
QuestionRegisterItemId = questionRegisterItem.QuestionRegisterItemId,
|
|
QuestionAnswerId = questionRegisterAnswerDto.QuestionAnswerId,
|
|
Content = questionRegisterAnswerDto.Content,
|
|
|
|
};
|
|
questionRegisterItem.QuestionRegisterAnswers.Add(questionRegisterAnswer);
|
|
|
|
foreach (var childQuestionRegisterAnswer in questionRegisterAnswerDto.Childs)
|
|
{
|
|
if (childQuestionRegisterAnswer.IsSelected == 'Y')
|
|
{
|
|
questionRegisterAnswer = new QuestionRegisterAnswer()
|
|
{
|
|
QuestionRegisterAnswerId = GuidGenerator.Create(),
|
|
QuestionRegisterItemId = questionRegisterItem.QuestionRegisterItemId,
|
|
QuestionAnswerId = childQuestionRegisterAnswer.QuestionAnswerId,
|
|
Content = childQuestionRegisterAnswer.Content,
|
|
|
|
};
|
|
questionRegisterItem.QuestionRegisterAnswers.Add(questionRegisterAnswer);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
await _repository.InsertAsync(questionRegister);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 更新问卷
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/QuestionRegister/Update")]
|
|
public async Task UpdateAsync(QuestionRegisterDto input)
|
|
{
|
|
var questionRegister = await _repository.GetAsync(o => o.QuestionRegisterId == input.QuestionRegisterId);
|
|
var questionRegisterItemList = (from questionRegisterItem in await _questionRegisterItemRepository.GetQueryableAsync()
|
|
join questionRegisterAnswer in await _questionRegisterAnswerRrepository.GetQueryableAsync()
|
|
on questionRegisterItem.QuestionRegisterItemId equals questionRegisterAnswer.QuestionRegisterItemId
|
|
where questionRegisterItem.QuestionRegisterId == questionRegister.QuestionRegisterId
|
|
select new
|
|
{
|
|
questionRegisterItem,
|
|
questionRegisterAnswer,
|
|
}).ToList();
|
|
//删除所有答案和项目
|
|
|
|
var questionRegisterItems = questionRegisterItemList
|
|
.GroupBy(o => o.questionRegisterItem)
|
|
.Select(x => x.FirstOrDefault().questionRegisterItem)
|
|
.ToList();
|
|
foreach (var questionRegisterItem in questionRegisterItems)
|
|
{
|
|
//删除答案
|
|
var questionRegisterAnswers = questionRegisterItemList.
|
|
Where(o => o.questionRegisterItem.QuestionRegisterItemId == questionRegisterItem.QuestionRegisterItemId)
|
|
.Select(x => x.questionRegisterAnswer)
|
|
.ToList();
|
|
await _questionRegisterAnswerRrepository.DeleteManyAsync(questionRegisterAnswers);
|
|
}
|
|
//删除问题
|
|
await _questionRegisterItemRepository.DeleteManyAsync(questionRegisterItems);
|
|
//重新设置
|
|
questionRegister.QuestionRegisterItems = new List<QuestionRegisterItem>();
|
|
|
|
foreach (var questionRegisterItemDto in input.QuestionRegisterItems)
|
|
{
|
|
foreach (var questionRegisterAnswerDto in questionRegisterItemDto.QuestionRegisterAnswers)
|
|
{
|
|
if (questionRegisterAnswerDto.IsSelected == 'Y')
|
|
{
|
|
var questionRegisterItem = questionRegister.QuestionRegisterItems
|
|
.Where(o => o.QuestionId == questionRegisterItemDto.QuestionId).FirstOrDefault();
|
|
if (questionRegisterItem == null)
|
|
{
|
|
questionRegisterItem = new QuestionRegisterItem()
|
|
{
|
|
QuestionRegisterItemId = questionRegisterItemDto.QuestionRegisterItemId,
|
|
QuestionRegisterId = questionRegister.QuestionRegisterId,
|
|
QuestionId = questionRegisterItemDto.QuestionId,
|
|
};
|
|
questionRegister.QuestionRegisterItems.Add(questionRegisterItem);
|
|
// await _questionRegisterItemRepository.InsertAsync(questionRegisterItem);
|
|
}
|
|
var questionRegisterAnswer = new QuestionRegisterAnswer()
|
|
{
|
|
QuestionRegisterAnswerId = GuidGenerator.Create(),
|
|
QuestionRegisterItemId = questionRegisterItem.QuestionRegisterItemId,
|
|
QuestionAnswerId = questionRegisterAnswerDto.QuestionAnswerId,
|
|
Content = questionRegisterAnswerDto.Content,
|
|
|
|
};
|
|
questionRegisterItem.QuestionRegisterAnswers.Add(questionRegisterAnswer);
|
|
|
|
foreach (var childQuestionRegisterAnswer in questionRegisterAnswerDto.Childs)
|
|
{
|
|
if (childQuestionRegisterAnswer.IsSelected == 'Y')
|
|
{
|
|
questionRegisterAnswer = new QuestionRegisterAnswer()
|
|
{
|
|
QuestionRegisterAnswerId = GuidGenerator.Create(),
|
|
QuestionRegisterItemId = questionRegisterItem.QuestionRegisterItemId,
|
|
QuestionAnswerId = childQuestionRegisterAnswer.QuestionAnswerId,
|
|
Content = childQuestionRegisterAnswer.Content,
|
|
|
|
};
|
|
questionRegisterItem.QuestionRegisterAnswers.Add(questionRegisterAnswer);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
await _repository.UpdateAsync(questionRegister);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取问卷所有题目
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <param name="sexId"></param>
|
|
/// <returns></returns>
|
|
private async Task<QuestionRegisterDto> GetBasicDataAsync(PersonIdInputDto input, char sexId)
|
|
{
|
|
var questions = (await _questionRepository.GetListAsync(o => o.IsActive == 'Y')).OrderBy(o => o.DisplayOrder);
|
|
|
|
var questionAnswers = await _questionAnswerRepository.GetListAsync();
|
|
var questionRegisterDto = new QuestionRegisterDto()
|
|
{
|
|
QuestionRegisterId = GuidGenerator.Create(),
|
|
PersonId = input.PersonId,
|
|
};
|
|
//问卷
|
|
foreach (var question in questions)
|
|
{
|
|
bool isDisplay = false;
|
|
if (question.ForSexId == ForSexFlag.All)
|
|
{
|
|
isDisplay = true;
|
|
}
|
|
else
|
|
{
|
|
if (question.ForSexId == sexId)
|
|
{
|
|
isDisplay = true;
|
|
}
|
|
}
|
|
|
|
if (isDisplay)
|
|
{
|
|
|
|
var questionRegisterItem = new QuestionRegisterItemDto()
|
|
{
|
|
QuestionRegisterItemId = GuidGenerator.Create(),
|
|
QuestionId = question.QuestionId,
|
|
QuestionName = question.QuestionName,
|
|
AnswerType = question.AnswerType,
|
|
DisplayOrder = question.DisplayOrder,
|
|
ParentId = question.ParentId,
|
|
PathCode = question.PathCode,
|
|
|
|
};
|
|
//一级答案
|
|
var firstLevelQuestionAnswers = questionAnswers.Where(o => o.QuestionId == question.QuestionId &&
|
|
o.PathCode.Length == 5).OrderBy(o => o.DisplayOrder).ToList();
|
|
foreach (var questionAnswer in firstLevelQuestionAnswers)
|
|
{
|
|
var questionRegisterAnswer = new QuestionRegisterAnswerDto()
|
|
{
|
|
QuestionRegisterAnswerId = GuidGenerator.Create(),
|
|
QuestionId = question.QuestionId,
|
|
QuestionAnswerId = questionAnswer.QuestionAnswerId,
|
|
QuestionAnswerName = questionAnswer.QuestionAnswerName,
|
|
ChildAnswerType = questionAnswer.ChildAnswerType,
|
|
AnswerResultType = questionAnswer.AnswerResultType,
|
|
IsSelected = 'N',
|
|
ChildAnswerTitle = questionAnswer.ChildAnswerTitle,
|
|
IsNone = questionAnswer.IsNone,
|
|
DisplayOrder = questionAnswer.DisplayOrder,
|
|
ParentId = questionAnswer.ParentId,
|
|
PathCode = questionAnswer.PathCode,
|
|
|
|
};
|
|
//二级答案
|
|
var childQuestionAnswers = questionAnswers.Where(o =>
|
|
o.ParentId == questionAnswer.QuestionAnswerId).OrderBy(o => o.DisplayOrder).ToList();
|
|
foreach (var ChilduestionAnswer in childQuestionAnswers)
|
|
{
|
|
var childQuestionRegisterAnswer = new QuestionRegisterAnswerDto()
|
|
{
|
|
QuestionRegisterAnswerId = GuidGenerator.Create(),
|
|
QuestionId = question.QuestionId,
|
|
QuestionAnswerId = ChilduestionAnswer.QuestionAnswerId,
|
|
QuestionAnswerName = ChilduestionAnswer.QuestionAnswerName,
|
|
ChildAnswerType = ChilduestionAnswer.ChildAnswerType,
|
|
AnswerResultType = ChilduestionAnswer.AnswerResultType,
|
|
IsSelected = 'N',
|
|
ChildAnswerTitle = questionAnswer.ChildAnswerTitle,
|
|
IsNone = questionAnswer.IsNone,
|
|
DisplayOrder = ChilduestionAnswer.DisplayOrder,
|
|
ParentId = ChilduestionAnswer.ParentId,
|
|
PathCode = ChilduestionAnswer.PathCode,
|
|
|
|
|
|
};
|
|
questionRegisterAnswer.Childs.Add(childQuestionRegisterAnswer);
|
|
}
|
|
questionRegisterItem.QuestionRegisterAnswers.Add(questionRegisterAnswer);
|
|
}
|
|
questionRegisterDto.QuestionRegisterItems.Add(questionRegisterItem);
|
|
}
|
|
|
|
}
|
|
|
|
return questionRegisterDto;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|