peis/src/Shentun.Peis.Application/ImportLisResults/ImportLisResultAppService.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Shentun.Peis.DiagnosisFunctions;
using Shentun.Peis.Models;
using Shentun.Peis.PlugIns;
using Shentun.Peis.RegisterCheckItems;
using Shentun.Peis.RegisterChecks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Guids;
using Volo.Abp.Identity;
using Volo.Abp.Users;

namespace Shentun.Peis.ImportLisResults
{
    public class ImportLisResultAppService : ApplicationService
    {
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<ReferenceRange, Guid> _referenceRangeRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private readonly IRepository<LisRequest, Guid> _lisRequestRepository;
        private readonly IRepository<RegisterCheckSummary, Guid> _registerCheckSummaryRepository;
        private readonly IRepository<RegisterCheckSuggestion, Guid> _registerCheckSuggestionRepository;
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly RegisterCheckManager _registerCheckManager;
        private readonly RegisterCheckItemManager _registerCheckItemManager;
        private readonly CacheService _cacheService;
        private readonly IGuidGenerator _guidGenerator;
        private readonly IConfiguration _configuration;
        private readonly ICurrentUser _currentUser;
        private readonly IRepository<UserItemType> _userItemTypeRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly DiagnosisFunctionAppService _diagnosisFunctionAppService;
        public ImportLisResultAppService(IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
             IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<ReferenceRange, Guid> referenceRangeRepository,
             IRepository<RegisterCheckSummary, Guid> registerCheckSummaryRepository,
            IRepository<RegisterCheckSuggestion, Guid> registerCheckSuggestionRepository,
            IRepository<IdentityUser, Guid> userRepository,
            RegisterCheckManager registerCheckManager,
            RegisterCheckItemManager registerCheckItemManager,
            CacheService cacheService,
            IGuidGenerator guidGenerator,
            IConfiguration configuration,
            ICurrentUser currentUser,
            IRepository<UserItemType> userItemTypeRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
            IRepository<LisRequest, Guid> lisRequestRepository,
             DiagnosisFunctionAppService diagnosisFunctionAppService)
        {
            _registerCheckRepository = registerCheckRepository;
            _userRepository = userRepository;
            _registerCheckManager = registerCheckManager;
            _patientRegisterRepository = patientRegisterRepository;
            _referenceRangeRepository = referenceRangeRepository;
            _registerCheckItemRepository = registerCheckItemRepository;
            _registerCheckSummaryRepository = registerCheckSummaryRepository;
            _registerCheckSuggestionRepository = registerCheckSuggestionRepository;
            _registerCheckItemManager = registerCheckItemManager;
            _cacheService = cacheService;
            _guidGenerator = guidGenerator;
            _configuration = configuration;
            _currentUser = currentUser;
            _userItemTypeRepository = userItemTypeRepository;
            _asbitemRepository = asbitemRepository;
            _registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            _lisRequestRepository = lisRequestRepository;
            _diagnosisFunctionAppService = diagnosisFunctionAppService;
        }
        [HttpGet("api/app/ImportLisResult/ImportResult")]
        public async Task ImportResultAsync(List<LisResult> input)
        {
            //设置结果

            var list = (from registerCheck in await _registerCheckRepository.GetQueryableAsync()
                        join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                        join registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckItem.RegisterCheckId
                        join lisRequest in await _lisRequestRepository.GetQueryableAsync()
                        on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                        where input.Select(o => o.LisRequestNo).ToList().Contains(lisRequest.LisRequestNo)
                        select new
                        {
                            registerCheck,
                            registerCheckAsbitem,
                            registerCheckItem,
                            lisRequest,
                        }).ToList();

            var lisRequestNos = input.Select(o => o.LisRequestNo).Distinct().ToList();
            foreach(var inputItem in input)
            {
                var lisRequestItem = list.Where(o=>o.lisRequest.LisRequestNo == inputItem.LisRequestNo 
                             && o.registerCheckItem.ItemId == new Guid(inputItem.ItemId)).FirstOrDefault();
                if(lisRequestItem == null)
                {
                    continue;
                }
                var itemSource = new RegisterCheckItem()
                {
                    Result = inputItem.Result,
                    ReferenceRangeValue = inputItem.ReferenceRangeValue,
                    Unit = inputItem.Unit,
                    CriticalRangeValue = inputItem.CriticalRangeValue
                };

                await _registerCheckItemManager.UpdateRegisterCheckItemAsync(itemSource, lisRequestItem.registerCheckItem);
                await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem);

            }
            //生成小结
            var registerChecks = list.Select(o=>o.registerCheck).Distinct().ToList();
            foreach(var registerCheck in registerChecks)
            {
                var getDiagnosisResultRequestDto = new GetDiagnosisResultRequestDto()
                {
                    RegisterCheckId = registerCheck.Id,
                    Items = list.Where(o=>o.registerCheck.Id == registerCheck.Id)
                    .Select(o=>new GetDiagnosisResultRequest_Item()
                    {
                        ItemId = o.registerCheckItem.ItemId,
                        Result = o.registerCheckItem.Result,
                    }).ToList()
                };
            }
            
            //保存小结

        }
    }
}