WingLiveConsultationService/LiveConsultationService.FollowUpEvaluation.cs

using WingInterfaceLibrary.DB.Request;
using WingInterfaceLibrary.DTO.Consultation;
using WingInterfaceLibrary.DTO.Organization;
using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.LiveConsultation;
using WingInterfaceLibrary.LiveConsultation.QualityControl;
using WingInterfaceLibrary.Request.DBRequest;
using WingServerCommon.Service;
using WingServerCommon.Utilities;

namespace WingLiveConsultationService
{
    public partial class LiveConsultationService : JsonRpcService, ILiveConsultationService
    {

        public async Task<bool> AddFollowUpVisitInfoAsync(AddFollowUpVisitInfoRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(new ConsultationRecordCodeDBRequest
                {
                    Code = request.ConsultationRecordCode
                });
                if (consultationRecord.ConsultationStatus != TransactionStatusEnum.End)
                {
                    ThrowRpcException(CustomerRpcCode.ConsultationStatusError, "ConsultationStatusError");
                }
                var userCode = await GetClientIdByTokenAsync(request.Token);
                return await _consultationRecordDBService.AddFollowUpVisitInfoAsync(new AddFollowUpVisitInfoDBRequest
                {
                    ConsultationRecordCode = request.ConsultationRecordCode,
                    DoctorCode = userCode,
                    GeneralCase = request.GeneralCase,
                    OccurredTime = request.OccurredTime
                });
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return false;
        }

        public async Task<bool> DeleteFollowUpVisitInfoAsync(DeleteFollowUpVisitInfoRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                return await _consultationRecordDBService.DeleteFollowUpVisitInfoAsync(new DeleteFollowUpVisitInfoDBRequest
                {
                    FollowUpVisitCode = request.FollowUpVisitCode,
                });
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return false;
        }

        public async Task<bool> UpdateFollowUpVisitInfoAsync(UpdateFollowUpVisitInfoRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                return await _consultationRecordDBService.UpdateFollowUpVisitInfoAsync(new UpdateFollowUpVisitInfoDBRequest
                {
                    FollowUpVisitCode = request.FollowUpVisitCode,
                    GeneralCase = request.GeneralCase,
                });
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return false;
        }

        public async Task<List<FollowUpVisitDTO>> GetFollowUpVisitInfoAsync(GetFollowUpVisitInfoRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                var userCode = await GetClientIdByTokenAsync(request.Token);
                var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
                var rootOrg = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = userDTO.RootOrganizationCode }) ?? new OrganizationDTO() { IsEncryptedShow = false };
                var consultationRecordCode = request.ConsultationRecordCode;
                var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(new ConsultationRecordCodeDBRequest
                {
                    Code = consultationRecordCode
                });
                var result = await _consultationRecordDBService.GetFollowUpVisitInfoAsync(new GetFollowUpVisitInfoDBRequest
                {
                    ConsultationRecordCode = consultationRecordCode,
                });
                foreach (var item in result)
                {
                    item.PatientName = (consultationRecord.PatientDatas == null || consultationRecord.PatientDatas.Count == 0) ? "" : CryptionHelper.NameEncrypt(GetPatientValue(consultationRecord.PatientDatas, "Name"), rootOrg.IsEncryptedShow);
                    item.PatientPhone = (consultationRecord.PatientDatas == null || consultationRecord.PatientDatas.Count == 0) ? "" : CryptionHelper.PhoneEncrypt(GetPatientValue(consultationRecord.PatientDatas, "Phone"), rootOrg.IsEncryptedShow);
                }
                return result;
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return new List<FollowUpVisitDTO>();
        }

        public async Task<FollowUpVisitDTO> GetFollowUpVisitInfoDetailAsync(GetFollowUpVisitInfoDetailRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                var userCode = await GetClientIdByTokenAsync(request.Token);
                var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
                var rootOrg = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = userDTO.RootOrganizationCode }) ?? new OrganizationDTO() { IsEncryptedShow = false };
                var result = await _consultationRecordDBService.GetFollowUpVisitInfoDetailAsync(new GetFollowUpVisitInfoDetailDBRequest
                {
                    FollowUpVisitCode = request.FollowUpVisitCode,
                });
                var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(new ConsultationRecordCodeDBRequest
                {
                    Code = result.ConsultationRecordCode
                });
                result.PatientName = (consultationRecord.PatientDatas == null || consultationRecord.PatientDatas.Count == 0) ? "" : CryptionHelper.NameEncrypt(GetPatientValue(consultationRecord.PatientDatas, "Name"), rootOrg.IsEncryptedShow);
                result.PatientPhone = (consultationRecord.PatientDatas == null || consultationRecord.PatientDatas.Count == 0) ? "" : CryptionHelper.PhoneEncrypt(GetPatientValue(consultationRecord.PatientDatas, "Phone"), rootOrg.IsEncryptedShow);
                return result;
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return null;
        }

        public async Task<bool> SetNeedFollowUpVisitAsync(SetNeedFollowUpVisitRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                return await _consultationRecordDBService.SetNeedFollowUpVisitAsync(new SetNeedFollowUpVisitDBRequest
                {
                    ConsultationRecordCode = request.ConsultationRecordCode,
                    IsNeed = request.IsNeed
                });
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return false;
        }

        public async Task<bool> AddConsultationEvaluateAsync(AddConsultationEvaluateRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(new ConsultationRecordCodeDBRequest
                {
                    Code = request.ConsultationRecordCode
                });
                if (consultationRecord.ConsultationStatus != TransactionStatusEnum.End)
                {
                    ThrowRpcException(CustomerRpcCode.ConsultationStatusError, "ConsultationStatusError");
                }
                return await _consultationRecordDBService.AddConsultationEvaluateAsync(new AddConsultationEvaluateDBRequest
                {
                    ConsultationRecordCode = request.ConsultationRecordCode,
                    EvaluateScore = request.EvaluateScore,
                    Feedback = request.Feedback,
                });
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return false;
        }

        public async Task<bool> DeleteConsultationEvaluateAsync(DeleteConsultationEvaluateRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                return await _consultationRecordDBService.DeleteConsultationEvaluateAsync(new DeleteConsultationEvaluateDBRequest
                {
                    ConsultationEvaluateCode = request.ConsultationEvaluateCode,
                });
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return false;
        }

        public async Task<bool> UpdateConsultationEvaluateAsync(UpdateConsultationEvaluateRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                return await _consultationRecordDBService.UpdateConsultationEvaluateAsync(new UpdateConsultationEvaluateDBRequest
                {
                    ConsultationEvaluateCode = request.ConsultationEvaluateCode,
                    EvaluateScore = request.EvaluateScore,
                    Feedback = request.Feedback,
                });
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return false;
        }

        public async Task<ConsultationEvaluateDTO> GetConsultationEvaluateDetailAsync(GetConsultationEvaluateRequest request)
        {
            if (!string.IsNullOrWhiteSpace(await GetClientIdByTokenAsync(request.Token)))
            {
                var result = await _consultationRecordDBService.GetConsultationEvaluateDetailAsync(new GetConsultationEvaluateDBRequest
                {
                    ConsultationRecordCode = request.ConsultationRecordCode,
                });
                return result;
            }
            else
            {
                ThrowRpcException(CustomerRpcCode.AuthenticationError, "AuthenticationError");
            }
            return null;
        }
    }
}