WingCloudServer/src/VitalMixtureService/DBService/Service/ContractRecordDBService.cs

using MongoDB.Driver;
using VitalService.Entities;
using VitalService.Request;
using VitalService.Common;
using WingServerCommon.Mapper;
using WingInterfaceLibrary.Interface.DBVitalInterface;
using WingInterfaceLibrary.Request.DBVitalRequest;
using WingInterfaceLibrary.DTO.Vital;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Enum.VitalEnum;
using WingServerCommon.Log;

namespace VitalService.Service
{
    /// <summary>
    /// 合约记录数据服务
    /// </summary>
    public partial class VitalDatabaseService : IVitalContractRecordDBService
    {
        private FindOptions<ContractRecordEntity> listProjection = new FindOptions<ContractRecordEntity>
        {
            Projection = Builders<ContractRecordEntity>.Projection
            .Exclude(f => f.ContractedFileUrl)
            .Exclude(f => f.Photos)
        };
        /// <summary>
        /// 创建合约记录数据
        /// </summary>
        /// <param name="request">创建请求</param>
        /// <returns></returns>
        public async Task<string> CreateContractRecordAsync(CreateContractRecordDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            if (string.IsNullOrWhiteSpace(request.ContractRecordNo))
            {
                request.ContractRecordNo = NumberGenerator.GenerateNumber();
            }
            var entity = request.MappingTo<ContractRecordEntity>();
            var info = await SetRequestCreatedFrom(entity, request.OperationDoctor);
            if (info.team != null)
            {
                entity.ContractedTeam = info.team.Code;
                if (string.IsNullOrWhiteSpace(entity.ContractedDoctor) && !string.IsNullOrWhiteSpace(info.team.Principal))
                {
                    entity.ContractedDoctor = info.team.Principal;
                }
            }
            var contactRecordCode = await _contractRecordDBRepository.InsertOneAsync(entity);

            await UpdatePatientContactStateAsync(entity.ContractedPatient);
            return contactRecordCode;
        }

        private async Task UpdatePatientContactStateAsync(string cardNo)
        {
            try
            {
                var contractRecordFilter = Builders<ContractRecordEntity>.Filter.Where(x => x.IsDelete == false && x.ContractedPatient == cardNo);
                var contractRecordList = await _contractRecordDBRepository.FindAllAsync(contractRecordFilter);
                if (contractRecordList?.Any() ?? false)
                {
                    var contractEntity = contractRecordList.OrderByDescending(x => x.CreateTime).FirstOrDefault();

                    var patientFilter = Builders<PatientEntity>.Filter.Eq(p => p.Code, cardNo);
                    var patientEntity = await _patientDBRepository.FindOneAsync(patientFilter);
                    if (patientEntity != null)
                    {
                        var patientUpdates = Builders<PatientEntity>.Update.Set(f => f.ContractState, contractEntity.ContractState);
                        if (contractEntity.ContractState == ContractStateEnum.Signed)
                        {
                            patientUpdates = patientUpdates.Set(f => f.ServiceStartDate, contractEntity.ServiceStartDate)
                                                        .Set(f => f.ServiceEndDate, contractEntity.ServiceEndDate);
                        }
                        await _patientDBRepository.UpdateOneAsync(patientFilter, patientUpdates, false);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"ContractRecordDBService UpdatePatientContactStateAsync error, ex:{ex}");
            }
        }

        /// <summary>
        /// 根据编码获取合约记录数据
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<ContractRecordDTO> GetContractRecordDetailAsync(GetContractRecordDBRequest request)
        {
            var filter = Builders<ContractRecordEntity>.Filter.Eq(x => x.Code, request.Code);
            filter = await AddPermissionFilter(filter, request.OperationDoctor);
            var result = await _contractRecordDBRepository.FindOneAsync(filter);
            return await ConvertToDTO(result, request.OperationDoctor);
        }

        /// <summary>
        /// 根据关键字段获取合约记录数据
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<ContractRecordDTO> GetContractRecordDetailByKeyAsync(GetContractRecordByKeyDBRequest request)
        {
            var filter = Builders<ContractRecordEntity>.Filter.Eq(request.Key, request.Value);
            filter = await AddPermissionFilter(filter, request.OperationDoctor);
            var result = await _contractRecordDBRepository.FindOneAsync(filter);
            return await ConvertToDTO(result, request.OperationDoctor);
        }

        /// <summary>
        /// 获取合约记录数据分页
        /// </summary>
        /// <param name="request">分页请求</param>
        /// <returns></returns>
        public async Task<PageCollection<ContractRecordDTO>> GetContractRecordPageAsync(DBPageRequest request)
        {
            var filter = await _contractRecordDBRepository.GetPageFilter(request);
            filter = await AddPermissionFilter(filter, request.OperationDoctor);
            var pageFilter = new DBPageRequest<ContractRecordEntity>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Filter = filter,
                Sort = Builders<ContractRecordEntity>.Sort.Descending(x => x.CreateTime)
            };
            var result = await _contractRecordDBRepository.GetPages(pageFilter, listProjection);
            return await ConvertToDTOPage(result, request.OperationDoctor);
        }


