WingLiveConsultationService/LiveConsultationService.Emergency.cs

using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.LiveConsultation;
using WingServerCommon.Service;
using WingInterfaceLibrary.LiveConsultation.Consultation;
using WingInterfaceLibrary.DB.Request;
using WingInterfaceLibrary.DTO.Consultation;
using WingInterfaceLibrary.DTO.Schedule;
using WingInterfaceLibrary.DTO.Device;
using WingServerCommon.Interfaces.Cache;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.DTO.User;
using WingInterfaceLibrary.Request.DBRequest;
using WingInterfaceLibrary.Request.Authentication;
using WingServerCommon.Mapper;
using WingInterfaceLibrary.Internal.Request;
using Newtonsoft.Json.Linq;
using WingInterfaceLibrary.Request.Patient;

namespace WingLiveConsultationService
{
    partial class LiveConsultationService : JsonRpcService, ILiveConsultationService
    {
        /// <summary>
        /// 获取即时会诊配置
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetEmergencySettingResult> GetEmergencySettingAsync(GetEmergencySettingRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userDTO = await _userDBService.FindUserByCodeAsync(userCode);

            var result = new GetEmergencySettingResult { EmergencyNeedFill = false };
            if (string.IsNullOrWhiteSpace(userDTO.RootOrganizationCode))
            {
                return result;
            }
            var organizationCache = CacheMaintenance.Instance.Get<IOrganizationsManager>().Get(userDTO.RootOrganizationCode);
            if (organizationCache == null || string.IsNullOrWhiteSpace(organizationCache.Code) || !organizationCache.EmergencyNeedFill)
            {
                return result;
            }
            result.OrganizationCode = organizationCache.Code;
            result.EmergencyNeedFill = organizationCache.EmergencyNeedFill;
            result.EmergencySettingVersion = organizationCache.ExamSettingVersion;
            result.EmergencySettingJson = organizationCache.EmergencySettingJson;
            if (string.IsNullOrWhiteSpace(result.EmergencySettingJson))
            {
                var json = File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resource", "Consultation", "EmergencyInfo.json"));
                JObject o = JObject.Parse(json);
                result.EmergencySettingVersion = o["General"]["Version"].ToString();
                o.Remove("General");
                result.EmergencySettingJson = o.ToString();
            }
            return result;
        }

        /// <summary>
        /// 获取急诊订单号
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<string> GetEmergencyOrderAsync(GetEmergencyOrderRequest request)
        {
            var deviceInfo = await _deviceDBService.FindDeviceInfoBySerialNumberAsync(request.EmergencySerialNumber);
            if (deviceInfo != null)
            {
                return await _consultationRecordDBService.GetEmergencyOrderAsync(new GetEmergencyOrderDBRequest
                {
                    EmergencyDeviceCode = deviceInfo.DeviceCode
                });
            }
            ThrowRpcException(CustomerRpcCode.DeviceNotExist, "DeviceNotExist");
            return string.Empty;
        }

        /// <summary>
        /// 急诊申请
        /// </summary>
        public async Task<string> ApplyEmergencyTreatment(ApplyEmergencyTreatmentRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var organizationRequest = new GetOrganizationDBRequest { OrganizationCode = userDTO.RootOrganizationCode };
            var organization = await _organizationDBService.GetOrganizationDetailAsync(organizationRequest);

            DeviceInfoDTO device = null;
            UserDTO expertDTO = null;
            if (!string.IsNullOrWhiteSpace(request.DeviceUniqueCode))
            {
                device = await _deviceDBService.FindDeviceInfoBySerialNumberAsync(request.DeviceUniqueCode);
                var emergencyDoctors = await GetEmergencyDoctorsAsync(userDTO.RootOrganizationCode);
                if (!emergencyDoctors.Any())
                {
                    ThrowRpcException(CustomerRpcCode.EmergencyDoctorsIsEmpty, "Emergency Doctors Is Empty");
                }
            }
            else
            {
                if (string.IsNullOrWhiteSpace(request.DeviceCode))
                {
                    ThrowRpcException(CustomerRpcCode.DeviceCodeIsEmpty, "DeviceCodeIsEmpty");
                }
                device = await _deviceDBService.FindDeviceInfoByCodeAsync(request.DeviceCode);
                if (string.IsNullOrWhiteSpace(request.ExpertCode))
                {
                    ThrowRpcException(CustomerRpcCode.ExpertCodeIsEmpty, "ExportCodeIsEmpty");
                }
                expertDTO = await _userDBService.FindUserByCodeAsync(request.ExpertCode);
                if (expertDTO == null || string.IsNullOrWhiteSpace(expertDTO.UserCode))
                {
                    ThrowRpcException(CustomerRpcCode.ExpertNotExisted, "ExpertNotExisted");
                }
                var expertTokens = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => x.ClientId == expertDTO.UserCode);
                if (expertTokens == null || !expertTokens.Any(x => x.IsOnline))
                {
                    ThrowRpcException(CustomerRpcCode.ExpertNotOnline, "ExpertNotOnline");
                }
            }
            if (device == null || string.IsNullOrWhiteSpace(device.DeviceCode))
            {
                ThrowRpcException(CustomerRpcCode.EmergencyDeviceNotExisted, "EmergencyDeviceNotExisted");
            }
            var deviceTokens = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => x.ClientId == device.DeviceCode);
            if (deviceTokens == null || !deviceTokens.Any(x => x.IsOnline))
            {
                ThrowRpcException(CustomerRpcCode.DeviceNotOnline, "DeviceNotOnline");
            }
            var emergencyCode = await _consultationRecordDBService.GetEmergencyOrderAsync(new GetEmergencyOrderDBRequest
            {
                EmergencyDeviceCode = device.DeviceCode
            });
            if (string.IsNullOrWhiteSpace(emergencyCode))
            {
                ThrowRpcException(CustomerRpcCode.EmergencyCodeError, "EmergencyCodeError");
            }

