WebPeis0523/src/Shentun.WebPeis.Application/QuestionRegisters/QuestionRegisterAppService.cs

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;
        }



    }
}