        /// <summary>
        /// 删除合约记录数据
        /// </summary>
        /// <param name="request">删除请求</param>
        /// <returns></returns>
        public async Task<bool> RemoveContractRecordAsync(RemoveContractRecordDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            return await _contractRecordDBRepository.DeleteOneAsync("Code", request.Code);
        }

        /// <summary>
        /// 删除多个合约记录数据
        /// </summary>
        /// <param name="request">删除请求</param>
        /// <returns></returns>
        public async Task<long> RemoveContractRecordListAsync(RemoveContractRecordListDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            var filter = new List<(string key, string val)>();
            foreach (var code in request.Codes)
            {
                filter.Add(("Code", code));
            }
            return await _contractRecordDBRepository.DeleteAllAsync(filter);
        }

        /// <summary>
        /// 获取合约记录数据列表
        /// </summary>
        /// <param name="request">列表请求</param>
        /// <returns></returns>
        public async Task<List<ContractRecordDTO>> GetContractRecordListAsync(GetContractRecordListDBRequest request)
        {
            var filter = Builders<ContractRecordEntity>.Filter.In(f => f.Code, request.Codes);
            filter = await AddPermissionFilter(filter, request.OperationDoctor);
            var result = await _contractRecordDBRepository.FindAllAsync(filter, listProjection);
            return await ConvertToDTOList(result, request.OperationDoctor);
        }

        /// <summary>
        /// 根据关键字段获取合约记录数据列表
        /// </summary>
        /// <param name="request">列表请求</param>
        /// <returns></returns>
        public async Task<List<ContractRecordDTO>> GetContractRecordListByKeyAsync(GetContractRecordListByKeyDBRequest request)
        {
            var filter = Builders<ContractRecordEntity>.Filter.Eq(request.Key, request.Value);
            filter = await AddPermissionFilter(filter, request.OperationDoctor);
            var result = await _contractRecordDBRepository.FindAllAsync(filter, listProjection);
            return await ConvertToDTOList(result, request.OperationDoctor);
        }

        /// <summary>
        /// 查询医生最近签约记录
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<ContractRecordDTO> GetDoctorContractRecordDBAsync(GetDoctorContractRecordDBRequest request)
        {
            var createdDoctor = request.CreatedDoctor;
            var filter = Builders<ContractRecordEntity>.Filter.Where(x => x.CreatedDoctor == createdDoctor && (x.ContractState == ContractStateEnum.Signed || x.ContractState == ContractStateEnum.Expired || x.ContractState == ContractStateEnum.Cancelled));
            var entities = await _contractRecordDBRepository.FindAllAsync(filter);

            var entity = entities?.OrderByDescending(x => x.CreateTime)?.FirstOrDefault();
            return await ConvertToDTO(entity, request.OperationDoctor);
        }

        /// <summary>
        /// 查询续签关联的签约记录
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<List<ContractRecordDTO>> GetRenewalContractDBAsync(GetRenewalContractDBRequest request)
        {
            var renewalContractCode = request.RenewalContractCode;
            var filter = Builders<ContractRecordEntity>.Filter.Where(x => x.RenewalContractCode == renewalContractCode);
            var entities = await _contractRecordDBRepository.FindAllAsync(filter);
            if (entities?.Any() ?? false)
            {
                return await ConvertToDTOList(entities, request.OperationDoctor);
            }
            return null;
        }