            var dbRequest = new CreateConsultationRecordDBRequest();
            dbRequest.Data = new ConsultationDetailDTO();
            var applyUserCode = userDTO.UserCode;
            var applyUserInfoDTO = await _userDBService.FindUserByCodeAsync(applyUserCode);
            dbRequest.Data.ApplyUserCode = applyUserCode;
            if (applyUserInfoDTO.OrganizationCode != applyUserInfoDTO.RootOrganizationCode)
            {
                dbRequest.Data.ApplyDepartmentCode = applyUserInfoDTO.OrganizationCode;
            }
            else
            {
                dbRequest.Data.ApplyDepartmentCode = "";
            }
            var startTime = DateTime.UtcNow;
            var endTime = startTime.AddHours(2);
            dbRequest.Data.ApplyOrganizationCode = applyUserInfoDTO.RootOrganizationCode;
            dbRequest.Data.ConsultationTime = startTime;
            dbRequest.Data.ConsultationTimeEnd = endTime;
            dbRequest.Data.OperateUserCode = userDTO.UserCode;
            dbRequest.Data.DeviceCode = device.DeviceCode;
            dbRequest.Data.CreateTime = DateTime.UtcNow;
            dbRequest.Data.ConsultationStatus = TransactionStatusEnum.ToStart;
            dbRequest.Data.IsEmergency = true;  //是否急诊标识
            dbRequest.Data.EmergencyCode = emergencyCode;//急诊code
            dbRequest.Data.ScanUserCode = applyUserCode;
            dbRequest.Data.ScanUserName = applyUserInfoDTO.DisplayName;
            if (expertDTO != null)
            {
                dbRequest.Data.ExpertUserCode = expertDTO.UserCode;
                dbRequest.Data.ExpertOrganizationCode = expertDTO.RootOrganizationCode;
                dbRequest.Data.ExpertDepartmentCode = string.Empty;
                if (expertDTO.OrganizationCode != expertDTO.RootOrganizationCode)
                {
                    dbRequest.Data.ExpertDepartmentCode = expertDTO.OrganizationCode;
                }
                await _userDBService.UpdateEmergencyInfoDBAsync(new UpdateEmergencyInfoDBRequest { UserCode = userCode, EmergencyDeviceCode = device.DeviceCode, EmergencyExpertCode = expertDTO.UserCode });
            }
            if (!string.IsNullOrWhiteSpace(request.PatientCode))
            {
                dbRequest.Data.PatientCode = request.PatientCode;
                dbRequest.Data.PatientType = organization.PatientType;
                if (request.PatientDatas != null && request.PatientDatas.Any())
                {
                    await _patientService.UpdatePatientAsync(new UpdatePatientRequest
                    {
                        Token = request.Token,
                        Code = request.PatientCode,
                        PatientData = request.PatientDatas,
                    });
                    var patientInfo = await _patientInfoDBService.FindPatientByCodeAsync(request.PatientCode);
                    dbRequest.Data.PatientDatas = patientInfo?.PatientData;
                }
            }

