def post(self):
try:
args = self._post_args().parse_args()
orderId = args.get('orderId')
paymentAmount = args.get('paymentAmount')
payId = args.get('payId')
payGroupIds = args.get('payGroupIds')
pt = args.get('payType')
payType = None
if pt == 'WX':
payType = '微信'
elif pt == 'ZFB':
payType = '支付宝'
log.info(
'收到支付命令，参数为orderId:{} paymentAmount:{} payId:{} payGroupdIds:{} '.format(orderId, paymentAmount, payId,
payGroupIds))
# 开始登录体检
_loginTj()
r = pay(orderId=orderId, paymentAmount=paymentAmount, payGroupIds=payGroupIds, payId=payId, payType=payType)
log.info('支付完成后，获取返回。{}'.format(r))
tjAssert(r)
return r
except Exception as e:
dealException(e)
def trans_pacs_reg(order_id, pacs_assem_id, op_type, op_name):
"""
根据预约号、PACS项目组ID，将项目组进行登入、或取消登入的操作
:param order_id:
:param pacs_assem_id:
:param op_type:
:param op_name:
:return:
"""
department_id, assemdIds = _common_fun(pacs_assem_id)
# 获取操作者id
# result = tjAssert(getUserByRealName(op_name))
# op_id = result['msg']['id']
# confirmId = getUserIdByRealName(audit_doctor, appconfig['PACS_USE_EXAM_DOCTOR'], 'pacs')
log.info('获取到技师名字:{} 是否是使用体检系统的用户名:{} '.format(
op_name, appconfig['PACS_USE_EXAM_DOCTOR']))
op_id = getUserIdByRealName(op_name, appconfig['PACS_USE_EXAM_DOCTOR'],
'pacs')
log.info("获取登记技师ID为:{}".format(op_id))
result = None
if op_type == '登记':
result = tjAssert(loginAssems(order_id, assemdIds, op_id))
elif op_type == '撤销登记':
result = tjAssert(
cancelLoginAssems(order_id, department_id, assemdIds, op_id))
else:
raise InvalidOpTypeException(
'无效的操作类型OP_TYPE:{},值必须为[登记]或[撤销登记]'.format(op_type))
log.info(result['msg'])
def delete(self, orderId):
"""
删除预约号
:param orderId:
:return:
"""
try:
_loginTj()
log.info('开始查询预约号为:{}的是否可删除'.format(orderId))
r = getOrderDigestByOrderId(orderId)
rowCount = len(r)
log.info('获取到可删除的记录数为:{}'.format(rowCount))
if rowCount == 0:
abort(400, '不能删除本次预约，本预约不存在或已收费或正在体检')
log.info('开始删除预约号为:{}的预约记录'.format(orderId))
r = deleteOrder(orderId)
tjAssert(r)
log.info('删除预约号为:{}的预约记录成功'.format(orderId))
return _returnMessage({
'deletedOrderId': orderId
})
# return r
except Exception as e:
dealException(e)
def put(self):
try:
args = self._post_args().parse_args()
log.info('开始改修团检的日期...')
_loginTj()
r = updateOrderDate(
orderId=args.get('orderId'),
orderExamDate=args.get('orderExamDate')
)
log.info(r)
tjAssert(r)
return _returnMessage({
'success': True
})
except Exception as e:
dealException(e)
def _common_fun(pacs_assem_id):
log.info(
'开始通过PACS项目组ID:{}从体检系统中，获取映射的体检项目组ID及科室ID信息.'.format(pacs_assem_id))
assems = None
if appconfig['MAP_CODE_IS_ASSEM_ID']:
assems = get_assem_by_id(pacs_assem_id)
else:
assems = get_assem_by_map(appconfig['DEPARTMENTS_RANGE'],
pacs_assem_id)
if len(assems) == 0:
raise NotFoundException(
'pacs项目组对照码:{}，在体检系统中没有找到相应的项目组与其对应.'.format(pacs_assem_id))
log.info('使用PACS项目组ID:{}找到{}条项目组映射.'.format(pacs_assem_id, len(assems)))
department_id_set = set([assem.department_id for assem in assems])
if len(department_id_set) > 1:
raise InvalidMultiException(
'pacs项目组对照码:{}对应了多个科室的项目组，这是无效的，多个科室id:{}'.format(
pacs_assem_id, department_id_set))
assem_id_list = [str(assem.id) for assem in assems]
assem_name_list = [assem.name for assem in assems]
log.info('获取到项目组id:{} 对应的项目组名字:{}'.format(assem_id_list, assem_name_list))
# 开始尝试登录到体检系统
exam_username = appconfig['JK_EXAM_USERNAME']
exam_password = appconfig['JK_EXAM_PASSWORD']
log.info('开始尝试登录体检系统，用户名:{} 密码:{}'.format(exam_username, exam_password))
result = tjAssert(loginByUserNamePwd(exam_username, exam_password))
log.info(result['msg'])
return list(department_id_set)[0], ','.join(assem_id_list)
def _loginTj():
log.info('开始登录体检系统...')
r = loginByUserNamePwd(JK_EXAM_USERNAME, JK_EXAM_PASSWORD)
tjAssert(r)
log.info(r['msg'])
def post(self):
"""
新建预约信息
:return:
"""
try:
log.info('开始分析参数...')
log.info('获取到预约参数:{}'.format(request.json))
args = self._post_args().parse_args()
certId = args.get('certId')
log.info('开始查询身份证号为[{}]的人员基本信息...'.format(certId))
basicInfo = getBasicInfo(certId)
if basicInfo:
log.info('查询到身份证:{} 的人员信息,姓名:{} 性别:{} 体检号:{}'.format(certId, basicInfo.username, basicInfo.sex,
basicInfo.exam_no))
else:
log.info('没有查到身份证:{}的人员基本信息'.format(certId))
log.info('开始解析身份证:{}的出生日期及性别...'.format(certId))
certInfo = validator.getInfo(certId)
log.info('从身份证获取的出身日期：{} 性别:{}'.format(certInfo['birth'], certInfo['sex']))
if basicInfo is not None:
personId = basicInfo.id
log.info('根据人员信息id:{}获取未完成的（已预约）预约信息...'.format(personId))
oInfo = getOrderDigest(personId)
if oInfo:
abort(400, '您还有未完成的体检预约，预约号为[{}]，预约日期为:{}，请取消后此预约后再重新预约体检'.format(
oInfo.id,
oInfo.initial_time.strftime('%Y-%m-%d')
))
log.info('开始组装结果...')
orderInfo = OrderInfo()
orderInfo.addBasicInfo(username=args.get('username'),
certId=args.get('certId'),
birth=certInfo['birth'],
sex=certInfo['sex'],
mobile=args.get('mobile'),
orderExamDate=args.get('orderExamDate'),
examType=args.get('examType'),
subarea=args.get('subarea'),
customerSource=TJ_CUSTOMER_SOURCE,
maritalStatus=args.get('maritalCode'),
personId=basicInfo.id if basicInfo is not None else None,
examNo=basicInfo.exam_no if basicInfo is not None else None,
itemPackage=args.get('packageId')
)
groups = args.get('groups')
for group in groups:
orderInfo.addGroup(departmentId=group['departmentId'],
groupId=group['groupId'],
groupName=group['groupName'],
originalPrice=group['originalPrice'],
discountPrice=group['discountPrice'],
discountRate=group['discountRate']
)
_loginTj()
log.info('开始保存预约记录...')
params = orderInfo.getParams()
# log.info('预约信息:{}'.format(params))
r = saveOrder(params)
tjAssert(r)
log.info('保存预约记录成功!')
# (examNo, orderId) = r['msg'].split(',')
return _returnMessage({
'examNo': r['msg']['examNo'],
'orderId': r['msg']['orderId']
})
except Exception as e:
dealException(e)
def lis_to_phexam(lisDepartment, dockingLisFollowing, SQJGMM):
"""
LIS到体检系统登入状态、LIS结果导入
:param dockingLisFollowing:
:return:
"""
r_list = []
ll = []
log.info('开始查询本样本号所做的项目....')
assems = get_assems_by_barcode_id(dockingLisFollowing.ZXTM)
str_assems = ','.join(assems)
if len(assems) == 0:
raise NotFoundException('在检检系统中，未发现条码号为:{}的任何项目组'.format(
dockingLisFollowing.ZXTM))
if not dockingLisFollowing.BRID:
raise TJException('不存在的预约号')
if dockingLisFollowing.ZTBZ == '2': # 表示样本号已经在LIS中登记
log.info('开始对预约号:{} 项目组列表:{} 进行登入操作'.format(dockingLisFollowing.BRID,
str_assems))
try:
_login()
loginAssems(dockingLisFollowing.BRID, str_assems,
None) # 为None的话，为当前的登录者进行操作
log.info('项目组登入操作成功')
_appen_msg(r_list=r_list,
orderId=dockingLisFollowing.BRID,
assems=str_assems,
assem_name=None,
op='登入',
msg='登入成功',
ex=None,
lis_result=None,
barcode=dockingLisFollowing.ZXTM)
except Exception as e:
_appen_msg(r_list, dockingLisFollowing.BRID, str_assems, None,
'登入', None, e, None, dockingLisFollowing.ZXTM)
elif dockingLisFollowing.ZTBZ == '3': # 表示报告已经完成
try:
log.info('开始从平台中，获取报告信息...')
build_dict = get_init_dict()
build_lis_report(dockingLisFollowing, build_dict)
build_dict['PARAMS']['TOKEN'] = get_token(
dockingLisFollowing.SQJGDM, SQJGMM, dockingLisFollowing.SQJGDM)
report_nos = get_report_no_from_lis(build_dict)
if len(report_nos) == 0:
raise Exception('没有获取到报告编号')
for report_no in report_nos:
log.info('使用报告编码:{}查询项目结果'.format(report_no))
req_results_dict = get_init_dict()
build_lis_report_results(dockingLisFollowing, report_no,
req_results_dict)
req_results_dict['PARAMS']['TOKEN'] = get_token(
dockingLisFollowing.SQJGDM, SQJGMM,
dockingLisFollowing.SQJGDM)
lis_results = get_report_result_from_lis(
req_results_dict)['Results']['Result']
# 获取到检验医生和审核医生
opName = lis_results.get('JYYS', None) # 报告医生
auditName = lis_results.get('SHYS', None) if lis_results.get(
'SHYS',
None) is not None else opName # 审核医生，如果审核医生为空，则使用报告医生
result_dict_list = lis_results['ItemResultList']['ItemResult']
if isinstance(result_dict_list, list):
for result in result_dict_list:
result['JYYS'] = opName
result['SHYS'] = auditName
ll.append(result)
else:
result_dict_list['JYYS'] = opName
result_dict_list['SHYS'] = auditName
ll.append(result_dict_list)
# 以lis项目id为key，建立字典
lis_results_map = {}
lis_results_set = set()
for result in ll:
key = result['XMBM']
lis_results_map[key] = result
lis_results_set.add(key)
log.info('获取到lis数据的对照码集合为:{}'.format(lis_results_set))
_login()
assemName = None
for assemId in assems:
try:
log.info('开始循环获取预约号:{}的项目组id:{}的体检信息'.format(
dockingLisFollowing.BRID, assemId))
msg = tjAssert(
loadExam(dept=lisDepartment,
orderId=dockingLisFollowing.BRID,
filterAssemIds=assemId))
exam = msg['msg']
assem = exam['assems'][0]
elements = assem['elements']
# 项目组名称
assemName = assem['assemName']
log.info('获取的体检系统的项目名称为:{}'.format(assemName))
# 使用外键组成项目字典
examElementDict = {}
examElementSet = set()
for element in elements:
extCode = element['extSysControlCode']
if not extCode:
raise TJException('项目名：{} 的系统对照为空'.format(
element['elementName']))
# 开始分割项目对照码，一个小项，可以有多个对照码，使用,，|^，进行分割
keys = re.split(r',|，|\^|\|', extCode)
for key in keys:
if key:
code = key.strip()
if code:
examElementDict[code] = element
examElementSet.add(code)
log.info('获取到体检数据的对照码集合为:{}'.format(examElementSet))
# 计算项目编码的合集
both_set = set.intersection(examElementSet,
lis_results_set)
log.info('得到的交集为:{}'.format(both_set))
# 开始对小项进行标记
for code in both_set:
examElementDict[code]['bingo'] = True
errMsgs = []
log.info('开始检查哪些项目，在HIS中没有结果...')
for element in elements:
if 'bingo' not in element.keys():
errMsg = '在LIS提供的项目列表中，未发现项目id:{} 项目名:{} 项目对照:{}的项目'.format(
element['elementId'], element['elementName'],
element['extSysControlCode'])
errMsgs.append(errMsg)
if len(errMsgs) > 0:
raise TJException(';'.join(errMsgs))
log.info('开始生成LIS体检项目...')
# sampleOpId, opId = _get_opid(lis_results)
lisDatas = {
'orderId': dockingLisFollowing.BRID,
'elementAssemId': assemId,
'departmentId': lisDepartment,
'sampleOpId': None, # 报告人
'opId': None, # 审核人
'items': []
}
sampleOpId = None
opId = None
isGetDoct = True
for code in both_set:
examElement = examElementDict[code]
hisLisElement = lis_results_map[code]
if isGetDoct: # 开始获取医生,只取一次
sampleOpId, opId = _get_opid(
hisLisElement.get('JYYS', None),
hisLisElement.get('SHYS', None))
lisDatas['sampleOpId'] = sampleOpId
lisDatas['opId'] = opId
lisElement = {}
lisElement['elementId'] = examElement['elementId']
lisElement['checkElementResult'] = hisLisElement.get(
'JCJG', None)
lisElement['ferenceLower'] = 0
lisElement['ferenceUpper'] = 0
# 参考范围,使用新版的参考范围
lisElement['showFerence'] = hisLisElement.get(
'CKFW', None)
lisElement['unit'] = hisLisElement.get('JLDW', None)
lisElement['resultType'] = examElement['resultType']
lisElement['referenceType'] = '1' # e['refType']
# 危机值的标识？
lisElement['criticalValuesSymbol'] = hisLisElement.get(
'WJZBZ', None)
# SUM_JUDGE_TYPE ，项目异常下小结判断：0表示使用体检系统判断业务，1表示使用外接系统根据positiveSymbol判断
lisElement['sumJudgeType'] = 1
ycts = hisLisElement.get('YCTS', None)
resultType = examElement['resultType']
lisElement['positiveSymbol'] = ''
if resultType == '1': # 数值类值
if ycts == '3':
lisElement['positiveSymbol'] = '高'
elif ycts == '4':
lisElement['positiveSymbol'] = '低'
elif resultType == '2': # 文本类型
if ycts != '1':
lisElement['positiveSymbol'] = lisElement[
'checkElementResult'] # 非正常值的话，这里写检查结果
lisDatas['items'].append(lisElement)
isGetDoct = False
log.info('开始上传LIS结果数据...')
examData = json.dumps(lisDatas, ensure_ascii=False)
log.info(examData)
log.info("开始保存LIS结果....")
result = tjAssert(saveLisExamData(examData))
log.info(result['msg'])
_appen_msg(r_list, dockingLisFollowing.BRID, assemId,
assemName, 'LIS结果传输', 'LIS结果传输成功', None,
_tojson(ll), dockingLisFollowing.ZXTM)
except Exception as e:
_appen_msg(r_list, dockingLisFollowing.BRID,
assemId, assemName, 'LIS结果传输', None, e,
_tojson(ll), dockingLisFollowing.ZXTM)
except Exception as e:
_appen_msg(r_list, dockingLisFollowing.BRID, str_assems, None,
'LIS结果传输', None, e, _tojson(ll),
dockingLisFollowing.ZXTM)
return r_list
def _login():
log.info('开始登录体检系统')
r = loginByUserNamePwd(appconfig['JK_EXAM_USERNAME'],
appconfig['JK_EXAM_PASSWORD'])
tjAssert(r)
log.info('体检系统登录成功')
def pacs_to_phexam(dockingPacsFollowing, SQJGMM):
r_list = []
log.info('开始拆分医院内流水号:{}'.format(dockingPacsFollowing.YWLSH))
(orderId, assemId) = re.split(r'\^', dockingPacsFollowing.YWLSH)
log.info('获取到预约号为:{} 项目组id为:{}'.format(orderId, assemId))
if orderId is None or assemId is None:
raise InvalidParamException('获取到的预约号或项目组无效')
if dockingPacsFollowing.ZTBZ == '1':
log.info('开始登记预约号：{} 项目组：{} 的记录'.format(orderId, assemId))
try:
_login()
tjAssert(loginAssems(orderId, assemId,
None)) # 为None的话，为当前的登录者进行操作
log.info('预约号：{} 项目组：{}登入操作成功'.format(orderId, assemId))
_appen_msg(r_list, orderId, assemId, None, '登入', '登入成功', None)
except Exception as e:
_appen_msg(r_list, orderId, assemId, None, '登入', None, e)
log.error('预约号：{} 项目组：{}登入操作失败!'.format(orderId, assemId))
log.error(e)
elif dockingPacsFollowing.ZTBZ == '4':
assemName = None
try:
log.info('开始获取预约号：{} 项目组id：{}的结果信息'.format(orderId, assemId))
log.info('开始通过项目组id：{}来获取科室id'.format(assemId))
departmentId = get_department_by_assem_id(assemId)
if departmentId is None:
raise TJException('项目组:{}在体检中未找到科室'.format(assemId))
log.info('开始获取报告列表...')
build_dict = get_init_dict()
build_pacs_report_result(dockingPacsFollowing, build_dict)
build_dict['PARAMS']['TOKEN'] = get_token(
dockingPacsFollowing.SQJGDM, SQJGMM,
dockingPacsFollowing.SQJGDM)
pacs_results = get_report_result_from_pacs(build_dict)
log.info('获取到PACS的结果为:{}'.format(pacs_results))
pacs_result_dict = pacs_results['FORMLISTS']['FORMLIST']
# 检查结果阴阳性,0未做1阴性2阳性
yybz = pacs_result_dict.get('YYBZ', None)
yxbx = pacs_result_dict.get('YXBX', None)
jcts = pacs_result_dict.get('JCTS', None)
log.info('从报告获取到阳性标识：{} 影像表现:{} 检查提示：{} '.format(yybz, yxbx, jcts))
log.info('从体检系统中获取体检结果...')
_login()
msg = tjAssert(
loadExam(dept=departmentId,
orderId=orderId,
filterAssemIds=assemId))
exam = msg['msg']
assem = exam['assems'][0]
element = assem['elements'][0]
# 项目组名称
assemName = assem['assemName']
log.info('获取到项目组名:{}'.format(assemName))
# 初始化保存数据
reporterId, confirmId = _get_opid(pacs_result_dict)
log.info('获取到报告者id:{} 审核者id:{}'.format(reporterId, confirmId))
saveExam = initSaveExam(exam, departmentId, confirmId, reporterId)
# 小项结果
fs = {'others': yxbx}
addElementResult(saveExam, exam=exam, opId=reporterId, **fs)
# 项目结论
log.info('获取结论...')
writeSymbol = None
diseaseCode = None
if yybz == '2': # 阳性
result = getDiseaseByName(jcts)
if result is None:
writeSymbol = '02'
else:
writeSymbol = '01'
diseaseCode = result['msg']['id']
elif yybz == '1': # 阴性
writeSymbol = '03'
log.info("获取诊断方式:{},疾病名称:{},疾病id:{}".format(
writeSymbol, jcts, diseaseCode))
addDisease(saveExam,
exam=exam,
deptId=departmentId,
opId=reporterId,
writeSymbol=writeSymbol,
diseaseName=jcts,
diseaseCode=diseaseCode)
# 开始提交分科结果
examData = json.dumps(saveExam)
log.info(examData)
log.info('开始提交分科结果...')
result = tjAssert(saveExamData(examData))
log.info(result['msg'])
_appen_msg(r_list, orderId, assemId, assemName, 'PACS结果传输',
'体检结果接收成功', None)
except Exception as e:
_appen_msg(r_list, orderId, assemId, assemName, 'PACS结果传输',
repr(e), e)
log.error('预约号：{} 项目组：{}获取PACS结果失败'.format(orderId, assemId))
log.error(e)
return r_list
def trans_pacs_result(order_id, pacs_assem_id, pacs_assem_name,
report_diagnose, report_result, positive_content,
report_url, reporter, audit_doctor, report_date):
"""
根据预约号、PACS项目组ID，传输pacs结果到体检系统
:param order_id:
:param pacs_element_id:
:return:
"""
department_id, assemdIds = _common_fun(pacs_assem_id)
# 获取报告医生的ID
reporterId = getUserIdByRealName(reporter,
appconfig['PACS_USE_EXAM_DOCTOR'], 'pacs')
log.info("获取报告医生ID为:{}".format(reporterId))
# 获取审核医生ID
confirmId = getUserIdByRealName(audit_doctor,
appconfig['PACS_USE_EXAM_DOCTOR'], 'pacs')
log.info("获取审核者医生ID为:{}".format(confirmId))
log.info('开始根据科室、项目组、预约号获取体检信息，科室ID:{} 预约号:{} 项目组ID:{}'.format(
department_id, order_id, assemdIds))
msg = tjAssert(
loadExam(dept=department_id,
orderId=order_id,
filterAssemIds=assemdIds))
exam = msg['msg']
# 初始化保存数据
saveExam = initSaveExam(exam, department_id, confirmId, reporterId)
# 小项结果
fs = {'others': report_result}
addElementResult(saveExam, exam=exam, opId=reporterId, **fs)
# 结论部分，开始拆分结论
log.info('获取结论...')
if not report_diagnose:
raise InvalidDialogException('结论不能为空')
summaries = re.split(r'\;|；|\r|\n|\r\n|[\d]+\.', report_diagnose)
for s in summaries:
summary = re.sub(r'^[\d]+\.', '', s.strip())
if len(summary) == 0:
continue
log.info('获取结论:{}'.format(summary))
writeSymbol = None
diseaseCode = None
if summary.find('未见异常') >= 0 or summary.find(
'未见明显异常') >= 0 or summary.find('未见确切异常') >= 0:
writeSymbol = '03'
else:
result = getDiseaseByName(summary)
if result is None:
writeSymbol = '02'
else:
writeSymbol = '01'
diseaseCode = result['msg']['id']
log.info("获取诊断方式:{},疾病名称:{},疾病id:{}".format(writeSymbol, summary,
diseaseCode))
addDisease(saveExam,
exam=exam,
deptId=department_id,
opId=reporterId,
writeSymbol=writeSymbol,
diseaseName=summary,
diseaseCode=diseaseCode)
# 重大阳性
if positive_content:
if positive_content.strip() != '阴性':
addPosReport(saveExam,
content=positive_content,
advice=positive_content,
opId=reporterId)
# 开始提交分科结果
examData = json.dumps(saveExam)
log.info(examData)
log.info('开始提交分科结果...')
result = tjAssert(saveExamData(examData))
log.info(result['msg'])
# 开始传输图像报告
upload_report(
order_id=order_id,
department_id=department_id,
pacs_assem_id=getElementAssemByCode(exam)['assemId'],
pacs_assem_name=pacs_assem_name,
reporter_id=reporterId,
report_url=report_url,
report_date=report_date if report_date else datetime.datetime.now())
def transLisByAssem(departmentId, order_id, assemId, lis_result_dict):
"""
上传LIS数据到体检系统中
:param departmentId: 科室ID
:param assemId:项目组ID
:lis_result_dict:项目结果字典
:return:
"""
lis_result_key_set = set()
for key in lis_result_dict.keys():
lis_result_key_set.add(key)
# 开始尝试登录到体检系统
log.info('开始尝试登录体检系统，用户名:{} 密码:{}'.format(appconfig['JK_EXAM_USERNAME'],
appconfig['JK_EXAM_PASSWORD']))
result = tjAssert(
loginByUserNamePwd(appconfig['JK_EXAM_USERNAME'],
appconfig['JK_EXAM_PASSWORD']))
log.info('开始根据科室、项目组、预约号获取体检信息，科室ID:{} 预约号:{} 项目组ID:{}'.format(
departmentId, order_id, assemId))
msg = tjAssert(
loadExam(dept=departmentId, orderId=order_id, filterAssemIds=assemId))
log.info('开始检查以及组装体检项目...')
exam = msg['msg']
assem = exam['assems'][0]
elements = assem['elements']
# 使用外键组成项目字典
examElementDict = {}
examElementSet = set()
for element in elements:
extCode = None
if appconfig['IS_LIS_ITEM_MAPPING']: # 如果不需要映射项目
extCode = element['elementId']
else:
extCode = element['extSysControlCode'] # 如果需要映射项目
if not extCode:
raise TJException('项目名：{} 的系统对照为空'.format(element['elementName']))
# 开始分割项目对照码，一个小项，可以有多个对照码，使用,，|^，进行分割
keys = re.split(r',|，|\^|\|', extCode)
for key in keys:
if key:
code = key.strip()
if code:
examElementDict[code] = element
examElementSet.add(code)
# 计算体检检查项目及lis项目结果列表的交集
both_set = set.intersection(examElementSet, lis_result_key_set)
# 开始对小项进行标记
for code in both_set:
examElementDict[code]['bingo'] = True
errMsgs = []
log.info('开始检查哪些项目，在HIS中没有结果...')
# 开始检查哪些项目没有结果
for element in elements:
if 'bingo' not in element.keys():
errMsg = '在LIS提供的项目列表中，未发现项目id:{} 项目名:{} 项目对照:{}的项目'.format(
element['elementId'], element['elementName'],
element['extSysControlCode'])
errMsgs.append(errMsg)
if len(errMsgs) > 0:
raise TJException(';'.join(errMsgs))
log.info('开始生成LIS体检项目...')
lisDatas = {
'orderId': order_id,
'elementAssemId': assemId,
'departmentId': departmentId,
'sampleOpId': None, # 报告人
'opId': None, # 审核人
'items': []
}
c = 0
item_results = []
for code in both_set:
try:
examElement = examElementDict[code]
hisLisElement = lis_result_dict[code]
if c == 0:
log.info('用于获取项目结果及操作员的记录ID:{}'.format(hisLisElement.ID))
sampleOpId, opId = _get_opid(hisLisElement)
lisDatas['sampleOpId'] = sampleOpId
lisDatas['opId'] = opId
lisElement = {}
lisElement['elementId'] = examElement['elementId']
lisElement[
'checkElementResult'] = hisLisElement.CONTENT_RESULT.strip(
) if hisLisElement.CONTENT_RESULT else None
lisElement[
'ferenceLower'] = hisLisElement.FERENCE_LOWER_LIMIT if _is_number(
hisLisElement.FERENCE_LOWER_LIMIT) else 0
lisElement[
'ferenceUpper'] = hisLisElement.FERENCE_UPPER_LIMIT if _is_number(
hisLisElement.FERENCE_UPPER_LIMIT) else 0
# 参考范围,使用新版的参考范围
lisElement['showFerence'] = hisLisElement.FERENCE_VALUE
lisElement['unit'] = hisLisElement.RESULT_UNIT
resultType = examElement['resultType']
lisElement['resultType'] = resultType
lisElement['referenceType'] = '1' # e['refType']
# 危机值的标识？
lisElement[
'criticalValuesSymbol'] = hisLisElement.CRITICAL_VALUES_SYMBOL
# 第三方接入标识
lisElement['sumJudgeType'] = 1
if resultType == '1': # 数值类值
if hisLisElement.POSTIVE_SYMBOL in ('↓', 'L', 'LL'):
lisElement['positiveSymbol'] = '低'
elif hisLisElement.POSTIVE_SYMBOL in ('↑', 'H', 'HH'):
lisElement['positiveSymbol'] = '高'
elif resultType == '2': # 文本类型
if hisLisElement.POSITIVE_SYMBOL == '↑' \
or '阳' in hisLisElement.POSITIVE_SYMBOL:
lisElement['positiveSymbol'] = lisElement[
'checkElementResult'] # 非正常值的话，这里写检查结果
# if hisLisElement.POSITIVE_SYMBOL == '↓':
# lisElement['positiveSymbol'] = '低'
# elif hisLisElement.POSITIVE_SYMBOL == '↑':
# lisElement['positiveSymbol'] = '高'
# else:
# lisElement['positiveSymbol'] = None
lisDatas['items'].append(lisElement)
# 项目的结果值列表保存，作为将来的参考，结构为 项目名称^项目结果^审核时间
item_results.append('{}^{}^{}'.format(
hisLisElement.LIS_ELEMENT_NAME, hisLisElement.CONTENT_RESULT,
hisLisElement.AUDIT_DATE.strftime('%Y-%m-%d %H:%M:%S')
if hisLisElement.AUDIT_DATE else None))
finally:
c += 1
log.info('开始上传LIS结果数据...')
examData = json.dumps(lisDatas)
log.info(examData)
log.info("开始保存LIS结果....")
result = tjAssert(saveLisExamData(examData))
log.info(result['msg'])
return '\n'.join(item_results)
def save_gmd():
# 获取参数
r = {"Msg": None, "Status": "SUCCESS"}
log.info('开始解析骨密度参数...')
try:
# print(request.json)
gmd = json.loads(str(request.data, encoding='utf-8'))
log.info('获取到要保存的骨密度数据:{}'.format(gmd))
patient_id = gmd.get('patientID')
t = gmd.get('t')
z = gmd.get('z')
examDoctor = gmd.get('examDoctor')
check_result = gmd.get('checkResultStr')
log.info('获取到patient_id:{} t值:{} z值:{} 检查结果:{} examDoctor:{}'.format(
patient_id, t, z, check_result, examDoctor))
exam_username = appconfig['JK_EXAM_USERNAME']
exam_password = appconfig['JK_EXAM_PASSWORD']
log.info('开始尝试登录体检系统，用户名:{} 密码:{}'.format(exam_username,
exam_password))
result = tjAssert(loginByUserNamePwd(exam_username, exam_password))
log.info(result['msg'])
# 获取报告医生的ID
reporterId = getUserIdByRealName(examDoctor,
appconfig['PACS_USE_EXAM_DOCTOR'],
'gmd')
log.info("获取报告医生ID为:{}".format(reporterId))
log.info('开始保存骨密度数据...')
# 获取诊断医生ID
department_id = appconfig['DEPARTMENT']
assemdIds = appconfig['ASSEM_ID']
order_id = patient_id
log.info('开始根据科室、项目组、预约号获取体检信息，科室ID:{} 预约号:{} 项目组ID:{}'.format(
department_id, order_id, assemdIds))
msg = tjAssert(
loadExam(dept=department_id,
orderId=patient_id,
filterAssemIds=assemdIds))
exam = msg['msg']
# 初始化保存数据
saveExam = initSaveExam(exam, department_id, reporterId, reporterId)
# 小项结果
fs = {'3837': str(t), '3838': str(z)}
addElementResult(saveExam, exam=exam, opId=reporterId, **fs)
log.info('获取诊断信息:{}'.format(check_result))
summary = check_result
log.info('获取结论:{}'.format(summary))
writeSymbol = None
diseaseCode = None
if summary.find('骨量正常') >= 0:
writeSymbol = '03'
else:
result = getDiseaseByName(summary)
if result is None:
writeSymbol = '02'
else:
writeSymbol = '01'
diseaseCode = result['msg']['id']
log.info("获取诊断方式:{},疾病名称:{},疾病id:{}".format(writeSymbol, summary,
diseaseCode))
addDisease(saveExam,
exam=exam,
deptId=department_id,
opId=reporterId,
writeSymbol=writeSymbol,
diseaseName=summary,
diseaseCode=diseaseCode)
# 开始提交分科结果
examData = json.dumps(saveExam)
log.info(examData)
log.info('开始提交分科结果...')
result = tjAssert(saveExamData(examData))
log.info(result['msg'])
# 开始上传图像
img = gmd.get('image')
if img:
log.info('开始上传图像报告...')
upload_report(order_id=patient_id,
department_id=department_id,
pacs_assem_id=assemdIds,
pacs_assem_name='超声骨密度',
reporter_id=reporterId,
report_base64=img,
report_date=datetime.now())
r['Msg'] = '上传成功'
except Exception as e:
r['Msg'] = "上传失败!{}".format(repr(e))
log.error('上传数据失败')
log.exception(e)
finally:
log.info('返回数据:{}'.format(r))
return jsonify(r)
def nj_to_exam(tjPacsResult, NJ_DEPARTMENT_ID):
log.info(
'开始对内镜记录 id:{} 预约号:{} 检查部位:{}进行操作'.format(tjPacsResult.id, tjPacsResult.register_num, tjPacsResult.check_part))
log.info('开始对诊断部位:{}进行分解...'.format(tjPacsResult.check_part))
desc, order_id, assem_id = re.split(r'\^', tjPacsResult.check_part)
if order_id is None or assem_id is None:
raise InvalidParamException('无效的部位代码,{}'.format(tjPacsResult.check_part))
log.info('获取到预约号:{} 项目组id:{}'.format(order_id, assem_id))
log.info('开始检查操作类型:{}'.format(tjPacsResult.rec_type))
_login()
if tjPacsResult.rec_type == '1':
log.info('开始登记...')
tjAssert(loginAssems(order_id, assem_id, None)) # 为None的话，为当前的登录者进行操作
log.info('预约号：{} 项目组：{}登入操作成功'.format(order_id, assem_id))
elif tjPacsResult.rec_type == '2':
log.info('开始保存体检结果...')
msg = tjAssert(
loadExam(dept=NJ_DEPARTMENT_ID, orderId=order_id, filterAssemIds=assem_id))
exam = msg['msg']
assem = exam['assems'][0]
element = assem['elements'][0]
# 初始化保存数据
reporterId, confirmId = _get_opid(tjPacsResult.report_doctor, tjPacsResult.audit_doctor)
log.info('获取到报告者id:{} 审核者id:{}'.format(reporterId, confirmId))
saveExam = initSaveExam(exam, NJ_DEPARTMENT_ID, confirmId, reporterId)
# 小项结果
fs = {'others': tjPacsResult.check_diag}
addElementResult(saveExam, exam=exam, opId=reporterId, **fs)
# 项目结论
log.info('获取结论...')
writeSymbol = None
diseaseCode = None
dialogs = re.split(r'[\d]+\s*\.|[\d]+\s*、|\r\n', tjPacsResult.check_result)
writeSymbol = None
diseaseCode = None
for diaglog in dialogs:
diseaseCode = None
if diaglog and diaglog.strip():
if diaglog.find('无异常') >= 0 or diaglog.find('无明显异常') >= 0: # 默认小节
writeSymbol = '03'
else:
result = getDiseaseByName(diaglog)
if result is None:
writeSymbol = '02'
else:
writeSymbol = '01'
diseaseCode = result['msg']['id']
log.info("获取诊断方式:{},疾病名称:{},疾病id:{}".format(writeSymbol, diaglog, diseaseCode))
addDisease(saveExam, exam=exam, deptId=NJ_DEPARTMENT_ID, opId=reporterId, writeSymbol=writeSymbol,
diseaseName=diaglog, diseaseCode=diseaseCode)
# 开始提交分科结果
examData = json.dumps(saveExam)
log.info(examData)
log.info('开始提交分科结果...')
result = tjAssert(saveExamData(examData))
log.info(result['msg'])