        /// <summary>
        /// 更新合约记录数据
        /// </summary>
        /// <param name="request">更新请求</param>
        /// <returns></returns>
        public async Task<bool> UpdateContractRecordAsync(UpdateContractRecordDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            var filter = Builders<ContractRecordEntity>.Filter.Eq(f => f.Code, request.Code);
            var updates = new List<UpdateDefinition<ContractRecordEntity>>();
            if (request.ContractRecordNo != "-1")
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractRecordNo, request.ContractRecordNo));
            }
            if (request.ContractState != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractState, request.ContractState));
            }
            if (request.ContractIsValid != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractIsValid, request.ContractIsValid));
            }
            if (request.ContractedDoctor != "-1")
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractIsValid, request.ContractIsValid));
            }
            if (request.ContractedPatient != "-1")
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractedPatient, request.ContractedPatient));
            }
            if (request.ContractedFileUrl != "-1")
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractedFileUrl, request.ContractedFileUrl));
            }
            if (request.ContractedFileUrl != "-1")
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractedFileUrl, request.ContractedFileUrl));
            }
            if (request.ContractedTime != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractedTime, request.ContractedTime));
            }
            if (request.AuditState != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.AuditState, request.AuditState));
            }
            if (request.ServicePacks != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ServicePacks, request.ServicePacks));
            }
            if (request.ServiceStartDate != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ServiceStartDate, request.ServiceStartDate));
            }
            if (request.ServiceEndDate != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ServiceEndDate, request.ServiceEndDate));
            }
            if (request.Photos != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.Photos, request.Photos));
            }
            if (request.Notes != "-1")
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.Notes, request.Notes));
            }
            var update = Builders<ContractRecordEntity>.Update.Combine(updates);
            var result = await _contractRecordDBRepository.UpdateOneAsync(filter, update) > 0;

            if (request.ContractState != null && result)
            {
                var contractFilter = Builders<ContractRecordEntity>.Filter.Eq(x => x.Code, request.Code);
                var contractEntity = await _contractRecordDBRepository.FindOneAsync(contractFilter);
                if (contractEntity != null && !string.IsNullOrWhiteSpace(contractEntity.ContractedPatient))
                {
                    await UpdatePatientContactStateAsync(contractEntity.ContractedPatient);
                }
            }
            return result;
        }

        private async Task<ContractRecordDTO> ConvertToDTO(ContractRecordEntity entity, string operationDoctor)
        {
            if (entity == null) return null;
            var record = entity?.MappingTo<ContractRecordDTO>();
            if (!string.IsNullOrWhiteSpace(entity.ContractedDoctor))
            {
                var filter = Builders<UserEntity>.Filter.Eq(f => f.Code, entity.ContractedDoctor);
                var userInfo = await _userDBRepository.FindOneAsync(filter);
                record.ContractedDoctorCode = userInfo?.Code;
                record.ContractedDoctor = !string.IsNullOrWhiteSpace(userInfo?.RealName) ? userInfo?.RealName : userInfo?.UserName;
                if (!string.IsNullOrWhiteSpace(userInfo?.OrganizationCode))
                {
                    var filterOrg = Builders<OrganizationEntity>.Filter.Eq(f => f.Code, userInfo.OrganizationCode);
                    var orgInfo = await _organizationDBRepository.FindOneAsync(filterOrg);
                    record.OrganizationName = orgInfo?.OrganizationName;
                }
            }
            if (!string.IsNullOrWhiteSpace(entity.ContractedTeam))
            {
                var filter = Builders<TeamEntity>.Filter.Eq(f => f.Code, entity.ContractedTeam);
                var teamInfo = await _teamDBRepository.FindOneAsync(filter);
                record.ContractedTeam = teamInfo?.TeamName;
                record.ContractedTeamCode = teamInfo?.Code;
                record.SupervisingPhysician = teamInfo?.Principal;
            }
            if (entity.ServicePacks != null && entity.ServicePacks.Count > 0)
            {
                var packRequest = new GetServicePackListDBRequest { Codes = entity.ServicePacks.ToList(), OperationDoctor = operationDoctor };
                record.ServicePacks = await GetServicePackListAsync(packRequest);
            }
            if (!string.IsNullOrWhiteSpace(entity.ContractedPatient))
            {
                var filter = Builders<PatientEntity>.Filter.Eq(f => f.Code, entity.ContractedPatient);
                var patientInfo = await _patientDBRepository.FindOneAsync(filter);
                var dto = await ConvertToDTO(patientInfo);
                if (dto != null)
                {
                    record.PatientName = dto.PatientName;
                    record.Birthday = dto.Birthday;
                    record.CardNo = dto.CardNo;
                    record.PatientGender = dto.PatientGender;
                    record.PatientAddress = dto.PatientAddress;
                    record.Nationality = dto.Nationality;
                    record.Phone = dto.Phone;
                    if (dto.CrowdLabels != null && dto.CrowdLabels.Count > 0)
                    {
                        record.CrowdLabels = dto.CrowdLabels;
                        record.LabelNames = dto.LabelNames;
                    }
                    else
                    {
                        record.CrowdLabels = new List<string>();
                    }
                }
            }
            return record;
        }

        private async Task<List<ContractRecordDTO>> ConvertToDTOList(List<ContractRecordEntity> entitys, string operationDoctor)
        {
            var userCodes = entitys.Select(f => f.ContractedDoctor).Distinct();
            var filterUsers = Builders<UserEntity>.Filter.In(f => f.Code, userCodes);
            var usersInfo = await _userDBRepository.FindAllAsync(filterUsers);

            var orgCodes = usersInfo.Select(u => u.OrganizationCode).Distinct();
            var filterOrgs = Builders<OrganizationEntity>.Filter.In(f => f.Code, orgCodes);
            var orgsInfo = await _organizationDBRepository.FindAllAsync(filterOrgs);

            var teamCodes = entitys.Select(f => f.ContractedTeam).Distinct();
            var filterTeams = Builders<TeamEntity>.Filter.In(f => f.Code, teamCodes);
            var teamsInfo = await _teamDBRepository.FindAllAsync(filterTeams);

            var packsCodes = entitys.SelectMany(f => f.ServicePacks ?? new List<string>()).Distinct();
            var filterPacks = new GetServicePackListDBRequest { Codes = packsCodes.ToList(), OperationDoctor = operationDoctor };
            var packsInfo = await GetServicePackListAsync(filterPacks);

            var patientCodes = entitys.Select(f => f.ContractedPatient).Distinct();
            var filterPatients = Builders<PatientEntity>.Filter.In(f => f.Code, patientCodes);
            var patientsInfo = await _patientDBRepository.FindAllAsync(filterPatients);

            var filterLabel = Builders<LabelEntity>.Filter.In(f => f.LabelTypeKey, new List<string> { "RQFL", "CJJB", "TSZG" });
            var labels = await _labelDBRepository.FindAllAsync(filterLabel);

            var resultList = new List<ContractRecordDTO>();
            foreach (var entity in entitys)
            {
                if (entity == null)
                {
                    continue;
                }
                var record = entity.MappingTo<ContractRecordDTO>();
                record.ContractedFileUrl = " ";
                record.Photos = new List<string>();
                if (!string.IsNullOrWhiteSpace(entity.ContractedDoctor))
                {
                    var userInfo = usersInfo.FirstOrDefault(w => w.Code == entity.ContractedDoctor);
                    record.ContractedDoctor = userInfo?.Code;
                    record.ContractedDoctor = !string.IsNullOrWhiteSpace(userInfo?.RealName) ? userInfo?.RealName : userInfo?.UserName;
                    if (!string.IsNullOrWhiteSpace(userInfo.OrganizationCode))
                    {
                        var orgInfo = orgsInfo.FirstOrDefault(w => w.Code == userInfo.OrganizationCode);
                        record.OrganizationName = orgInfo?.OrganizationName;
                    }
                }
                if (!string.IsNullOrWhiteSpace(entity.ContractedTeam))
                {
                    var teamInfo = teamsInfo.FirstOrDefault(w => w.Code == entity.ContractedTeam);
                    record.ContractedTeam = teamInfo?.TeamName;
                    record.ContractedTeamCode = teamInfo?.Code;
                    record.SupervisingPhysician = teamInfo?.Principal;
                }
                if (entity.ServicePacks != null && entity.ServicePacks.Count > 0)
                {
                    var packInfo = packsInfo.Where(w => entity.ServicePacks != null && entity.ServicePacks.Count > 0 && entity.ServicePacks.Contains(w.Code)).ToList();
                    record.ServicePacks = packInfo;
                }
                if (!string.IsNullOrWhiteSpace(entity.ContractedPatient))
                {
                    var patientInfo = patientsInfo.FirstOrDefault(w => w.Code == entity.ContractedPatient);
                    if (patientInfo != null)
                    {
                        var dto = await ConvertToDTO(patientInfo);
                        if (dto != null)
                        {
                            record.PatientName = dto.PatientName;
                            record.Birthday = dto.Birthday;
                            record.CardNo = dto.CardNo;
                            record.PatientGender = dto.PatientGender;
                            record.PatientAddress = dto.PatientAddress;
                            record.Nationality = dto.Nationality;
                            record.Phone = dto.Phone;
                            record.CrowdLabels = dto.CrowdLabels;
                            record.LabelNames = dto.LabelNames;
                        }
                    }
                }
                resultList.Add(record);
            }
            return resultList;
        }

        private async Task<PageCollection<ContractRecordDTO>> ConvertToDTOPage(PageCollection<ContractRecordEntity> entitys, string operationDoctor)
        {
            var resultPage = new PageCollection<ContractRecordDTO>
            {
                DataCount = entitys.DataCount,
                CurrentPage = entitys.CurrentPage,
                PageSize = entitys.PageSize,
                PageData = await ConvertToDTOList(entitys.PageData, operationDoctor)
            };
            return resultPage;
        }

        public async Task<ContractRecordDTO> GetPatientLastContractRecordAsync(GetPatientLastContractRecordDBRequest request)
        {
            var filter = Builders<ContractRecordEntity>.Filter.Where(f => f.ContractedPatient == request.PatientCode);
            filter = await AddPermissionFilter(filter, request.OperationDoctor);
            var result = await _contractRecordDBRepository.FindOneAsync(filter, new FindOptions<ContractRecordEntity> { Sort = Builders<ContractRecordEntity>.Sort.Descending(f => f.CreateTime).Descending(f => f.ContractState) });
            return await ConvertToDTO(result, request.OperationDoctor);
        }

        /// <summary>
        /// 更新签约记录状态
        /// </summary>
        /// <param name="request">update request</param>
        /// <returns></returns>
        public async Task<bool> UpdateContractRecordStateAsync(UpdateContractRecordStateDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            var filter = Builders<ContractRecordEntity>.Filter.Eq(f => f.Code, request.Code);
            var updates = new List<UpdateDefinition<ContractRecordEntity>>();
            if (request.ContractState != null)
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.ContractState, request.ContractState));
            }
            if (!string.IsNullOrWhiteSpace(request.Reason))
            {
                updates.Add(Builders<ContractRecordEntity>.Update.Set(f => f.Reason, request.Reason));
            }
            var update = Builders<ContractRecordEntity>.Update.Combine(updates);
            var result = await _contractRecordDBRepository.UpdateOneAsync(filter, update) > 0;
            if (result)
            {
                var contractFilter = Builders<ContractRecordEntity>.Filter.Eq(x => x.Code, request.Code);
                var contractEntity = await _contractRecordDBRepository.FindOneAsync(contractFilter);
                if (contractEntity != null && !string.IsNullOrWhiteSpace(contractEntity.ContractedPatient))
                {
                    await UpdatePatientContactStateAsync(contractEntity.ContractedPatient);
                }
            }
            return result;
        }
    }
}