            var result = await _consultationRecordDBService.InsertConsultationRecordAsync(dbRequest);
            //创建日程
            var addScheduleDBRequest = new AddScheduleDBRequest();
            addScheduleDBRequest.Data = new ScheduleDTO()
            {
                Title = emergencyCode,
                StartTime = startTime,
                EndTime = endTime,
                Status = TransactionStatusEnum.ToStart,
                ScheduleType = ScheduleTypeEnum.Consultation,
                RelevanceCode = result,
                UserCodes = new List<string> { userCode }
            };
            await _userDBService.AddScheduleDBAsync(addScheduleDBRequest);
            return result;
        }

        public async Task<QueryEmergencyDataResult> QueryEmergencyDataAsync(TokenRequest request)
        {
            var result = new QueryEmergencyDataResult();
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //查询用户是否存在
            var userInfo = await _userDBService.FindUserByCodeAsync(userCode);
            if (userInfo == null)
            {
                ThrowRpcException(CustomerRpcCode.UserNotExistError, "User does not exist");
            }
            //查询用户的医院是否存在
            if (string.IsNullOrEmpty(userInfo.OrganizationCode))
            {
                ThrowRpcException(CustomerRpcCode.OrganizationNotExist, "Org does not exist");
            }
            //急诊设备列表：只查询在线的，上次选择的在第一个
            var deviceInfoList = new List<EmergencyDeviceInfoDTO>();
            //急诊专家列表：只查询在线的，上次选择的在第一个
            var expertList = new List<UserDTO>();
            var deviceInfoDOList = new List<DeviceInfoDTO>();
            //普通用户，查询用户绑定的设备
            if (userInfo.BindDevices != null && userInfo.BindDevices.Any())
            {
                deviceInfoDOList = await _deviceDBService.FindDeviceInfoListByCodeListAsync(userInfo.BindDevices);
            }
            if (userInfo.IsDirector)
            {
                //机构负责人
                var orgRootCodes = new List<string> { userInfo.RootOrganizationCode };
                var allChildOrganizations = await _organizationDBService.GetAllChildOrganizations(userInfo.RootOrganizationCode);
                if (allChildOrganizations != null && allChildOrganizations.Count() > 0)
                {
                    orgRootCodes.AddRange(allChildOrganizations.Select(x => x.OrganizationCode));
                }
                var orgDeviceInfoDTOList = await _deviceDBService.FindDeviceInfoListByOrganizationCodesAsync(orgRootCodes);
                if (orgDeviceInfoDTOList != null && orgDeviceInfoDTOList.Count > 0)
                {
                    var devinceInfoCodes = deviceInfoDOList.Select(x => x.DeviceCode);
                    foreach (var item in orgDeviceInfoDTOList)
                    {
                        if (!devinceInfoCodes.Contains(item.DeviceCode))
                        {
                            deviceInfoDOList.Add(item);
                        }
                    }
                }
            }
            if (deviceInfoDOList.Any())
            {
                var deviceCodes = deviceInfoDOList.Select(x => x.DeviceCode).ToList();
                var deviceTokens = await _authenticationService.GetTokenWithClientIdsAsync(new GetTokenWithClientIdsRequest { ClientIds = deviceCodes });
                var onLineDeviceCodes = deviceTokens.Where(x => x.IsOnline == true).Select(x => x.ClientId);
                var onlineDeviceInfoDOList = deviceInfoDOList.Where(x => onLineDeviceCodes.Contains(x.DeviceCode)).ToList();
                if (onlineDeviceInfoDOList != null && onlineDeviceInfoDOList.Count > 0)
                {
                    var bindEmergencyDeviceCode = userInfo.BindEmergencyDeviceCode;
                    if (!string.IsNullOrWhiteSpace(bindEmergencyDeviceCode))
                    {
                        //排序
                        if (onLineDeviceCodes.Contains(bindEmergencyDeviceCode))
                        {
                            var bindEmergencyDevice = onlineDeviceInfoDOList.FirstOrDefault(x => x.DeviceCode == bindEmergencyDeviceCode);
                            if (bindEmergencyDevice != null && !string.IsNullOrWhiteSpace(bindEmergencyDevice.DeviceCode))
                            {
                                deviceInfoList.Add(await GetEmergencyDeviceInfoDTO(bindEmergencyDevice));
                            }
                        }
                    }
                    onlineDeviceInfoDOList = onlineDeviceInfoDOList.Where(x => x.DeviceCode != bindEmergencyDeviceCode).ToList();

                    //超声机设备是否被占用
                    foreach (var item in onlineDeviceInfoDOList)
                    {
                        deviceInfoList.Add(await GetEmergencyDeviceInfoDTO(item));
                    }
                }
                else
                {
                    ThrowRpcException(CustomerRpcCode.DeviceNotOnline, "DeviceNotOnline");
                }
            }
            if (deviceInfoList.Count == 0)
            {
                ThrowRpcException(CustomerRpcCode.EmergencyDeviceNotFound, "EmergencyDeviceNotFound");
            }
            var orgRequest = new GetOrganizationDBRequest { OrganizationCode = userInfo.RootOrganizationCode };
            var rootOrg = await _organizationDBService.GetOrganizationDetailAsync(orgRequest);
            var orgCodes = new List<string> { rootOrg.RootCode, rootOrg.ParentCode };
            orgCodes.AddRange(rootOrg.ReferralOrganizationCodes);
            orgCodes = orgCodes.Distinct().ToList();
            var orgs = await _organizationDBService.FindOrganizationListByCodesAsync(orgCodes);
            var userList = new List<UserDTO>();
            foreach (var orgCode in orgCodes)
            {
                var roles = new List<string>() { "Role_CertifiedExpert", "Role_CertifiedPhysician" };
                var tempUserList = await FindOrganizationAssistantsAsync(orgCode, roles);
                foreach (var item in tempUserList)
                {
                    item.RootOrganizationName = orgs.FirstOrDefault(x => x.RootCode == orgCode)?.OrganizationName;
                }
                userList.AddRange(tempUserList);
            }
            var userExts = userList.MappingTo<List<UserExtendDTO>>();
            if (userExts == null || userExts.Count == 0)
            {
                ThrowRpcException(CustomerRpcCode.EmergencyExpertNotFound, "EmergencyExpertNotFound");
            }
            foreach (var item in userExts)
            {
                item.UserStatus = GetUserStatus(item.UserCode);
            }
            userExts = userExts.Where(x => x.UserCode != userCode).ToList();
            if (userExts.Count <= 0)//专家未找到
            {
                ThrowRpcException(CustomerRpcCode.EmergencyExpertNotFound, "EmergencyExpertNotFound");
            }
            var idleUsers = userExts.Where(x => x.UserStatus == UserStatusEnum.Idle).ToList();//在线
            if (idleUsers != null && idleUsers.Count > 0)
            {
                var idleUserCodes = idleUsers.Select(x => x.UserCode);
                string bindEmergencyExpertCode = userInfo.BindEmergencyExpertCode;
                if (!string.IsNullOrWhiteSpace(bindEmergencyExpertCode) && bindEmergencyExpertCode != userCode)
                {
                    //排序
                    if (idleUserCodes.Contains(bindEmergencyExpertCode))
                    {
                        var bindEmergencyExpert = idleUsers.FirstOrDefault(x => x.UserCode == bindEmergencyExpertCode);
                        if (bindEmergencyExpert != null && !string.IsNullOrWhiteSpace(bindEmergencyExpert.UserCode))
                        {
                            expertList.Add(bindEmergencyExpert);
                        }
                    }
                }
                idleUsers = idleUsers.Where(x => x.UserCode != bindEmergencyExpertCode).ToList();
                if (idleUsers != null && idleUsers.Count > 0)
                {
                    expertList.AddRange(idleUsers);
                }
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.ExpertNotOnline, "ExpertNotOnline");
            }

            result.ExpertList = expertList;
            result.DeviceInfoList = deviceInfoList;
            return result;
        }

        private async Task<EmergencyDeviceInfoDTO> GetEmergencyDeviceInfoDTO(DeviceInfoDTO deviceInfoDTO)
        {
            var emergencyDeviceInfoDTO = deviceInfoDTO.MappingTo<EmergencyDeviceInfoDTO>();
            var liveRoomDTO = await _rtcService.GetInitiatingRoomByDeviceCodeAsync(new GetInitiatingRoomByDeviceCodeRequest()
            {
                DeviceCode = deviceInfoDTO.DeviceCode,
            });
            if (liveRoomDTO != null)
            {
                emergencyDeviceInfoDTO.IsOccupied = true;
                emergencyDeviceInfoDTO.OccupiedModuleEnum = liveRoomDTO.BusinessModule;
            }
            return emergencyDeviceInfoDTO;
        }
    }
}