|
|
@ -1,6 +1,8 @@
|
|
|
package com.yihu.jw.hospital.prescription.service;
|
|
|
|
|
|
import com.alibaba.fastjson.JSON;
|
|
|
import com.alibaba.fastjson.JSONArray;
|
|
|
import com.alibaba.fastjson.JSONObject;
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
|
import com.yihu.jw.dict.dao.DictHospitalDeptDao;
|
|
|
import com.yihu.jw.doctor.dao.BaseDoctorDao;
|
|
|
@ -12,7 +14,6 @@ import com.yihu.jw.entity.base.doctor.BaseDoctorHospitalDO;
|
|
|
import com.yihu.jw.entity.base.org.BaseDoctorPatientFollowDO;
|
|
|
import com.yihu.jw.entity.base.org.BaseOrgDO;
|
|
|
import com.yihu.jw.entity.base.patient.BasePatientDO;
|
|
|
import com.yihu.jw.entity.base.patient.PatientMedicareCardDO;
|
|
|
import com.yihu.jw.entity.hospital.consult.WlyyDoctorClinicRoomDO;
|
|
|
import com.yihu.jw.entity.hospital.consult.WlyyHospitalSysDictDO;
|
|
|
import com.yihu.jw.entity.hospital.consult.WlyyHospitalWaitingRoomDO;
|
|
|
@ -39,6 +40,7 @@ import com.yihu.jw.hospital.mapping.service.PatientMappingService;
|
|
|
import com.yihu.jw.hospital.message.service.SystemMessageService;
|
|
|
import com.yihu.jw.hospital.prescription.dao.*;
|
|
|
import com.yihu.jw.hospital.prescription.service.entrance.EntranceService;
|
|
|
import com.yihu.jw.hospital.prescription.service.entrance.YkyyEntranceService;
|
|
|
import com.yihu.jw.order.BusinessOrderService;
|
|
|
import com.yihu.jw.org.dao.BaseOrgDao;
|
|
|
import com.yihu.jw.patient.dao.BaseDoctorPatientFollowDao;
|
|
|
@ -64,8 +66,7 @@ import com.ylzinfo.ehc.common.utils.DateUtils;
|
|
|
import com.ylzinfo.ehc.trans.TransRequest;
|
|
|
import com.ylzinfo.ehc.trans.TransResponse;
|
|
|
import jxl.write.*;
|
|
|
import net.sf.json.JSONArray;
|
|
|
import net.sf.json.JSONObject;
|
|
|
|
|
|
import org.apache.commons.collections.map.HashedMap;
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
|
import org.slf4j.Logger;
|
|
|
@ -166,26 +167,27 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
@Autowired
|
|
|
private BaseDoctorInfoService baseDoctorService;
|
|
|
@Autowired
|
|
|
private BusinessOrderService businessOrderService;
|
|
|
private BusinessOrderService businessOrderService;
|
|
|
@Autowired
|
|
|
private YkyyEntranceService ykyyEntranceService;
|
|
|
|
|
|
|
|
|
@Value("${demo.flag}")
|
|
|
private boolean demoFlag;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 发起图文和视频复诊
|
|
|
*
|
|
|
* @param outpatientJson
|
|
|
* @param expressageJson
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public WlyyOutpatientDO appointmentRevisit(String outpatientJson,String expressageJson,String registerJson,String chargeType)throws Exception{
|
|
|
public WlyyOutpatientDO appointmentRevisit(String outpatientJson, String expressageJson, String registerJson, String chargeType) throws Exception {
|
|
|
|
|
|
//1.保存就诊实体
|
|
|
WlyyOutpatientDO outpatientDO = objectMapper.readValue(outpatientJson,WlyyOutpatientDO.class);
|
|
|
WlyyOutpatientDO outpatientDO = objectMapper.readValue(outpatientJson, WlyyOutpatientDO.class);
|
|
|
BasePatientDO patientDO = basePatientDao.findById(outpatientDO.getPatient());
|
|
|
|
|
|
outpatientDO.setMjz("mz");
|
|
|
@ -196,51 +198,51 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
outpatientDO.setCreateTime(new Date());
|
|
|
outpatientDO.setPayStatus(0);
|
|
|
|
|
|
if (outpatientDO.getRegisterDate() == null) {
|
|
|
outpatientDO.setRegisterDate(new Date());
|
|
|
}
|
|
|
|
|
|
WlyyOutpatientDO outpatient = outpatientDao.save(outpatientDO);
|
|
|
|
|
|
BusinessOrderDO businessOrderDO = new BusinessOrderDO();
|
|
|
businessOrderDO.setRelationCode(outpatientDO.getId());
|
|
|
businessOrderDO.setRelationCode(outpatient.getId());
|
|
|
businessOrderDO.setRelationName("复诊-诊查费");
|
|
|
businessOrderDO.setDescription("复诊-诊查费");
|
|
|
businessOrderDO.setPatient(outpatientDO.getPatient());
|
|
|
businessOrderDO.setPatientName(outpatientDO.getPatientName());
|
|
|
businessOrderDO.setDoctor(outpatientDO.getDoctor());
|
|
|
if (outpatientDO.getType().equalsIgnoreCase("1")){
|
|
|
businessOrderDO.setPatient(outpatient.getPatient());
|
|
|
businessOrderDO.setPatientName(outpatient.getPatientName());
|
|
|
businessOrderDO.setDoctor(outpatient.getDoctor());
|
|
|
if (outpatientDO.getType().equalsIgnoreCase("1")) {
|
|
|
businessOrderDO.setOrderType(1);
|
|
|
businessOrderDO.setOrderCategory("2");
|
|
|
}else if (outpatientDO.getType().equalsIgnoreCase("2")){
|
|
|
} else if (outpatientDO.getType().equalsIgnoreCase("2")) {
|
|
|
businessOrderDO.setOrderType(3);
|
|
|
businessOrderDO.setOrderCategory("3");
|
|
|
}
|
|
|
businessOrderService.saveOrder(businessOrderDO);
|
|
|
|
|
|
if(outpatientDO.getRegisterDate()==null){
|
|
|
outpatientDO.setRegisterDate(new Date());
|
|
|
}
|
|
|
|
|
|
WlyyOutpatientDO outpatient = outpatientDao.save(outpatientDO);
|
|
|
|
|
|
WlyyPatientRegisterTimeDO registerTimeDO = null;
|
|
|
|
|
|
try {
|
|
|
//如果是视频预约咨询
|
|
|
if(StringUtils.isNotBlank(registerJson)){
|
|
|
registerTimeDO = objectMapper.readValue(registerJson,WlyyPatientRegisterTimeDO.class);
|
|
|
if (StringUtils.isNotBlank(registerJson)) {
|
|
|
registerTimeDO = objectMapper.readValue(registerJson, WlyyPatientRegisterTimeDO.class);
|
|
|
registerTimeDO.setOutpatientId(outpatient.getId());
|
|
|
registerTimeDO.setCreateTime(new Date());
|
|
|
patientRegisterTimeDao.save(registerTimeDO);
|
|
|
}
|
|
|
}catch (Exception e){
|
|
|
} catch (Exception e) {
|
|
|
throw new RuntimeException("号源已经被预约，请选择其他号源");
|
|
|
}
|
|
|
|
|
|
//2.物流信息
|
|
|
WlyyPrescriptionExpressageDO expressageDO = objectMapper.readValue(expressageJson,WlyyPrescriptionExpressageDO.class);
|
|
|
WlyyPrescriptionExpressageDO expressageDO = objectMapper.readValue(expressageJson, WlyyPrescriptionExpressageDO.class);
|
|
|
expressageDO.setDel(1);
|
|
|
expressageDO.setCreateTime(new Date());
|
|
|
expressageDO.setOutpatientId(outpatient.getId());
|
|
|
prescriptionExpressageDao.save(expressageDO);
|
|
|
|
|
|
//3.创建候诊室
|
|
|
createRoom(outpatient,chargeType);
|
|
|
createRoom(outpatient, chargeType);
|
|
|
|
|
|
return outpatient;
|
|
|
}
|
|
|
@ -248,10 +250,11 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
|
|
|
/**
|
|
|
* 创建候诊室
|
|
|
*
|
|
|
* @param outpatientDO
|
|
|
* @return
|
|
|
*/
|
|
|
public Boolean createRoom(WlyyOutpatientDO outpatientDO,String chargeType){
|
|
|
public Boolean createRoom(WlyyOutpatientDO outpatientDO, String chargeType) {
|
|
|
|
|
|
WlyyHospitalWaitingRoomDO waitingRoom = new WlyyHospitalWaitingRoomDO();
|
|
|
|
|
|
@ -261,7 +264,7 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
waitingRoom.setHospitalName(outpatientDO.getHospitalName());
|
|
|
|
|
|
//是否是有协同门诊医生
|
|
|
if(StringUtils.isNotBlank(outpatientDO.getGeneralDoctor())){
|
|
|
if (StringUtils.isNotBlank(outpatientDO.getGeneralDoctor())) {
|
|
|
waitingRoom.setGeneralDoctor(outpatientDO.getGeneralDoctor());
|
|
|
waitingRoom.setGeneralDoctorName(outpatientDO.getGeneralDoctorName());
|
|
|
}
|
|
|
@ -271,18 +274,18 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
waitingRoom.setReservationTime(outpatientDO.getRegisterDate());
|
|
|
waitingRoom.setVisitStatus(0);
|
|
|
//设置复诊类型
|
|
|
waitingRoom.setReservationType(StringUtils.isNotBlank(outpatientDO.getOutpatientType())?Integer.parseInt(outpatientDO.getOutpatientType()):1);
|
|
|
waitingRoom.setReservationType(StringUtils.isNotBlank(outpatientDO.getOutpatientType()) ? Integer.parseInt(outpatientDO.getOutpatientType()) : 1);
|
|
|
|
|
|
waitingRoom.setSort(0);
|
|
|
waitingRoom.setConsultType(Integer.parseInt(outpatientDO.getType()));
|
|
|
if(StringUtils.isNotBlank(outpatientDO.getDoctor())){
|
|
|
if (StringUtils.isNotBlank(outpatientDO.getDoctor())) {
|
|
|
waitingRoom.setDoctor(outpatientDO.getDoctor());
|
|
|
waitingRoom.setDoctorName(outpatientDO.getDoctorName());
|
|
|
}
|
|
|
waitingRoom.setOutpatientId(outpatientDO.getId());
|
|
|
waitingRoom.setCreateTime(new Date());
|
|
|
|
|
|
if(StringUtils.isNotBlank(chargeType)){
|
|
|
if (StringUtils.isNotBlank(chargeType)) {
|
|
|
waitingRoom.setChargeType(chargeType);
|
|
|
}
|
|
|
|
|
|
@ -292,897 +295,67 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
}
|
|
|
|
|
|
|
|
|
public Boolean cancelPrescription(String prescriptionId){
|
|
|
WlyyPrescriptionDO prescriptionDO = prescriptionDao.findOne(prescriptionId);
|
|
|
prescriptionDO.setStatus(-2);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public SystemMessageDO sendPatientGetDrugMes(WlyyOutpatientDO outpatient,WlyyPrescriptionDO prescriptionDO){
|
|
|
SystemMessageDO systemMessageDO = new SystemMessageDO();
|
|
|
try{
|
|
|
|
|
|
systemMessageDO.setTitle("患者取药");
|
|
|
systemMessageDO.setType("7");
|
|
|
systemMessageDO.setReceiver(outpatient.getDoctor());
|
|
|
systemMessageDO.setReceiverName(outpatient.getDoctorName());
|
|
|
systemMessageDO.setRelationCode(outpatient.getId());
|
|
|
systemMessageDO.setSender(outpatient.getPatient());
|
|
|
systemMessageDO.setSenderName(outpatient.getPatientName());
|
|
|
systemMessageDO.setRelationCode(outpatient.getId());
|
|
|
|
|
|
JSONObject data = new JSONObject();
|
|
|
data.put("name",outpatient.getPatientName());
|
|
|
data.put("age",IdCardUtil.getAgeForIdcard(outpatient.getIdcard()));
|
|
|
data.put("gender",IdCardUtil.getSexForIdcard_new(outpatient.getIdcard()));
|
|
|
data.put("recipeType",prescriptionDO.getDispensaryType());
|
|
|
data.put("message","患者已完成取药");
|
|
|
|
|
|
systemMessageDO.setData(data.toString());
|
|
|
|
|
|
systemMessageService.saveMessage(systemMessageDO);
|
|
|
|
|
|
}catch (Exception e){
|
|
|
logger.error("sendPatientGetDrugMes :"+e.toString());
|
|
|
}
|
|
|
return systemMessageDO;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取卡记录
|
|
|
* @param patient
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray findPatientCard(String patient)throws Exception{
|
|
|
BasePatientDO patientDO = basePatientDao.findById(patient);
|
|
|
JSONArray res = entranceService.BS15018(patientDO.getIdcard(),null,demoFlag);
|
|
|
JSONArray rs = new JSONArray();
|
|
|
if(res !=null){
|
|
|
for (int i =0;i<res.size();i++){
|
|
|
JSONObject card = res.getJSONObject(i);
|
|
|
String cardStat = card.getString("CARD_STAT");
|
|
|
if("激活".equals(cardStat)){
|
|
|
rs.add(card);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
|
|
|
public Map<String,Object> checkOutpatient(String patient)throws Exception{
|
|
|
//-1卡余额不足，,-2 存在未结束的诊断热 1成功
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
//1.余额判断改到前端判断
|
|
|
//net.sf.json.JSONObject json = entranceService.qutpatientBalance(cardNo,demoFlag);
|
|
|
|
|
|
//2.判断是否有未结束的
|
|
|
List<WlyyOutpatientDO> list = outpatientDao.findByPatientList(patient);
|
|
|
if(list!=null&&list.size()>0){
|
|
|
rs.put("outpatient",list.get(0));
|
|
|
rs.put("code",-2);
|
|
|
rs.put("mes","存在未结束的诊断");
|
|
|
return rs;
|
|
|
}
|
|
|
rs.put("code",1);
|
|
|
rs.put("mes","验证通过");
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取所有医院列表
|
|
|
* @return
|
|
|
*/
|
|
|
public List<BaseOrgVO> findAllHospital(Integer level,String keyWord){
|
|
|
|
|
|
if (StringUtils.isNoneEmpty(keyWord)) {
|
|
|
keyWord = "%" + keyWord + "%";
|
|
|
|
|
|
if(level!=null){
|
|
|
List<BaseOrgDO> list = baseOrgDao.findByLevelAndName(level,"1",keyWord);
|
|
|
List<BaseOrgVO> rs = new ArrayList<>();
|
|
|
return convertToModels(list,rs,BaseOrgVO.class);
|
|
|
}else {
|
|
|
List<BaseOrgDO> list = baseOrgDao.findByDelAndName("1",keyWord);
|
|
|
List<BaseOrgVO> rs = new ArrayList<>();
|
|
|
return convertToModels(list,rs,BaseOrgVO.class);
|
|
|
}
|
|
|
}else{
|
|
|
|
|
|
if(level!=null){
|
|
|
List<BaseOrgDO> list = baseOrgDao.findByLevelAndDel(level,"1");
|
|
|
List<BaseOrgVO> rs = new ArrayList<>();
|
|
|
return convertToModels(list,rs,BaseOrgVO.class);
|
|
|
}else {
|
|
|
List<BaseOrgDO> list = baseOrgDao.findByDel("1");
|
|
|
List<BaseOrgVO> rs = new ArrayList<>();
|
|
|
return convertToModels(list,rs,BaseOrgVO.class);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取机构下部门信息
|
|
|
*
|
|
|
* @param orgCode
|
|
|
* @return
|
|
|
*/
|
|
|
public List<DictHospitalDeptVO> findDeptByHospital(String orgCode, String dept, String consultDeptFlag) {
|
|
|
List<DictHospitalDeptDO> list;
|
|
|
if (StringUtils.isNotBlank(consultDeptFlag) && "1".equals(consultDeptFlag)) {
|
|
|
list = dictHospitalDeptDao.findByOrgCodeAndConsultDeptFlag(orgCode, consultDeptFlag);
|
|
|
} else {
|
|
|
list = dictHospitalDeptDao.findByOrgCodeIn(orgCode);
|
|
|
}
|
|
|
List<DictHospitalDeptVO> rs = new ArrayList<>();
|
|
|
convertToModels(list, rs, DictHospitalDeptVO.class);
|
|
|
if (rs != null && rs.size() > 0 && StringUtils.isNotBlank(dept)) {
|
|
|
//排序
|
|
|
for (int i = 0; i < rs.size(); i++) {
|
|
|
String id = rs.get(i).getCode();
|
|
|
if (dept.equals(id)) {
|
|
|
Collections.swap(rs, 0, i);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取医生列表.
|
|
|
*
|
|
|
* @param orgCode
|
|
|
* @param dept
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findDoctorByHospitalAndDept(String orgCode,String dept,String chargeType,String doctorCode,String outpatientType,String startDate,String endDate,String key,String consultStatus){
|
|
|
String sql ="SELECT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.photo AS \"photo\", " +
|
|
|
" d.name AS \"name\", " +
|
|
|
" d.expertise AS \"expertise\"," +
|
|
|
" d.introduce AS \"introduce\"," +
|
|
|
" d.job_title_code AS \"jobTitleCode\", " +
|
|
|
" d.job_title_name AS \"jobTitleName\"," +
|
|
|
" d.charge_type AS \"chargeType\"," +
|
|
|
" d.outpatient_type AS \"outpatientType\"," +
|
|
|
" d.consult_status AS \"consultStatus\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON h.doctor_code = d.id " +
|
|
|
" WHERE " +
|
|
|
" 1=1";
|
|
|
Map<String,Object> params = new HashedMap();
|
|
|
if (StringUtils.isNotBlank(dept)) {
|
|
|
sql += " AND h.dept_code = '" + dept + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(orgCode)) {
|
|
|
sql += " AND h.org_code = '" + orgCode + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(chargeType)) {
|
|
|
if ("all".equals(chargeType)) {
|
|
|
//查询全部号源
|
|
|
} else {
|
|
|
sql += " AND d.charge_type ='" + chargeType + "'";
|
|
|
}
|
|
|
} else {
|
|
|
sql += " AND d.charge_type is not null ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(outpatientType)) {
|
|
|
if ("all".equals(outpatientType)) {
|
|
|
//查询全部权限
|
|
|
} else {
|
|
|
sql += " AND d.outpatient_type like'%" + outpatientType + "%'";
|
|
|
}
|
|
|
} else {
|
|
|
sql += " AND d.outpatient_type is not null ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(key)) {
|
|
|
sql += " AND (h.dept_name like '%" + key + "%' OR d.name like '%" + key + "%' OR d.expertise like '%" + key + "%') ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(consultStatus)) {
|
|
|
sql += " AND d.consult_status = '" + consultStatus + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(endDate) && StringUtils.isNotBlank(startDate)) {
|
|
|
sql += " AND EXISTS ( " +
|
|
|
" SELECT " +
|
|
|
" 1 " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.doctor = d.id " +
|
|
|
" AND t.start_time >=:startDate" +
|
|
|
" AND t.start_time <=:endDate" +
|
|
|
" )";
|
|
|
params.put("startDate",DateUtil.stringToDate(startDate,"yyyy-MM-ss HH:mm:ss"));
|
|
|
params.put("endDate",DateUtil.stringToDate(endDate,"yyyy-MM-ss HH:mm:ss"));
|
|
|
|
|
|
}
|
|
|
|
|
|
logger.info("findDoctorByHospitalAndDept sql:" + sql);
|
|
|
|
|
|
List<Map<String, Object>> list = hibenateUtils.createSQLQuery(sql,params);
|
|
|
|
|
|
if (list != null && list.size() > 0 && StringUtils.isNotBlank(doctorCode)) {
|
|
|
//排序
|
|
|
for (int i = 0; i < list.size(); i++) {
|
|
|
String id = (String) list.get(i).get("id");
|
|
|
if (doctorCode.equals(id)) {
|
|
|
Collections.swap(list, 0, i);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取医生列表带排班
|
|
|
*
|
|
|
* @param orgCode
|
|
|
* @param dept
|
|
|
* @return
|
|
|
*/
|
|
|
public MixEnvelop findDoctorWithWork(String orgCode, String dept, String chargeType, String doctorCode, String outpatientType, String startDate, String endDate, String key, String consultStatus, Integer page, Integer size) {
|
|
|
|
|
|
String totalSql = "SELECT " +
|
|
|
" count(1) AS \"total\" " +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON h.doctor_code = d.id " +
|
|
|
" WHERE " +
|
|
|
" 1=1 ";
|
|
|
Map<String,Object> params = new HashedMap();
|
|
|
if (StringUtils.isNotBlank(dept)) {
|
|
|
totalSql += " AND h.dept_code = '" + dept + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(orgCode)) {
|
|
|
totalSql += " AND h.org_code = '" + orgCode + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(chargeType)) {
|
|
|
totalSql += " AND d.charge_type ='" + chargeType + "'";
|
|
|
} else {
|
|
|
totalSql += " AND d.charge_type is not null ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(outpatientType)) {
|
|
|
if (outpatientType.contains("or")) {
|
|
|
String[] outpatientTypeArray = outpatientType.split("or");
|
|
|
totalSql += " AND ( ";
|
|
|
|
|
|
for (int i = 0; i < outpatientTypeArray.length; i++) {
|
|
|
totalSql += " d.outpatient_type like'%" + outpatientTypeArray[i] + "%'";
|
|
|
if (i != outpatientTypeArray.length - 1) {
|
|
|
totalSql += " or ";
|
|
|
}
|
|
|
}
|
|
|
totalSql += " ) ";
|
|
|
} else {
|
|
|
totalSql += " AND d.outpatient_type like'%" + outpatientType + "%'";
|
|
|
}
|
|
|
} else {
|
|
|
totalSql += " AND d.outpatient_type is not null ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(key)) {
|
|
|
totalSql += " AND (h.dept_name like '%" + key + "%' OR d.name like '%" + key + "%' OR d.expertise like '%" + key + "%') ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(consultStatus)) {
|
|
|
totalSql += " AND d.consult_status = '" + consultStatus + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(endDate) && StringUtils.isNotBlank(startDate)) {
|
|
|
totalSql += " AND EXISTS ( " +
|
|
|
" SELECT " +
|
|
|
" 1 " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.doctor = d.id " +
|
|
|
" AND t.start_time >=:startDate" +
|
|
|
" AND t.start_time <=:endDate" +
|
|
|
" )";
|
|
|
params.put("startDate",DateUtil.stringToDate(startDate,"yyyy-MM-ss HH:mm:ss"));
|
|
|
params.put("endDate",DateUtil.stringToDate(endDate,"yyyy-MM-ss HH:mm:ss"));
|
|
|
}
|
|
|
List<Map<String, Object>> rstotal = hibenateUtils.createSQLQuery(totalSql,params);
|
|
|
|
|
|
Long count = 0L;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
count = hibenateUtils.objTransformLong(rstotal.get(0).get("total"));
|
|
|
}
|
|
|
|
|
|
String sql = "SELECT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.photo AS \"photo\", " +
|
|
|
" d.name AS \"name\", " +
|
|
|
" d.expertise AS \"expertise\"," +
|
|
|
" d.introduce AS \"introduce\"," +
|
|
|
" d.job_title_code AS \"jobTitleCode\", " +
|
|
|
" d.job_title_name AS \"jobTitleName\"," +
|
|
|
" d.charge_type AS \"chargeType\"," +
|
|
|
" h.dept_code AS \"deptCode\"," +
|
|
|
" h.dept_Name AS \"deptName\"," +
|
|
|
" d.outpatient_type AS \"outpatientType\"," +
|
|
|
" d.consult_status AS \"consultStatus\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON h.doctor_code = d.id " +
|
|
|
" WHERE " +
|
|
|
" 1=1";
|
|
|
if (StringUtils.isNotBlank(dept)) {
|
|
|
sql += " AND h.dept_code = '" + dept + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(orgCode)) {
|
|
|
sql += " AND h.org_code = '" + orgCode + "'";
|
|
|
}
|
|
|
|
|
|
if (StringUtils.isNotBlank(chargeType)) {
|
|
|
sql += " AND d.charge_type ='" + chargeType + "'";
|
|
|
} else {
|
|
|
sql += " AND d.charge_type is not null";
|
|
|
}
|
|
|
|
|
|
if (StringUtils.isNotBlank(outpatientType)) {
|
|
|
if (outpatientType.contains("or")) {
|
|
|
String[] outpatientTypeArray = outpatientType.split("or");
|
|
|
sql += " AND ( ";
|
|
|
|
|
|
for (int i = 0; i < outpatientTypeArray.length; i++) {
|
|
|
sql += " d.outpatient_type like'%" + outpatientTypeArray[i] + "%'";
|
|
|
if (i != outpatientTypeArray.length - 1) {
|
|
|
sql += " or ";
|
|
|
}
|
|
|
}
|
|
|
sql += " ) ";
|
|
|
} else {
|
|
|
sql += " AND d.outpatient_type like'%" + outpatientType + "%'";
|
|
|
}
|
|
|
} else {
|
|
|
sql += " AND d.outpatient_type is not null ";
|
|
|
}
|
|
|
|
|
|
if (StringUtils.isNotBlank(key)) {
|
|
|
sql += " AND (h.dept_name like '%" + key + "%' OR d.name like '%" + key + "%' OR d.expertise like '%" + key + "%') ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(consultStatus)) {
|
|
|
sql += " AND d.consult_status = '" + consultStatus + "'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(endDate) && StringUtils.isNotBlank(startDate)) {
|
|
|
sql += " AND EXISTS ( " +
|
|
|
" SELECT " +
|
|
|
" 1 " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.doctor = d.id " +
|
|
|
" AND t.start_time >= :startDate" +
|
|
|
" AND t.start_time <= :endDate" +
|
|
|
" )";
|
|
|
}
|
|
|
sql += " AND d.del='1' AND d.outpatient_type is not null ";
|
|
|
logger.info("withwork sql:" +sql);
|
|
|
List<Map<String, Object>> list = hibenateUtils.createSQLQuery(sql,params,page,size);
|
|
|
if (list != null && list.size() > 0) {
|
|
|
//获取排班
|
|
|
for (Map<String, Object> doctor : list) {
|
|
|
String id = (String) doctor.get("id");
|
|
|
List<WlyyDoctorWorkTimeVO> times = findDoctorWorkTime(id, orgCode);
|
|
|
doctor.put("workTime", times);
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(doctorCode)) {
|
|
|
//排序
|
|
|
for (int i = 0; i < list.size(); i++) {
|
|
|
String id = (String) list.get(i).get("id");
|
|
|
if (doctorCode.equals(id)) {
|
|
|
Collections.swap(list, 0, i);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return MixEnvelop.getSuccessListWithPage(BaseHospitalRequestMapping.Prescription.api_success, list, page, size, count);
|
|
|
}
|
|
|
|
|
|
public List<WlyyDoctorWorkTimeVO> findDoctorWorkTime(String doctor, String hospital) {
|
|
|
|
|
|
List<WlyyHospitalWorkRuleDO> list = wlyyHospitalWorkRuleDao.findByHospital(hospital);
|
|
|
|
|
|
if (list != null && list.size() > 0) {
|
|
|
WlyyHospitalWorkRuleDO rule = list.get(0);
|
|
|
|
|
|
String openTimeString = DateUtil.dateToStr(new Date(), "yyyy-MM-dd")+ " " + rule.getMaxDayOpenTime() + ":00";
|
|
|
logger.info("today openTimeString :"+openTimeString);
|
|
|
Date openTime = DateUtil.strToDate(openTimeString, "yyyy-MM-dd HH:mm:ss");
|
|
|
|
|
|
Integer openDay = rule.getMaxDay();
|
|
|
if (openTime.before(new Date())) {
|
|
|
openDay = openDay - 1;
|
|
|
}
|
|
|
Date preDate = DateUtil.getPreDays(new Date(), openDay);
|
|
|
String maxDateString = DateUtil.dateToStr(preDate,"yyyy-MM-dd")+" 23:59:59";
|
|
|
logger.info("maxDateString :"+maxDateString);
|
|
|
|
|
|
Date endDate = DateUtil.stringToDate(maxDateString, "yyyy-MM-dd HH:mm:ss");
|
|
|
List<WlyyDoctorWorkTimeVO> timeVOs = new ArrayList<>();
|
|
|
List<WlyyDoctorWorkTimeDO> timeDOs = doctorWorkTimeDao.findDoctorWorkTime(doctor, new Date(), endDate);
|
|
|
if(timeDOs!=null&&timeDOs.size()>0){
|
|
|
convertToModels(timeDOs, timeVOs, WlyyDoctorWorkTimeVO.class);
|
|
|
if (timeVOs != null && timeVOs.size() > 0) {
|
|
|
for (WlyyDoctorWorkTimeVO timeVO : timeVOs) {
|
|
|
timeVO.setCount(findWorkTimeInfoCout(timeVO.getId()));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return timeVOs;
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 查询医生列表带月份排班状态
|
|
|
*
|
|
|
* @param orgCode
|
|
|
* @param dept
|
|
|
* @param chargeType
|
|
|
* @param date
|
|
|
* @param page
|
|
|
* @param size
|
|
|
* @return
|
|
|
*/
|
|
|
public MixEnvelop findDoctorWithMouthWork(String orgCode, String dept, String chargeType, String date, String nameKey,String iswork, Integer page, Integer size) {
|
|
|
|
|
|
String totalSql = "SELECT " +
|
|
|
" count(1) AS \"total\" " +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON h.doctor_code = d.id " +
|
|
|
" JOIN base_doctor_role r ON r.doctor_code = d.id " +
|
|
|
" WHERE " +
|
|
|
" h.org_code = '" + orgCode + "'" +
|
|
|
" AND r.role_code ='specialist'";
|
|
|
if (StringUtils.isNotBlank(chargeType)) {
|
|
|
if ("all".equals(chargeType)) {
|
|
|
//不过滤号别
|
|
|
} else {
|
|
|
totalSql += " AND d.charge_type ='" + chargeType + "'";
|
|
|
|
|
|
}
|
|
|
} else {
|
|
|
//不传号别过滤不为为空
|
|
|
totalSql += " AND d.charge_type is not null ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(dept)) {
|
|
|
totalSql += " AND h.dept_code = '" + dept + "' ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(nameKey)) {
|
|
|
totalSql += " AND d.name like '%" + nameKey + "%' ";
|
|
|
}
|
|
|
//过滤排班
|
|
|
if(StringUtils.isNotBlank(iswork)){
|
|
|
if("1".equals(iswork)){
|
|
|
totalSql +=" AND d.id IN ( " +
|
|
|
" SELECT DISTINCT " +
|
|
|
" t.doctor " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.work_date LIKE '%"+date+"%' " +
|
|
|
" )";
|
|
|
}else{
|
|
|
totalSql +=" AND d.id NOT IN ( " +
|
|
|
" SELECT DISTINCT " +
|
|
|
" t.doctor " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.work_date LIKE '%"+date+"%' " +
|
|
|
" )";
|
|
|
}
|
|
|
|
|
|
}
|
|
|
List<Map<String, Object>> rstotal = hibenateUtils.createSQLQuery(totalSql);
|
|
|
|
|
|
Long count = 0L;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
count = hibenateUtils.objTransformLong(rstotal.get(0).get("total"));
|
|
|
}
|
|
|
|
|
|
String sql = "SELECT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.photo AS \"photo\", " +
|
|
|
" d.name AS \"name\", " +
|
|
|
" d.expertise AS \"expertise\"," +
|
|
|
" d.introduce AS \"introduce\"," +
|
|
|
" d.job_title_code AS \"jobTitleCode\", " +
|
|
|
" d.job_title_name AS \"jobTitleName\"," +
|
|
|
" d.charge_type AS \"chargeType\"," +
|
|
|
" h.dept_code AS \"deptCode\"," +
|
|
|
" h.dept_Name AS \"deptName\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON h.doctor_code = d.id " +
|
|
|
" JOIN base_doctor_role r ON r.doctor_code = d.id " +
|
|
|
" WHERE " +
|
|
|
" h.org_code = '" + orgCode + "'" +
|
|
|
" AND r.role_code ='specialist'";
|
|
|
if (StringUtils.isNotBlank(chargeType)) {
|
|
|
if ("all".equals(chargeType)) {
|
|
|
//不过滤号别
|
|
|
} else {
|
|
|
sql += " AND d.charge_type ='" + chargeType + "'";
|
|
|
}
|
|
|
} else {
|
|
|
//不传号别过滤不为为空
|
|
|
sql += " AND d.charge_type is not null ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(dept)) {
|
|
|
sql += " AND h.dept_code = '" + dept + "' ";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(nameKey)) {
|
|
|
sql += " AND d.name like '%" + nameKey + "%' ";
|
|
|
}
|
|
|
//过滤排班
|
|
|
if(StringUtils.isNotBlank(iswork)){
|
|
|
if("1".equals(iswork)){
|
|
|
sql +=" AND d.id IN ( " +
|
|
|
" SELECT DISTINCT " +
|
|
|
" t.doctor " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.work_date LIKE '%"+date+"%' " +
|
|
|
" )";
|
|
|
}else{
|
|
|
sql +=" AND d.id NOT IN ( " +
|
|
|
" SELECT DISTINCT " +
|
|
|
" t.doctor " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.work_date LIKE '%"+date+"%' " +
|
|
|
" )";
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
List<Map<String, Object>> list = hibenateUtils.createSQLQuery(sql,page,size);
|
|
|
if (list != null && list.size() > 0) {
|
|
|
//获取排班
|
|
|
for (Map<String, Object> doctor : list) {
|
|
|
String id = (String) doctor.get("id");
|
|
|
List<WlyyDoctorWorkTimeDO> workTimeDOs = doctorWorkTimeDao.findDoctorWorkTimeByMonth(id, "%" + date + "%");
|
|
|
if (workTimeDOs != null && workTimeDOs.size() > 0) {
|
|
|
doctor.put("isScheduling", true);
|
|
|
} else {
|
|
|
doctor.put("isScheduling", false);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
logger.info("findDoctorWithMouthWork :" + sql);
|
|
|
return MixEnvelop.getSuccessListWithPage(BaseHospitalRequestMapping.Prescription.api_success, list, page, size, count);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 挂号
|
|
|
*
|
|
|
* @return
|
|
|
*/
|
|
|
public JSONObject registerOutPatient(String outPatientId, String doctor) throws Exception {
|
|
|
|
|
|
WlyyOutpatientDO outpatientDO = outpatientDao.findOne(outPatientId);
|
|
|
|
|
|
|
|
|
DoctorMappingDO doctorMappingDO = doctorMappingService.findMappingCode(doctor, outpatientDO.getHospital());
|
|
|
if (doctorMappingDO == null) {
|
|
|
throw new RuntimeException("未找到医生映射信息");
|
|
|
}
|
|
|
|
|
|
BasePatientDO basePatientDO = basePatientDao.findById(outpatientDO.getPatient());
|
|
|
|
|
|
Integer manageType = 1;//处理类型（1-新增 2-修改 3-删除） 必填
|
|
|
|
|
|
//查找居民当天挂号记录
|
|
|
String date = DateUtil.dateToStr(new Date(), "yyyy-MM-dd");
|
|
|
List<WlyyPatientRegisterDO> patientRegisterDOs = patientRegisterDao.findByPatientAndDateAndDoctor(outpatientDO.getPatient(), date, doctor);
|
|
|
if (patientRegisterDOs != null && patientRegisterDOs.size() > 0) {
|
|
|
WlyyPatientRegisterDO registerDO = patientRegisterDOs.get(0);
|
|
|
//判断是否已经挂号，如果已经挂号
|
|
|
if (StringUtils.isNotBlank(registerDO.getConNo()) && StringUtils.isNotBlank(registerDO.getRegisterNo())) {
|
|
|
|
|
|
JSONObject res = new JSONObject();
|
|
|
res.put("@RESULT", "0");
|
|
|
logger.info("已经挂号 res: " + res.toString());
|
|
|
|
|
|
//更新挂号流水号
|
|
|
outpatientDO.setConNo(registerDO.getConNo());
|
|
|
outpatientDO.setRegisterNo(registerDO.getRegisterNo());
|
|
|
outpatientDO.setAdmDate(registerDO.getCreateTime());
|
|
|
outpatientDao.save(outpatientDO);
|
|
|
//调用电子病历注册
|
|
|
manageType = 2;
|
|
|
registDianziBingli(outpatientDO, basePatientDO, manageType, registerDO.getRegisterNo(), registerDO.getConNo());
|
|
|
return res;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
JSONObject rs = entranceService.BS10111(outpatientDO.getCardNo(), doctorMappingDO.getMappingCode(), outpatientDO.getDept(), null, outpatientDO.getWinNo(), demoFlag);
|
|
|
JSONObject res = rs.getJSONObject("resquest");
|
|
|
logger.info("挂号结果 res: " + res.toString());
|
|
|
String rsCode = res.getString("@RESULT");
|
|
|
|
|
|
if ("0".equals(rsCode)) {
|
|
|
//存储挂号号
|
|
|
// {"resquest":{"@RESULT":"0","@MSG":"完成","@serial_no":"47770476","@times":"28"}}
|
|
|
String serialNo = (String) res.get("@serial_no");
|
|
|
outpatientDO.setRegisterNo(serialNo);
|
|
|
String conNo = (String) res.get("@times");
|
|
|
outpatientDO.setConNo(conNo);
|
|
|
outpatientDO.setAdmDate(new Date());
|
|
|
logger.info("挂号流水 @serial_no: " + serialNo + " @times: " + conNo);
|
|
|
outpatientDao.save(outpatientDO);
|
|
|
|
|
|
//存储就诊记录
|
|
|
WlyyPatientRegisterDO registerDO = new WlyyPatientRegisterDO();
|
|
|
// 存储挂号医生与挂号科室
|
|
|
registerDO.setDoctor(outpatientDO.getDoctor());
|
|
|
registerDO.setDoctorName(outpatientDO.getDoctorName());
|
|
|
registerDO.setDept(outpatientDO.getDept());
|
|
|
registerDO.setDeptName(outpatientDO.getDeptName());
|
|
|
|
|
|
registerDO.setPatient(outpatientDO.getPatient());
|
|
|
registerDO.setPatientName(outpatientDO.getPatientName());
|
|
|
//挂号流水号与挂号次数
|
|
|
registerDO.setRegisterNo(serialNo);
|
|
|
registerDO.setConNo(conNo);
|
|
|
registerDO.setCreateTime(new Date());
|
|
|
registerDO.setDate(DateUtil.dateToStr(new Date(), "yyyy-MM-dd"));
|
|
|
patientRegisterDao.save(registerDO);
|
|
|
|
|
|
//调用电子病历注册
|
|
|
manageType = 1;//处理类型（1-新增 2-修改 3-删除） 必填
|
|
|
registDianziBingli(outpatientDO, basePatientDO, manageType, registerDO.getRegisterNo(), registerDO.getConNo());
|
|
|
|
|
|
} else if ("-2".equals(rsCode)) {
|
|
|
|
|
|
String serialNo = (String) res.get("@serial_no");
|
|
|
outpatientDO.setRegisterNo(serialNo);
|
|
|
String conNo = (String) res.get("@times");
|
|
|
outpatientDO.setConNo(conNo);
|
|
|
outpatientDO.setAdmDate(new Date());
|
|
|
logger.info("挂号流水 @serial_no: " + serialNo + " @times: " + conNo);
|
|
|
outpatientDao.save(outpatientDO);
|
|
|
|
|
|
//存储就诊记录
|
|
|
WlyyPatientRegisterDO registerDO = new WlyyPatientRegisterDO();
|
|
|
|
|
|
registerDO.setDoctor(outpatientDO.getDoctor());
|
|
|
registerDO.setDoctorName(outpatientDO.getDoctorName());
|
|
|
registerDO.setDept(outpatientDO.getDept());
|
|
|
registerDO.setDeptName(outpatientDO.getDeptName());
|
|
|
|
|
|
registerDO.setPatient(outpatientDO.getPatient());
|
|
|
registerDO.setPatientName(outpatientDO.getPatientName());
|
|
|
registerDO.setRegisterNo(serialNo);
|
|
|
registerDO.setConNo(conNo);
|
|
|
registerDO.setCreateTime(new Date());
|
|
|
registerDO.setDate(DateUtil.dateToStr(new Date(), "yyyy-MM-dd"));
|
|
|
|
|
|
patientRegisterDao.save(registerDO);
|
|
|
|
|
|
//调用电子病历注册
|
|
|
manageType = 1;//处理类型（1-新增 2-修改 3-删除） 必填
|
|
|
registDianziBingli(outpatientDO, basePatientDO, manageType, registerDO.getRegisterNo(), registerDO.getConNo());
|
|
|
}
|
|
|
|
|
|
|
|
|
//保存日志
|
|
|
WlyyHttpLogDO log = new WlyyHttpLogDO();
|
|
|
log.setCode("registerOutPatient");
|
|
|
log.setName("挂号");
|
|
|
log.setPatient(outpatientDO.getPatient());
|
|
|
log.setDoctor(doctor);
|
|
|
log.setResponse(rs.toString());
|
|
|
log.setRequest("outPatientId=" + outPatientId + "&doctor=" + doctor);
|
|
|
log.setStatus(rsCode);
|
|
|
log.setCreateTime(new Date());
|
|
|
wlyyHttpLogDao.save(log);
|
|
|
return res;
|
|
|
}
|
|
|
|
|
|
public String registDianziBingli(WlyyOutpatientDO outpatientDO, BasePatientDO basePatientDO, Integer manageType, String RegisterSN, String registerCon) throws Exception {
|
|
|
|
|
|
//调用电子病历接口注册居民信息
|
|
|
String patientMappingCode = patientMappingService.findHisPatNoByIdCard(basePatientDO.getIdcard());
|
|
|
DoctorMappingDO doctorMappingDO = doctorMappingService.findMappingCode(outpatientDO.getDoctor(), outpatientDO.getHospital());
|
|
|
Map<String, String> params = new HashedMap();
|
|
|
params.put("type", "PatientInfo");
|
|
|
|
|
|
String _xmlStr = "<?xml version='1.0' encoding='UTF-8'?>" +
|
|
|
"<HtRequest>" +
|
|
|
"<OutRegister>" +
|
|
|
"<RecordFlow>" + outpatientDO.getId() + "</RecordFlow>" +
|
|
|
"<RegisterSN>" + RegisterSN + "</RegisterSN>" +
|
|
|
"<TreatDate>" + DateUtil.getStringDate("yyyyMMdd") + "</TreatDate>" +
|
|
|
"<RegisterDeptCode>" + outpatientDO.getDept() + "</RegisterDeptCode>" +
|
|
|
"<RegisterDeptName>" + outpatientDO.getDeptName() + "</RegisterDeptName>" +
|
|
|
"<RegisterDoctorID>" + doctorMappingDO.getMappingCode() + "</RegisterDoctorID>" +
|
|
|
"<RegisterDoctorName>" + doctorMappingDO.getDoctorName() + "</RegisterDoctorName>" +
|
|
|
"<DutyID></DutyID>" +
|
|
|
"<DutyName></DutyName>" +
|
|
|
"<OutPatientTime></OutPatientTime>" +
|
|
|
"<NumClassCode></NumClassCode>" +
|
|
|
"<NumClassName></NumClassName>" +
|
|
|
"<JoinGroupCode></JoinGroupCode>" +
|
|
|
"<JoinGroupName></JoinGroupName>" +
|
|
|
"<NumClassNO></NumClassNO>" +
|
|
|
"<AppointmentDateTime></AppointmentDateTime>" +
|
|
|
"<AppointSN></AppointSN>" +
|
|
|
"<Pid>" + patientMappingCode + "</Pid>" +
|
|
|
"<CardNO>" + outpatientDO.getCardNo() + "</CardNO>\n" +
|
|
|
"<PatientName>" + basePatientDO.getName() + "</PatientName>" +
|
|
|
"<SexCode>" + basePatientDO.getSex() + "</SexCode>";
|
|
|
if (1 == basePatientDO.getSex()) {
|
|
|
_xmlStr = _xmlStr + "<Sex>男</Sex>";
|
|
|
} else {
|
|
|
_xmlStr = _xmlStr + "<Sex>女</Sex>";
|
|
|
}
|
|
|
_xmlStr = _xmlStr + "<Age>" + IdCardUtil.getAgeForIdcard(basePatientDO.getIdcard()) + "</Age>" +
|
|
|
"<AgeDesc>" + IdCardUtil.getAgeForIdcard(basePatientDO.getIdcard()) + "岁</AgeDesc>" +
|
|
|
"<PatientClass></PatientClass>" +
|
|
|
"<FeeTypeCode></FeeTypeCode>" +
|
|
|
"<FeeTypeName></FeeTypeName>" +
|
|
|
"<MedicalInsuranceType></MedicalInsuranceType>" +
|
|
|
"<IsFirst>N</IsFirst>" +
|
|
|
"<RegisterDateTime>20200121</RegisterDateTime>" +
|
|
|
"<RegisterUserID>" + patientMappingCode + "</RegisterUserID>" +
|
|
|
"<RegisterUserName></RegisterUserName>" +
|
|
|
"<OutStatus>20</OutStatus>" +
|
|
|
"<ModifierID></ModifierID>" +
|
|
|
"<Modifier></Modifier>" +
|
|
|
"<ModifyTime></ModifyTime>" +
|
|
|
"<RetreatDateTime></RetreatDateTime>" +
|
|
|
"<RetreatUserID></RetreatUserID>" +
|
|
|
"<RetreatUserName></RetreatUserName>" +
|
|
|
"<PaymentMethodCode></PaymentMethodCode>" +
|
|
|
"<PaymentMethod></PaymentMethod>" +
|
|
|
"<RegisterFee></RegisterFee>" +
|
|
|
"<MedicalFee></MedicalFee>" +
|
|
|
"<OtherFee></OtherFee>" +
|
|
|
"<TotalFee></TotalFee>" +
|
|
|
"<MedicalFloor>N</MedicalFloor>" +
|
|
|
"<MedicalAddress></MedicalAddress>" +
|
|
|
"<LastDeptCode></LastDeptCode>" +
|
|
|
"<LastDeptName></LastDeptName>" +
|
|
|
"<LastDoctorID></LastDoctorID>" +
|
|
|
"<LastDoctorName></LastDoctorName>" +
|
|
|
"<LastTreatDateTime></LastTreatDateTime>" +
|
|
|
"<LastOpid></LastOpid>" +
|
|
|
"<NumTypeCode>0</NumTypeCode>" +
|
|
|
"<NumTypeName></NumTypeName>" +
|
|
|
"<RegisterSource>1</RegisterSource>" +
|
|
|
"<AcctNO></AcctNO>" +
|
|
|
"<IsAcct>N</IsAcct>" +
|
|
|
"<ManageType>" + manageType + "</ManageType>" +
|
|
|
"<Times>" + registerCon + "</Times>" +
|
|
|
"</OutRegister>" +
|
|
|
"<PatientInfo>" +
|
|
|
"<RecordFlow>" + outpatientDO.getId() + "</RecordFlow>" +
|
|
|
"<PID>" + patientMappingCode + "</PID></PatientInfo></HtRequest>";
|
|
|
|
|
|
|
|
|
// String xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
|
|
|
// "<HtRequest >" +
|
|
|
// "<PatientInfo>" +
|
|
|
// "<RecordFlow>"+outPatientId+"</RecordFlow >" +
|
|
|
// "<PID>"+patientMappingCode+"</PID>" +
|
|
|
// "<InsuranceNo>"+basePatientDO.getIdcard()+"</InsuranceNo>" +
|
|
|
// "<PatientName>"+basePatientDO.getName()+"</PatientName>" +
|
|
|
// "<TmpFlag>正式</TmpFlag>" +
|
|
|
// "<LastName>"+basePatientDO.getName().substring(1,basePatientDO.getName().length())+"</LastName>" +
|
|
|
// "<FirstName>"+basePatientDO.getName().substring(0,1)+"</FirstName>" +
|
|
|
// "<PY>"+ PinYinUtils.getUpEname(basePatientDO.getName())+"</PY>" +
|
|
|
// "<WB></WB>" +
|
|
|
// "<SexCode>"+basePatientDO.getSex()+"</SexCode>";
|
|
|
// if(1 == basePatientDO.getSex()){
|
|
|
// xmlStr = xmlStr + "<Sex>男</Sex>";
|
|
|
// }else{
|
|
|
// xmlStr = xmlStr + "<Sex>女</Sex>";
|
|
|
// }
|
|
|
//
|
|
|
// xmlStr = xmlStr + "<DateOfBirth>"+DateUtil.dateToStrShort(IdCardUtil.getBirthdayForIdcard(basePatientDO.getIdcard()))+"</DateOfBirth>" +
|
|
|
// "<TimeOfBirth></TimeOfBirth>" +
|
|
|
// "<MarriageStatusCode></MarriageStatusCode>" +
|
|
|
// "<MarriageStatus></MarriageStatus>" +
|
|
|
// "<OccupationCode></OccupationCode>" +
|
|
|
// "<Occupation></Occupation>" +
|
|
|
// "<NationalityCode></NationalityCode>" +
|
|
|
// "<Nationality></Nationality>" +
|
|
|
// "<CountryCode>CN</CountryCode>" +
|
|
|
// "<Country>中国</Country>" +
|
|
|
// "<FormalSchoolingCode></FormalSchoolingCode>" +
|
|
|
// "<FormalSchooling></FormalSchooling>" +
|
|
|
// "<Religion></Religion>" +
|
|
|
// "<BirthPlaceCode></BirthPlaceCode>" +
|
|
|
// "<BirthPlace></BirthPlace>" +
|
|
|
// "<NativePlaceCode></NativePlaceCode>" +
|
|
|
// "<NativePlace></NativePlace>" +
|
|
|
// "<BloodType></BloodType>" +
|
|
|
// "<CertTypeCode>111</CertTypeCode>" +
|
|
|
// "<CertType>身份证</CertType>" +
|
|
|
// "<CertNo>"+basePatientDO.getIdcard()+"</CertNo>" +
|
|
|
// "<PatientClassCode></PatientClassCode>" +
|
|
|
// "<PatientClass></PatientClass>" +
|
|
|
// "<FeeTypeCode></FeeTypeCode>" +
|
|
|
// "<FeeType></FeeType>" +
|
|
|
// "<Company></Company>" +
|
|
|
// "<PublicExpenseNo></PublicExpenseNo>" +
|
|
|
// "<ContractUnitCode></ContractUnitCode> " +
|
|
|
// "<ContractUnit></ContractUnit>" +
|
|
|
// "<BusinessAddressCode></BusinessAddressCode>" +
|
|
|
// "<BusinessAddress></BusinessAddress>" +
|
|
|
// "<BusinessPostCode></BusinessPostCode>" +
|
|
|
// "<BusinessPhone></BusinessPhone>" +
|
|
|
// "<HomeAddressCode></HomeAddressCode>" +
|
|
|
// "<HomeAddress></HomeAddress>" +
|
|
|
// "<HomePostCode></HomePostCode>" +
|
|
|
// "<MobilePhone></MobilePhone>" +
|
|
|
// "<Contact></Contact>" +
|
|
|
// "<RelationCode></RelationCode>" +
|
|
|
// "<Relation></Relation>" +
|
|
|
// "<ContactEmail></ContactEmail>" +
|
|
|
// "<ContactMethod></ContactMethod>" +
|
|
|
// "<VIPType></VIPType>" +
|
|
|
// "<OperatorID></OperatorID>" +
|
|
|
// "<Operator></Operator>" +
|
|
|
// "<OperatorTime>0</OperatorTime>" +
|
|
|
// "<Available></Available>" +
|
|
|
// "<ManageType>"+manageType+"</ManageType>" +
|
|
|
// "<InsuranceTypeCode></InsuranceTypeCode>" +
|
|
|
// "<InsuranceType></InsuranceType>" +
|
|
|
// "<RegisteredAddressCode></RegisteredAddressCode>" +
|
|
|
// "<RegisteredAddress></RegisteredAddress>" +
|
|
|
// "<ContactAddressCode></ContactAddressCode>" +
|
|
|
// "<ContactAddress></ContactAddress>" +
|
|
|
// "<RegisteredPostCode></RegisteredPostCode>" +
|
|
|
// "<ContactPostcode></ContactPostcode>" +
|
|
|
// "<BloodType></BloodType>" +
|
|
|
// "<RhBloodType></RhBloodType>" +
|
|
|
// "</PatientInfo>" +
|
|
|
// "</HtRequest>";
|
|
|
String returnValue = "";
|
|
|
params.put("xmlStr", _xmlStr);
|
|
|
|
|
|
returnValue = WebserviceUtil.post("http://192.10.33.34:9080/HtMzWebService/services/Manage",
|
|
|
"http://business.htemr.haitaiinc.com",
|
|
|
"manageAdt",
|
|
|
params);
|
|
|
|
|
|
logger.info("调用电子病历注册接口请求成功，返回值xmlstr:" + returnValue);
|
|
|
|
|
|
return returnValue;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取诊断
|
|
|
*
|
|
|
* @param pyKey
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray getICD10(String pyKey) throws Exception {
|
|
|
return entranceService.MS25001(pyKey, demoFlag);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取药品
|
|
|
*
|
|
|
* @return
|
|
|
`prescription_id` varchar(50) DEFAULT NULL COMMENT '处方code 关联表wlyy_prescription code',
|
|
|
`drug_no` varchar(50) DEFAULT NULL COMMENT '药品编号',
|
|
|
`drug_name` varchar(50) DEFAULT NULL COMMENT '药品名称',
|
|
|
`disp_deposite` varchar(50) DEFAULT NULL COMMENT '库房号',
|
|
|
`dosage` varchar(50) DEFAULT NULL COMMENT '药量',
|
|
|
`quantity` varchar(50) DEFAULT NULL COMMENT '数量',
|
|
|
`unit` varchar(50) DEFAULT NULL COMMENT '用量单位',
|
|
|
`unit_name` varchar(50) DEFAULT NULL COMMENT '用量单位中文',
|
|
|
`pack_unit` varchar(50) DEFAULT NULL COMMENT '包装单位',
|
|
|
`pack_unit_name` varchar(50) DEFAULT NULL COMMENT '包装单位名称',
|
|
|
`usage_code` varchar(50) DEFAULT NULL COMMENT '频率code',
|
|
|
`usage_name` varchar(50) DEFAULT NULL COMMENT '频次名称',
|
|
|
`supply_code` varchar(50) DEFAULT NULL COMMENT '用法',
|
|
|
`supply_name` varchar(50) DEFAULT NULL COMMENT '用法名称',
|
|
|
`days` varchar(50) DEFAULT NULL COMMENT '天数',
|
|
|
`frequency` varchar(50) DEFAULT NULL COMMENT '组号',
|
|
|
`serial` varchar(50) DEFAULT NULL COMMENT '药品序列号',
|
|
|
`group_no` varchar(50) DEFAULT NULL COMMENT '库房号',
|
|
|
`specification` varchar(50) DEFAULT NULL COMMENT '规格（10mgx10片/盒）',
|
|
|
`pack_retprice` double(10,4) DEFAULT NULL COMMENT '包装价格',
|
|
|
`herbal_count` varchar(10) DEFAULT NULL COMMENT '草药数量',
|
|
|
`post_count` varchar(10) DEFAULT NULL COMMENT '贴数',
|
|
|
`comm` varchar(50) DEFAULT NULL COMMENT '中药用法',
|
|
|
`del` int(2) DEFAULT '1' COMMENT '1可用 0删除',
|
|
|
`drug_place` varchar(100) DEFAULT NULL COMMENT '药品产地',
|
|
|
`pack_quantity` int(11) DEFAULT NULL COMMENT '包装数量',
|
|
|
PRIMARY KEY (`id`),
|
|
|
*/
|
|
|
public JSONArray getDrugDictionary(String chargeCode, String pyKey, String winNo, String groupNo) throws Exception {
|
|
|
return entranceService.MS53001(chargeCode, pyKey, "0", winNo, "0", groupNo, demoFlag);
|
|
|
JSONArray mapList = ykyyEntranceService.findYkYpxx(chargeCode, null, null, pyKey);
|
|
|
JSONArray array = new JSONArray();
|
|
|
for (int i=0;i<mapList.size();i++){
|
|
|
JSONObject map = mapList.getJSONObject(i);
|
|
|
JSONObject object = new JSONObject();
|
|
|
object.put("charge_code",map.get("ypdm"));
|
|
|
object.put("drugname",map.get("ypmc"));
|
|
|
object.put("specification",map.get("yfgg"));
|
|
|
object.put("pack_unit_name",map.get("yfdw"));
|
|
|
object.put("pack_size",map.get("yfbz"));
|
|
|
object.put("yfsx",map.get("yfsx"));//药房属性
|
|
|
object.put("ypjl",map.get("ypjl"));//药剂量
|
|
|
object.put("jldw",map.get("jldw"));//剂量单位
|
|
|
object.put("py_code",map.get("pydm"));//拼音代码
|
|
|
object.put("fyfs",map.get("fyfs"));//发药方式
|
|
|
object.put("supply_code",map.get("gyff"));//给药方式
|
|
|
object.put("yfzf",map.get("yfzf"));//药房作废
|
|
|
object.put("supply_name",map.get("gyffmc"));//给药方式名称
|
|
|
object.put("ybfl",map.get("ybfl"));//医保分类
|
|
|
object.put("retprice",map.get("lsjg"));//零售价格
|
|
|
object.put("kcsl",map.get("kcsl"));//库存
|
|
|
object.put("ypcd",map.get("ypcd"));//产地
|
|
|
object.put("zfpb",map.get("zfpb"));//作废判别
|
|
|
object.put("jbywbz",map.get("jbywbz"));//基本药物标志
|
|
|
object.put("ydyp",map.get("ydyp"));//药店药品
|
|
|
object.put("ypmc2",map.get("ypmc2"));//药品名称2
|
|
|
array.add(object);
|
|
|
}
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1190,7 +363,17 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
* 获取药品用法
|
|
|
*/
|
|
|
public JSONArray getDrugUse(String drugNo, String pyKey) throws Exception {
|
|
|
return entranceService.BS10110(drugNo, pyKey, demoFlag);
|
|
|
|
|
|
JSONArray mapList = ykyyEntranceService.findYpyf(pyKey);
|
|
|
JSONArray array = new JSONArray();
|
|
|
for (int i=0;i<mapList.size();i++){
|
|
|
JSONObject map = mapList.getJSONObject(i);
|
|
|
JSONObject object = new JSONObject();
|
|
|
object.put("supply_code",map.get("pydm"));
|
|
|
object.put("supply_name",map.get("xmmc"));
|
|
|
array.add(object);
|
|
|
}
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@ -1199,3320 +382,77 @@ public class YkyyPrescriptionService extends BaseJpaService<WlyyPrescriptionDO,
|
|
|
* @return
|
|
|
*/
|
|
|
public JSONArray getDrugFrequency() throws Exception {
|
|
|
return entranceService.MS30012(demoFlag);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 检查模板选择接口
|
|
|
*
|
|
|
* @param bz_code
|
|
|
* @param flag
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray getJcmb(String bz_code, String tc_no, String flag) throws Exception {
|
|
|
return entranceService.BS25033(bz_code, tc_no, flag, demoFlag);
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 检验选择接口
|
|
|
*
|
|
|
* @param bz_code
|
|
|
* @param flag
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray getJymb(String bz_code, String tc_no, String flag) throws Exception {
|
|
|
return entranceService.BS20030(bz_code, tc_no, flag, demoFlag);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 套餐选择接口
|
|
|
*
|
|
|
* @param bz_code
|
|
|
* @param flag
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray getTcxz(String bz_code, String tc_no, String flag) throws Exception {
|
|
|
return entranceService.MS02017(bz_code, tc_no, flag, demoFlag);
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 套餐子项目接口
|
|
|
*
|
|
|
* @param parent_code 检查检验项目的charge_code
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray getTcChild(String parent_code) throws Exception {
|
|
|
return entranceService.MS02015(parent_code, demoFlag);
|
|
|
JSONArray mapList = ykyyEntranceService.findSypc(null);
|
|
|
JSONArray array = new JSONArray();
|
|
|
for (int i=0;i<mapList.size();i++){
|
|
|
JSONObject map = mapList.getJSONObject(i);
|
|
|
JSONObject object = new JSONObject();
|
|
|
object.put("FREQ_CODE",map.get("pcmc"));
|
|
|
object.put("FREQ_NAME",map.get("pcmc1"));
|
|
|
array.add(object);
|
|
|
}
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 项目子项目接口
|
|
|
* 获取检查检验
|
|
|
* "action": "select",
|
|
|
"name": "丙型肝炎RNA测定(全自动荧光定量分析)",
|
|
|
"charge_unit": "项",
|
|
|
"charge_amount": "150",
|
|
|
"py_code": "BXGYRNAC",
|
|
|
"d_code": "GGEORNAI",
|
|
|
"code": "393333",
|
|
|
"exec_unit": "2160000",
|
|
|
"win_no": "0",
|
|
|
"exec_unit_name": "检验科"
|
|
|
*
|
|
|
* @param zd_charge_code
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray getInsChild(String zd_charge_code) throws Exception {
|
|
|
return entranceService.MS02016(zd_charge_code, demoFlag);
|
|
|
public JSONArray getInspectionDictionary(String pyKey, String codes, String winNo) throws Exception {
|
|
|
JSONArray mapList = ykyyEntranceService.findYkJcxm(pyKey);
|
|
|
JSONArray array = new JSONArray();
|
|
|
for (int i=0;i<mapList.size();i++){
|
|
|
JSONObject map = mapList.getJSONObject(i);
|
|
|
JSONObject object = new JSONObject();
|
|
|
object.put("name",map.get("xmmc"));
|
|
|
object.put("code",map.get("zlxmid"));
|
|
|
object.put("py_code",map.get("pydm"));
|
|
|
object.put("wbdm",map.get("wbdm"));
|
|
|
object.put("jxdm",map.get("jxdm"));
|
|
|
object.put("qtdm",map.get("qtdm"));
|
|
|
object.put("ydyzlb",map.get("ydyzlb"));
|
|
|
object.put("mlbh",map.get("mlbh"));
|
|
|
object.put("zxpc",map.get("zxpc"));
|
|
|
object.put("jfpc",map.get("jfpc"));
|
|
|
object.put("jsfs",map.get("jsfs"));
|
|
|
object.put("jszq",map.get("jszq"));
|
|
|
object.put("charge_unit",map.get("jsdw"));
|
|
|
object.put("syxb",map.get("syxb"));
|
|
|
object.put("mxsy",map.get("mxsy"));
|
|
|
object.put("zysy",map.get("zysy"));//住院使用
|
|
|
object.put("tjsy",map.get("tjsy"));
|
|
|
object.put("zxlb",map.get("zxlb"));//执行类别
|
|
|
object.put("exec_unit",map.get("zxks"));//执行科室
|
|
|
object.put("zxgzid",map.get("zxgzid"));//执行规则
|
|
|
object.put("ywzx",map.get("ywzx"));
|
|
|
object.put("zxap",map.get("zxap"));
|
|
|
object.put("cpzx",map.get("cpzx"));
|
|
|
object.put("szzx",map.get("szzx"));
|
|
|
object.put("jjlx",map.get("jjlx"));
|
|
|
object.put("ycxzsl",map.get("ycxzsl"));
|
|
|
object.put("yblx",map.get("yblx"));
|
|
|
object.put("zxbz",map.get("zxbz"));
|
|
|
object.put("txid",map.get("txid"));
|
|
|
object.put("bgbh",map.get("bgbh"));
|
|
|
object.put("czsy",map.get("czsy"));
|
|
|
object.put("lzsy",map.get("lzsy"));
|
|
|
object.put("lccs",map.get("lccs"));
|
|
|
object.put("bwbz",map.get("bwbz"));
|
|
|
object.put("yblb",map.get("yblb"));
|
|
|
array.add(object);
|
|
|
}
|
|
|
return array;
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 获取检查检验
|
|
|
*
|
|
|
* @return
|
|
|
*/
|
|
|
public JSONArray getInspectionDictionary(String pyKey, String codes, String winNo) throws Exception {
|
|
|
JSONArray rs = entranceService.MS25002(pyKey, codes, winNo, demoFlag);
|
|
|
if (rs != null && rs.size() > 0) {
|
|
|
|
|
|
//设置科室翻译名称字典，减少循环层级降低循环次数
|
|
|
List<DictHospitalDeptDO> depts = dictHospitalDeptDao.findByOrgCode("350211A1002");
|
|
|
Map<String, String> deptDictMap = new HashedMap();
|
|
|
for (DictHospitalDeptDO dp : depts) {
|
|
|
deptDictMap.put(dp.getCode(), dp.getName());
|
|
|
}
|
|
|
|
|
|
//翻译执行科室
|
|
|
for (int i = 0; i < rs.size(); i++) {
|
|
|
JSONObject dict = (JSONObject) rs.get(i);
|
|
|
String dept = dict.getString("exec_unit");
|
|
|
if (StringUtils.isNotBlank(dept)) {
|
|
|
String deptName = deptDictMap.get(dept);
|
|
|
if (StringUtils.isNotBlank(deptName)) {
|
|
|
dict.put("exec_unit_name", deptName);
|
|
|
} else {
|
|
|
dict.put("exec_unit_name", "");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 下诊断，线上开方
|
|
|
*
|
|
|
* @param outPatientId
|
|
|
* @param advice
|
|
|
* @param type 1带处方，2不带处方
|
|
|
* @param infoJsons
|
|
|
* @param diagnosisJson
|
|
|
* @return
|
|
|
*/
|
|
|
public Map<String, Object> makeDiagnosis(String outPatientId, String advice, String type, String infoJsons, String diagnosisJson, String inspectionJson) throws Exception {
|
|
|
|
|
|
Map<String, Object> result = new HashedMap();
|
|
|
|
|
|
//获取门诊记录
|
|
|
WlyyOutpatientDO outpatientDO = outpatientDao.findOne(outPatientId);
|
|
|
//设置医嘱
|
|
|
outpatientDO.setAdvice(advice);
|
|
|
|
|
|
//========================处方操作=============================================================
|
|
|
//创建处方记录
|
|
|
List<WlyyPrescriptionDO> prescriptionDOs = prescriptionDao.findByOutpatientId(outPatientId);
|
|
|
WlyyPrescriptionDO prescriptionDO = null;
|
|
|
if (prescriptionDOs != null && prescriptionDOs.size() > 0) {
|
|
|
prescriptionDO = prescriptionDOs.get(0);
|
|
|
} else {
|
|
|
prescriptionDO = new WlyyPrescriptionDO();
|
|
|
prescriptionDO.setOutpatientId(outPatientId);
|
|
|
}
|
|
|
prescriptionDO.setCreateTime(new Date());
|
|
|
prescriptionDO.setStatus(10);
|
|
|
prescriptionDO.setPatientCode(outpatientDO.getPatient());
|
|
|
prescriptionDO.setPatientName(outpatientDO.getPatientName());
|
|
|
prescriptionDO.setDoctor(outpatientDO.getDoctor());
|
|
|
prescriptionDO.setDoctorName(outpatientDO.getDoctorName());
|
|
|
WlyyPrescriptionDO prescription = prescriptionDao.save(prescriptionDO);
|
|
|
|
|
|
//========================处方操作结束=============================================================
|
|
|
|
|
|
//加入处方状态变更流水日志
|
|
|
prescriptionLogService.addPrescriptionLog(prescription.getId(), 10, 2, outpatientDO.getDoctor(), outpatientDO.getDoctorName(), "", new Date());
|
|
|
|
|
|
//============================下诊断==============================================================
|
|
|
//删除之前诊断
|
|
|
List<WlyyPrescriptionDiagnosisDO> ds = prescriptionDiagnosisDao.findByPrescriptionId(prescription.getId());
|
|
|
if (ds != null && ds.size() > 0) {
|
|
|
prescriptionDiagnosisDao.delete(ds);
|
|
|
}
|
|
|
|
|
|
List<WlyyPrescriptionDiagnosisDO> diagnosisDOs = (List<WlyyPrescriptionDiagnosisDO>) com.alibaba.fastjson.JSONArray.parseArray(diagnosisJson, WlyyPrescriptionDiagnosisDO.class);
|
|
|
String Icd10 = "";
|
|
|
String Icd10Name = "";
|
|
|
for (WlyyPrescriptionDiagnosisDO diagnosisDO : diagnosisDOs) {
|
|
|
if ("1".equals(diagnosisDO.getType())) {
|
|
|
Icd10 = diagnosisDO.getCode() + "," + Icd10;
|
|
|
Icd10Name += diagnosisDO.getName() + "," + Icd10Name;
|
|
|
} else {
|
|
|
Icd10 += diagnosisDO.getCode() + ",";
|
|
|
Icd10Name += diagnosisDO.getName() + ",";
|
|
|
}
|
|
|
diagnosisDO.setPrescriptionId(prescription.getId());
|
|
|
}
|
|
|
prescriptionDiagnosisDao.save(diagnosisDOs);
|
|
|
|
|
|
//存储icd10
|
|
|
Icd10 = Icd10.substring(0, Icd10.length() - 1);
|
|
|
Icd10Name = Icd10Name.substring(0, Icd10Name.length() - 1);
|
|
|
outpatientDO.setIcd10(Icd10);
|
|
|
outpatientDO.setIcd10Name(Icd10Name);
|
|
|
outpatientDao.save(outpatientDO);
|
|
|
//============================下诊断end==============================================================
|
|
|
|
|
|
//判断是否有检查检验或药品开方
|
|
|
if ("1".equals(type)) {
|
|
|
|
|
|
//doctor转换为his医生
|
|
|
DoctorMappingDO doctorMappingDO = doctorMappingService.findMappingCode(outpatientDO.getDoctor(), outpatientDO.getHospital());
|
|
|
if (doctorMappingDO == null) {
|
|
|
throw new RuntimeException("未找到医生映射信息");
|
|
|
}
|
|
|
|
|
|
//his处方拼接开方条件
|
|
|
com.alibaba.fastjson.JSONArray jsonData = new com.alibaba.fastjson.JSONArray();
|
|
|
|
|
|
//===================药品操作======================================================
|
|
|
// 删除原有药品信息
|
|
|
List<WlyyPrescriptionInfoDO> oldInfos = prescriptionInfoDao.findByPrescriptionId(prescription.getId());
|
|
|
if (oldInfos != null && oldInfos.size() > 0) {
|
|
|
prescriptionInfoDao.delete(oldInfos);
|
|
|
}
|
|
|
|
|
|
//存储药品，构建his开方入参
|
|
|
if (StringUtils.isNotBlank(infoJsons)) {
|
|
|
//药品
|
|
|
List<WlyyPrescriptionInfoDO> infoDOs = (List<WlyyPrescriptionInfoDO>) com.alibaba.fastjson.JSONArray.parseArray(infoJsons, WlyyPrescriptionInfoDO.class);
|
|
|
|
|
|
for (WlyyPrescriptionInfoDO info : infoDOs) {
|
|
|
|
|
|
info.setDel(1);
|
|
|
info.setPrescriptionId(prescription.getId());
|
|
|
|
|
|
//设置his药品查询条件
|
|
|
setInfoJsonParam(jsonData, doctorMappingDO, outpatientDO, prescriptionDO, info, Icd10);
|
|
|
}
|
|
|
//保存药品信息
|
|
|
prescriptionInfoDao.save(infoDOs);
|
|
|
|
|
|
//计算药品费用
|
|
|
prescription.setDrugFee(getInfoFee(infoDOs));
|
|
|
}
|
|
|
//=====================药品操作=======================================================================
|
|
|
|
|
|
|
|
|
//=====================检查检验=======================================================================
|
|
|
//存储检查检验,构建his开方入参
|
|
|
//删除之前检查检验
|
|
|
List<WlyyInspectionDO> inspectionDels = wlyyInspectionDao.findByOutpatientId(outPatientId);
|
|
|
if (inspectionDels != null && inspectionDels.size() > 0) {
|
|
|
wlyyInspectionDao.delete(inspectionDels);
|
|
|
}
|
|
|
|
|
|
if (StringUtils.isNotBlank(inspectionJson)) {
|
|
|
List<WlyyInspectionDO> inspections = (List<WlyyInspectionDO>) com.alibaba.fastjson.JSONArray.parseArray(inspectionJson, WlyyInspectionDO.class);
|
|
|
for (WlyyInspectionDO ins : inspections) {
|
|
|
|
|
|
ins.setCreateTime(new Date());
|
|
|
ins.setPrescriptionId(prescription.getId());
|
|
|
ins.setOutpatientId(outPatientId);
|
|
|
|
|
|
//设置his药品查询条件
|
|
|
setInspectionParam(jsonData, doctorMappingDO, outpatientDO, prescriptionDO, ins, Icd10);
|
|
|
}
|
|
|
//保存检查检验。
|
|
|
wlyyInspectionDao.save(inspections);
|
|
|
|
|
|
//计算检查检验费用
|
|
|
prescription.setDrugFee(getInsFee(inspections));
|
|
|
}
|
|
|
//=====================检查检验=======================================================================
|
|
|
|
|
|
//保存挂号费用
|
|
|
prescription.setRegFee(getChargeFee(outpatientDO.getDoctor()));
|
|
|
//保存费用
|
|
|
prescriptionDao.save(prescription);
|
|
|
|
|
|
//上传his开方
|
|
|
return sendHisDiagnosis(jsonData, outpatientDO, prescription);
|
|
|
|
|
|
} else {
|
|
|
|
|
|
outpatientDO.setStatus("2");
|
|
|
outpatientDao.save(outpatientDO);
|
|
|
result.put("code", 1);
|
|
|
result.put("mes", "诊断完成");
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 计算药品费用
|
|
|
*
|
|
|
* @param infoDOs
|
|
|
* @return
|
|
|
*/
|
|
|
public Double getInfoFee(List<WlyyPrescriptionInfoDO> infoDOs) {
|
|
|
Double fee = 0D;
|
|
|
try {
|
|
|
if (infoDOs != null && infoDOs.size() > 0) {
|
|
|
for (WlyyPrescriptionInfoDO info : infoDOs) {
|
|
|
Integer quantity = Integer.parseInt(info.getQuantity());
|
|
|
fee += info.getPackRetprice() * quantity;
|
|
|
}
|
|
|
}
|
|
|
} catch (Exception e) {
|
|
|
logger.error("getInfoFee:" + e.toString());
|
|
|
}
|
|
|
return fee;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 计算检查检验费用
|
|
|
*
|
|
|
* @param inspections
|
|
|
* @return
|
|
|
*/
|
|
|
public Double getInsFee(List<WlyyInspectionDO> inspections) {
|
|
|
Double fee = 0D;
|
|
|
try {
|
|
|
if (inspections != null && inspections.size() > 0) {
|
|
|
for (WlyyInspectionDO ins : inspections) {
|
|
|
Double chargeAmount = Double.parseDouble(ins.getChargeAmount());
|
|
|
fee += chargeAmount * ins.getQuantity();
|
|
|
}
|
|
|
}
|
|
|
} catch (Exception e) {
|
|
|
logger.error("getInsFee:" + e.toString());
|
|
|
}
|
|
|
return fee;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 计算挂号费用
|
|
|
*
|
|
|
* @param doctor
|
|
|
* @return
|
|
|
*/
|
|
|
public Double getChargeFee(String doctor) {
|
|
|
Double fee = 0D;
|
|
|
try {
|
|
|
BaseDoctorDO doctorDO = baseDoctorDao.findById(doctor);
|
|
|
WlyyChargeDictDO chargeDictDO = wlyyChargeDictDao.findByChargeTypeAndDeptTypeCode(doctorDO.getChargeType(), "6");
|
|
|
return chargeDictDO.getReqFee();
|
|
|
} catch (Exception e) {
|
|
|
logger.error("getChargeFee:" + e.toString());
|
|
|
|
|
|
}
|
|
|
return fee;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 上传his开方
|
|
|
*
|
|
|
* @param jsonData
|
|
|
* @param outpatientDO
|
|
|
* @param prescription
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public Map<String, Object> sendHisDiagnosis(com.alibaba.fastjson.JSONArray jsonData, WlyyOutpatientDO outpatientDO, WlyyPrescriptionDO prescription) throws Exception {
|
|
|
Map<String, Object> result = new HashedMap();
|
|
|
//调用his开方接口
|
|
|
JSONObject jsonObject = entranceService.BS10112(jsonData.toJSONString(), demoFlag);
|
|
|
//如果无法解析his系统报文，his系统报错
|
|
|
if (jsonObject == null) {
|
|
|
//记录http日志
|
|
|
WlyyHttpLogDO log = new WlyyHttpLogDO();
|
|
|
log.setCode("makeDiagnosis");
|
|
|
log.setName("下诊断");
|
|
|
log.setPatient(outpatientDO.getPatient());
|
|
|
log.setDoctor(outpatientDO.getDoctor());
|
|
|
log.setResponse("his系统异常，无法解析返回值");
|
|
|
log.setRequest(jsonData.toJSONString());
|
|
|
log.setStatus("-99");
|
|
|
log.setCreateTime(new Date());
|
|
|
wlyyHttpLogDao.save(log);
|
|
|
//开方失败
|
|
|
//更新处方状态
|
|
|
prescription.setStatus(13);
|
|
|
prescriptionDao.save(prescription);
|
|
|
//记录开发失败日志
|
|
|
prescriptionLogService.addPrescriptionLog(prescription.getId(), 13, 2, outpatientDO.getDoctor(), outpatientDO.getDoctorName(), "", new Date());
|
|
|
//开方失败返回值
|
|
|
result.put("code", -1);
|
|
|
result.put("mes", "开方失败，his系统异常");
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
logger.info("调用his开方接口: " + jsonObject.toString());
|
|
|
//判断返回结果
|
|
|
String rs = jsonObject.getString("@RESULT");
|
|
|
//保存日志
|
|
|
WlyyHttpLogDO log = new WlyyHttpLogDO();
|
|
|
log.setCode("makeDiagnosis");
|
|
|
log.setName("下诊断");
|
|
|
log.setPatient(outpatientDO.getPatient());
|
|
|
log.setDoctor(outpatientDO.getDoctor());
|
|
|
log.setResponse(jsonObject.toString());
|
|
|
log.setRequest(jsonData.toJSONString());
|
|
|
log.setStatus(rs);
|
|
|
log.setCreateTime(new Date());
|
|
|
wlyyHttpLogDao.save(log);
|
|
|
|
|
|
if ("0".equals(rs)) {
|
|
|
String admNo = jsonObject.getString("@ADM_NO");
|
|
|
String realOrder = jsonObject.getString("@real_order");
|
|
|
|
|
|
prescription.setAdmNo(admNo);
|
|
|
prescription.setRealOrder(realOrder);
|
|
|
prescriptionDao.save(prescription);
|
|
|
outpatientDO.setAdmNo(admNo);
|
|
|
outpatientDao.save(outpatientDO);
|
|
|
|
|
|
result.put("code", 1);
|
|
|
result.put("mes", "开方提交成功");
|
|
|
|
|
|
return result;
|
|
|
} else {
|
|
|
//开方失败
|
|
|
result.put("code", -1);
|
|
|
result.put("mes", jsonObject.getString("@MSG"));
|
|
|
//更新处方状态
|
|
|
prescription.setStatus(13);
|
|
|
prescriptionDao.save(prescription);
|
|
|
//记录开发失败日志
|
|
|
prescriptionLogService.addPrescriptionLog(prescription.getId(), 13, 2, outpatientDO.getDoctor(), outpatientDO.getDoctorName(), "", new Date());
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 设置检查检验his入参
|
|
|
*
|
|
|
* @param jsonData
|
|
|
* @param doctorMappingDO
|
|
|
* @param outpatientDO
|
|
|
* @param inspectionDO
|
|
|
* @param Icd10
|
|
|
*/
|
|
|
public void setInspectionParam(com.alibaba.fastjson.JSONArray jsonData, DoctorMappingDO doctorMappingDO, WlyyOutpatientDO outpatientDO, WlyyPrescriptionDO prescriptionDO, WlyyInspectionDO inspectionDO, String Icd10) {
|
|
|
|
|
|
com.alibaba.fastjson.JSONObject json = new com.alibaba.fastjson.JSONObject();
|
|
|
if (StringUtils.isNotBlank(prescriptionDO.getRealOrder())) {
|
|
|
json.put("realOrder", prescriptionDO.getRealOrder());
|
|
|
}
|
|
|
json.put("cardNo", outpatientDO.getCardNo());
|
|
|
json.put("doctor", doctorMappingDO.getMappingCode());
|
|
|
json.put("dept", outpatientDO.getDept());
|
|
|
|
|
|
json.put("frequency", inspectionDO.getFrequency()); //组号
|
|
|
json.put("quantity", inspectionDO.getQuantity()); //数量
|
|
|
json.put("serialNo", outpatientDO.getRegisterNo()); //挂号流水号-必输
|
|
|
json.put("groupNo", "00"); //-库房号
|
|
|
json.put("serial", "00"); //药品序列号-必输
|
|
|
|
|
|
json.put("winNo", outpatientDO.getWinNo());
|
|
|
json.put("chargeFlag", 2); //项目类别-必输 1-药品 2检验检查
|
|
|
/**
|
|
|
* code;//项目编码',
|
|
|
* name;//(检查方法)',
|
|
|
* information;//病史与体征',
|
|
|
* checkEquip;//类别',
|
|
|
* checkPart;//部位',
|
|
|
* adresult;//辅助检查治疗',
|
|
|
* goal;//检查目的',
|
|
|
* opview;//手术所见-病理申请单必填',
|
|
|
* specimenName;//标本名称-病理申请单必填',
|
|
|
* specimenNum;//标本数量-病理申请单必填',
|
|
|
* ywjcResult;//以往检查结果-病理申请单选填',
|
|
|
* ywjcDate;//以往检查时间-病理申请单选填 格式：yyyy-mm-dd',
|
|
|
* blzd;//病理诊断-病理申请单选填',
|
|
|
* fixationfluid;//固定液
|
|
|
*/
|
|
|
json.put("parentCode", inspectionDO.getParentCode()); //父节点
|
|
|
json.put("chargeCode", inspectionDO.getCode()); //项目编码
|
|
|
json.put("name", inspectionDO.getName()); //挂号流水号-必输
|
|
|
json.put("information", inspectionDO.getInformation());//库房号-必输
|
|
|
json.put("checkEquip", inspectionDO.getCheckEquip()); //药品序列号-必输
|
|
|
json.put("checkPart", inspectionDO.getCheckPart());
|
|
|
json.put("adresult", inspectionDO.getAdresult());
|
|
|
json.put("goal", inspectionDO.getGoal());
|
|
|
json.put("opview", inspectionDO.getOpview());
|
|
|
json.put("specimenName", inspectionDO.getSpecimenName());
|
|
|
json.put("specimenNum", inspectionDO.getSpecimenNum());
|
|
|
json.put("ywjcResult", inspectionDO.getYwjcResult());
|
|
|
json.put("ywjcDate", inspectionDO.getYwjcDate());
|
|
|
json.put("blzd", inspectionDO.getBlzd());
|
|
|
json.put("fixationfluid", inspectionDO.getFixationfluid());
|
|
|
//设置诊断
|
|
|
setIcd10(json, Icd10);
|
|
|
jsonData.add(json);
|
|
|
logger.info("json:" + json.toString());
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 设置药品his入参
|
|
|
*
|
|
|
* @param jsonData
|
|
|
* @param doctorMappingDO
|
|
|
* @param outpatientDO
|
|
|
* @param info
|
|
|
* @param Icd10
|
|
|
*/
|
|
|
public void setInfoJsonParam(com.alibaba.fastjson.JSONArray jsonData, DoctorMappingDO doctorMappingDO, WlyyOutpatientDO outpatientDO, WlyyPrescriptionDO prescriptionDO, WlyyPrescriptionInfoDO info, String Icd10) {
|
|
|
|
|
|
com.alibaba.fastjson.JSONObject json = new com.alibaba.fastjson.JSONObject();
|
|
|
|
|
|
if (StringUtils.isNotBlank(prescriptionDO.getRealOrder())) {
|
|
|
json.put("realOrder", prescriptionDO.getRealOrder());
|
|
|
}
|
|
|
json.put("cardNo", outpatientDO.getCardNo());
|
|
|
json.put("doctor", doctorMappingDO.getMappingCode());
|
|
|
json.put("dept", outpatientDO.getDept());
|
|
|
json.put("chargeCode", info.getDrugNo());
|
|
|
json.put("winNo", outpatientDO.getWinNo());
|
|
|
json.put("chargeFlag", 1); //项目类别-必输 1-药品 2检验检查
|
|
|
json.put("quantity", info.getQuantity()); //数量-必输
|
|
|
json.put("serialNo", outpatientDO.getRegisterNo()); //挂号流水号-必输
|
|
|
json.put("groupNo", info.getGroupNo());//库房号-必输
|
|
|
json.put("serial", info.getSerial()); //药品序列号-必输
|
|
|
|
|
|
json.put("dosage", info.getDosage());
|
|
|
json.put("unit", info.getUnit());
|
|
|
json.put("usage", info.getUsageCode());
|
|
|
json.put("supplyCode", info.getSupplyCode());
|
|
|
if (StringUtils.isNotBlank(info.getDays())) {
|
|
|
json.put("days", info.getDays());
|
|
|
} else {
|
|
|
//如果是中草药，贴数为天数，没有默认1天
|
|
|
json.put("days", StringUtils.isNotBlank(info.getPostCount()) ? info.getPostCount() : "1");
|
|
|
}
|
|
|
json.put("frequency", info.getFrequency());
|
|
|
json.put("comm", info.getComm());
|
|
|
|
|
|
//设置诊断
|
|
|
setIcd10(json, Icd10);
|
|
|
|
|
|
jsonData.add(json);
|
|
|
logger.info("json:" + json.toString());
|
|
|
}
|
|
|
|
|
|
public void setIcd10(com.alibaba.fastjson.JSONObject json, String Icd10) {
|
|
|
String Icd10s[] = Icd10.split(",");
|
|
|
for (int i = 0; i < Icd10s.length; i++) {
|
|
|
if (i == 0) {
|
|
|
json.put("icdCode", Icd10s[i]);
|
|
|
} else if (i == 1) {
|
|
|
json.put("diagTwo", Icd10s[i]);
|
|
|
} else if (i == 2) {
|
|
|
json.put("diagThree", Icd10s[i]);
|
|
|
} else if (i == 3) {
|
|
|
json.put("diagFour", Icd10s[i]);
|
|
|
} else if (i == 4) {
|
|
|
json.put("diagFive", Icd10s[i]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 订单查询
|
|
|
*
|
|
|
* @param status
|
|
|
* @param oneselfPickupFlg
|
|
|
* @param nameKey
|
|
|
* @param startTime
|
|
|
* @param endTime
|
|
|
* @param page
|
|
|
* @param size
|
|
|
* @return
|
|
|
*/
|
|
|
public MixEnvelop findExpressageList(String status, String oneselfPickupFlg, String nameKey, String startTime, String endTime, Integer page, Integer size) {
|
|
|
String totalSql = "SELECT " +
|
|
|
" COUNT(1) AS total " +
|
|
|
" FROM " +
|
|
|
" wlyy_outpatient o " +
|
|
|
" JOIN wlyy_prescription p ON p.outpatient_id = o.id " +
|
|
|
" JOIN wlyy_prescription_expressage e ON e.outpatient_id = o.id" +
|
|
|
" WHERE" +
|
|
|
" 1=1";
|
|
|
if (StringUtils.isNotBlank(status)) {
|
|
|
totalSql += " AND p.status in(" + status + ")";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(oneselfPickupFlg)) {
|
|
|
totalSql += " AND e.oneself_pickup_flg =" + oneselfPickupFlg;
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(nameKey)) {
|
|
|
totalSql += " AND e.name like '%" + nameKey + "%'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(startTime)) {
|
|
|
totalSql += " AND e.create_time >='" + startTime + " 00:00:00'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(endTime)) {
|
|
|
totalSql += " AND e.create_time <='" + endTime + " 23:59:59'";
|
|
|
}
|
|
|
List<Map<String, Object>> rstotal = jdbcTemplate.queryForList(totalSql);
|
|
|
|
|
|
Long count = 0L;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
count = (Long) rstotal.get(0).get("total");
|
|
|
}
|
|
|
String sql = "SELECT " +
|
|
|
" e.create_time AS createTime, " +
|
|
|
" e.`name`, " +
|
|
|
" e.oneself_pickup_flg AS oneselfPickupFlg, " +
|
|
|
" o.id AS outpatientId, " +
|
|
|
" o.icd10_name AS icd10Name, " +
|
|
|
" p.`status`, " +
|
|
|
" p.id AS prescriptionId ," +
|
|
|
" e.id AS expressageId" +
|
|
|
" FROM " +
|
|
|
" wlyy_outpatient o " +
|
|
|
" JOIN wlyy_prescription p ON p.outpatient_id = o.id " +
|
|
|
" JOIN wlyy_prescription_expressage e ON e.outpatient_id = o.id " +
|
|
|
" WHERE" +
|
|
|
" 1=1";
|
|
|
if (StringUtils.isNotBlank(status)) {
|
|
|
sql += " AND p.status in(" + status + ")";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(oneselfPickupFlg)) {
|
|
|
sql += " AND e.oneself_pickup_flg =" + oneselfPickupFlg;
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(nameKey)) {
|
|
|
sql += " AND e.name like '%" + nameKey + "%'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(startTime)) {
|
|
|
sql += " AND e.create_time >='" + startTime + " 00:00:00'";
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(endTime)) {
|
|
|
sql += " AND e.create_time <='" + endTime + " 23:59:59'";
|
|
|
}
|
|
|
|
|
|
sql += " LIMIT " + (page - 1) * size + "," + size + "";
|
|
|
List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
return MixEnvelop.getSuccessListWithPage(BaseHospitalRequestMapping.Prescription.api_success, list, page, size, count);
|
|
|
|
|
|
}
|
|
|
|
|
|
public Boolean setMailno(String mailno, String expressageId) {
|
|
|
WlyyPrescriptionExpressageDO expressageDO = prescriptionExpressageDao.findOne(expressageId);
|
|
|
expressageDO.setMailno(mailno);
|
|
|
prescriptionExpressageDao.save(expressageDO);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
public void pushListWrite(OutputStream os, List<Map<String, Object>> ls) throws Exception {
|
|
|
WritableWorkbook wwb = jxl.Workbook.createWorkbook(os);
|
|
|
try {
|
|
|
WritableSheet ws;
|
|
|
ws = wwb.createSheet("sheet", 1);
|
|
|
|
|
|
String[] header = {"订单日期", "收货人", "诊断结果", "配送方式", "订单状态"};
|
|
|
int k = 0;
|
|
|
for (String h : header) {
|
|
|
addCell(ws, 0, k, h);//表名，行，列，header
|
|
|
k++;
|
|
|
}
|
|
|
|
|
|
int i = 1;
|
|
|
for (Map<String, Object> m : ls) {
|
|
|
addCell(ws, i, 0, DateUtil.dateToStr((Date) m.get("createTime"), "yyyy-MM-dd HH:mm:ss"), "");
|
|
|
addCell(ws, i, 1, (String) m.get("name"), "");
|
|
|
addCell(ws, i, 2, (String) m.get("icd10Name"), "");
|
|
|
addCell(ws, i, 3, getOneselfPickupFlgString((Integer) m.get("oneselfPickupFlg")), "");
|
|
|
addCell(ws, i, 4, getStatusName((Integer) m.get("status")), "");
|
|
|
i++;
|
|
|
}
|
|
|
wwb.write();
|
|
|
wwb.close();
|
|
|
} catch (IOException e) {
|
|
|
e.printStackTrace();
|
|
|
if (wwb != null) wwb.close();
|
|
|
throw e;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @return
|
|
|
*/
|
|
|
public String getOneselfPickupFlgString(Integer oneselfPickupFlg) {
|
|
|
if (1 == oneselfPickupFlg) {
|
|
|
return "自取";
|
|
|
} else if (0 == oneselfPickupFlg) {
|
|
|
return "快递";
|
|
|
} else {
|
|
|
return "其他";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @param status
|
|
|
* @return
|
|
|
*/
|
|
|
public String getStatusName(Integer status) {
|
|
|
if (31 == status) {
|
|
|
return "待配送";
|
|
|
} else if (32 == status) {
|
|
|
return "配送中";
|
|
|
} else if (100 == status) {
|
|
|
return "已完成";
|
|
|
} else {
|
|
|
return "其他";
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//添加单元格内容
|
|
|
public void addCell(WritableSheet ws, int row, int column, String data) throws WriteException {
|
|
|
Label label = new Label(column, row, data);
|
|
|
ws.addCell(label);
|
|
|
}
|
|
|
|
|
|
//添加单元格内容
|
|
|
public void addCell(WritableSheet ws, int row, int column, String data, String memo) throws WriteException {
|
|
|
Label label = new Label(column, row, data);
|
|
|
if (!org.springframework.util.StringUtils.isEmpty(memo)) {
|
|
|
WritableCellFeatures cellFeatures = new WritableCellFeatures();
|
|
|
cellFeatures.setComment(memo);
|
|
|
label.setCellFeatures(cellFeatures);
|
|
|
}
|
|
|
ws.addCell(label);
|
|
|
}
|
|
|
|
|
|
public List<WlyyChargeDictVO> findByDeptTypeCode(String deptTypeCode) {
|
|
|
List<WlyyChargeDictDO> dictDOs = wlyyChargeDictDao.findByDeptTypeCode(deptTypeCode);
|
|
|
List<WlyyChargeDictVO> dictVOs = new ArrayList<>();
|
|
|
return convertToModels(dictDOs, dictVOs, WlyyChargeDictVO.class);
|
|
|
}
|
|
|
|
|
|
|
|
|
// 过时
|
|
|
// public List<WlyyDoctorWorkTimeVO> findDoctorWorkTime(String doctor) {
|
|
|
// //获取医生排班规则
|
|
|
// List<WlyyHospitalSysDictDO> list = sysDictDao.findByDictName("Scheduling");
|
|
|
//
|
|
|
// Calendar ncTime = Calendar.getInstance();
|
|
|
// ncTime.setTime(new Date());
|
|
|
//
|
|
|
// Calendar scTime = Calendar.getInstance();
|
|
|
// scTime.setTime(new Date());
|
|
|
//
|
|
|
// Calendar ecTime = Calendar.getInstance();
|
|
|
// ecTime.setTime(new Date());
|
|
|
//
|
|
|
// //设置几天号源，及最后天号源的开放时间
|
|
|
// int days = Integer.parseInt(findHospitalSysDictValue(list, "OpenDays"));
|
|
|
// String closeTime = findHospitalSysDictValue(list, "CloseTime");
|
|
|
//
|
|
|
// //比较当前时间是否超过开放时间
|
|
|
// if (DateUtil.strToDate(DateUtil.getTimeShort(), DateUtil.HH_MM_SS).after(DateUtil.strToDate(closeTime, DateUtil.HH_MM))) {
|
|
|
// //当前时间超过开放时间，可以预约最后一天全部号源
|
|
|
// ecTime.add(Calendar.DAY_OF_MONTH, days);
|
|
|
// ecTime.set(ecTime.get(Calendar.YEAR), ecTime.get(Calendar.MONTH), ecTime.get(Calendar.DATE), 23, 59, 59);
|
|
|
// } else {
|
|
|
// //当前时间没超过开放时间，可以预约最后一天前一天全部号源
|
|
|
// ecTime.add(Calendar.DAY_OF_MONTH, days > 1 ? days - 1 : 0);
|
|
|
// ecTime.set(ecTime.get(Calendar.YEAR), ecTime.get(Calendar.MONTH), ecTime.get(Calendar.DATE), 23, 59, 59);
|
|
|
// }
|
|
|
//
|
|
|
//
|
|
|
// List<WlyyDoctorWorkTimeDO> times = doctorWorkTimeDao.findDoctorWorkTime(doctor, scTime.getTime(), ecTime.getTime());
|
|
|
//
|
|
|
// workTimeFilter(list, times);
|
|
|
//
|
|
|
// List<WlyyDoctorWorkTimeVO> timeVOs = new ArrayList<>();
|
|
|
//
|
|
|
// convertToModels(times, timeVOs, WlyyDoctorWorkTimeVO.class);
|
|
|
//
|
|
|
// if (timeVOs != null && timeVOs.size() > 0) {
|
|
|
// for (WlyyDoctorWorkTimeVO timeVO : timeVOs) {
|
|
|
// timeVO.setCount(findWorkTimeCount(timeVO.getId()));
|
|
|
// }
|
|
|
// }
|
|
|
// return timeVOs;
|
|
|
// }
|
|
|
|
|
|
// public List<WlyyDoctorWorkTimeDO> workTimeFilter(List<WlyyHospitalSysDictDO> sys, List<WlyyDoctorWorkTimeDO> times) {
|
|
|
//
|
|
|
// if (times != null && times.size() > 0) {
|
|
|
// //上午号源开放的最早天数
|
|
|
// int AMCloseDays = Integer.parseInt(findHospitalSysDictValue(sys, "AMCloseDays"));
|
|
|
// //每一天上午的最早预约的过号时间
|
|
|
// String AMCloseTime = findHospitalSysDictValue(sys, "AMCloseTime");
|
|
|
// //下午号源开放的最早天数
|
|
|
// int PMCloseDays = Integer.parseInt(findHospitalSysDictValue(sys, "PMCloseDays"));
|
|
|
// //每一天下午的最早预约的过号时间
|
|
|
// String PMCloseTime = findHospitalSysDictValue(sys, "PMCloseTime");
|
|
|
//
|
|
|
// Iterator it = times.iterator();
|
|
|
// while (it.hasNext()) {
|
|
|
// //设置上午过号时间
|
|
|
// Calendar scAMTime = Calendar.getInstance();
|
|
|
// scAMTime.setTime(new Date());
|
|
|
// scAMTime.add(Calendar.DAY_OF_MONTH, AMCloseDays);
|
|
|
//
|
|
|
// //设置下午午过号时间
|
|
|
// Calendar scPMTime = Calendar.getInstance();
|
|
|
// scPMTime.setTime(new Date());
|
|
|
// scPMTime.add(Calendar.DAY_OF_MONTH, PMCloseDays);
|
|
|
//
|
|
|
// WlyyDoctorWorkTimeDO time = (WlyyDoctorWorkTimeDO) it.next();
|
|
|
//
|
|
|
// Boolean filter = true;
|
|
|
//
|
|
|
// //1.【上午的排班中】 且 【排班结束时间】如果在【开放时间】前，则移除
|
|
|
// if (filter && "1".equals(time.getTimeType()) && time.getEndTime().before(scAMTime.getTime())) {
|
|
|
// it.remove();
|
|
|
// filter = false;
|
|
|
// }
|
|
|
//
|
|
|
// //2.【下午午的排班中】 且 【排班结束时间】如果在【开放时间】前，则移除该排班
|
|
|
// if (filter && "2".equals(time.getTimeType()) && time.getEndTime().before(scPMTime.getTime())) {
|
|
|
// it.remove();
|
|
|
// filter = false;
|
|
|
// }
|
|
|
//
|
|
|
// //3.如果【当前时间】过了【上午放号时间】，则移除所有上午的排班
|
|
|
// if (filter && "1".equals(time.getTimeType()) &&
|
|
|
// DateUtil.strToDate(DateUtil.getTimeShort(), DateUtil.HH_MM_SS).after(DateUtil.strToDate(AMCloseTime, DateUtil.HH_MM))) {
|
|
|
// scAMTime.set(scAMTime.get(Calendar.YEAR), scAMTime.get(Calendar.MONTH), scAMTime.get(Calendar.DATE), 12, 00, 00);
|
|
|
//
|
|
|
// if (time.getEndTime().before(scAMTime.getTime())) {
|
|
|
// it.remove();
|
|
|
// filter = false;
|
|
|
// }
|
|
|
// }
|
|
|
// //4.如果【当前时间】过了【下午午放号时间】，则移除所有下午的排班
|
|
|
// if (filter && "2".equals(time.getTimeType()) &&
|
|
|
// DateUtil.strToDate(DateUtil.getTimeShort(), DateUtil.HH_MM_SS).after(DateUtil.strToDate(PMCloseTime, DateUtil.HH_MM))) {
|
|
|
// scPMTime.set(scAMTime.get(Calendar.YEAR), scAMTime.get(Calendar.MONTH), scAMTime.get(Calendar.DATE), 12, 00, 00);
|
|
|
//
|
|
|
// if (time.getEndTime().before(scPMTime.getTime())) {
|
|
|
// it.remove();
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
// return times;
|
|
|
// }
|
|
|
|
|
|
|
|
|
public String findHospitalSysDictValue(List<WlyyHospitalSysDictDO> list, String dictCode) {
|
|
|
|
|
|
if (list != null && list.size() > 0) {
|
|
|
for (WlyyHospitalSysDictDO sysDictDO : list) {
|
|
|
if (dictCode.equals(sysDictDO.getDictCode())) {
|
|
|
return sysDictDO.getDictValue();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return "";
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取卡信息
|
|
|
*
|
|
|
* @param cardNo
|
|
|
* @param demoFlag
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONObject getCardInfo(String cardNo, boolean demoFlag) throws Exception {
|
|
|
return entranceService.qutpatientBalance(cardNo, demoFlag);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 新排班号源详情
|
|
|
* @param id
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findWorkTimeInfo(String id){
|
|
|
WlyyDoctorWorkTimeDO timeDO = doctorWorkTimeDao.findOne(id);
|
|
|
|
|
|
Long ss = timeDO.getEndTime().getTime()-timeDO.getStartTime().getTime();
|
|
|
Long s = ss/timeDO.getSourceNumber();
|
|
|
|
|
|
Calendar sc = Calendar.getInstance();
|
|
|
sc.setTime(timeDO.getStartTime());
|
|
|
|
|
|
List<Map<String,Object>> rs = new ArrayList<>();
|
|
|
|
|
|
//1.根据当前时间，去取已过时间的号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
if(new Date().before(sc.getTime())){
|
|
|
break;
|
|
|
}
|
|
|
//加上时间间隔
|
|
|
Date temp =new Date();
|
|
|
temp.setTime(sc.getTime().getTime()+s);
|
|
|
sc.setTime(temp);
|
|
|
}
|
|
|
|
|
|
List<WlyyPatientRegisterTimeDO> registerTimeDOs = patientRegisterTimeDao.findByDoctorAndWorkId(timeDO.getDoctor(),id);
|
|
|
|
|
|
//2.根据时间间隔拆分号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
|
|
|
Map<String,Object> t = new HashedMap();
|
|
|
t.put("startTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
//加上时间间隔
|
|
|
Date temp =new Date();
|
|
|
temp.setTime(sc.getTime().getTime()+s);
|
|
|
sc.setTime(temp);
|
|
|
//如果结束时间大于排班时间则不再拆分号源
|
|
|
if(sc.getTime().after(timeDO.getEndTime())){
|
|
|
break;
|
|
|
}
|
|
|
t.put("endTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
//如果号源被预约了，标记为true
|
|
|
Boolean registered = false;
|
|
|
if(registerTimeDOs!=null&®isterTimeDOs.size()>0){
|
|
|
for(WlyyPatientRegisterTimeDO registerTimeDO : registerTimeDOs){
|
|
|
if(t.get("startTime").equals(DateUtil.dateToStr(registerTimeDO.getStartTime(),"yyyy-MM-dd HH:mm:ss"))){
|
|
|
registered = true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
t.put("registered",registered);
|
|
|
rs.add(t);
|
|
|
}
|
|
|
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 计算号源数目
|
|
|
* @param id
|
|
|
* @return
|
|
|
*/
|
|
|
public Integer findWorkTimeInfoCout(String id){
|
|
|
WlyyDoctorWorkTimeDO timeDO = doctorWorkTimeDao.findOne(id);
|
|
|
|
|
|
if(timeDO.getSourceNumber()==null||timeDO.getStartTime()==null||timeDO.getEndTime()==null){
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
Long ss = timeDO.getEndTime().getTime()-timeDO.getStartTime().getTime();
|
|
|
Long s = ss/timeDO.getSourceNumber();
|
|
|
|
|
|
Calendar sc = Calendar.getInstance();
|
|
|
sc.setTime(timeDO.getStartTime());
|
|
|
|
|
|
List<Map<String,Object>> rs = new ArrayList<>();
|
|
|
|
|
|
//1.根据当前时间，去取已过时间的号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
if(new Date().before(sc.getTime())){
|
|
|
break;
|
|
|
}
|
|
|
//加上时间间隔
|
|
|
Date temp =new Date();
|
|
|
temp.setTime(sc.getTime().getTime()+s);
|
|
|
sc.setTime(temp);
|
|
|
}
|
|
|
|
|
|
List<WlyyPatientRegisterTimeDO> registerTimeDOs = patientRegisterTimeDao.findByDoctorAndWorkId(timeDO.getDoctor(),id);
|
|
|
|
|
|
//2.根据时间间隔拆分号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
|
|
|
Map<String,Object> t = new HashedMap();
|
|
|
t.put("startTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
//加上时间间隔
|
|
|
Date temp =new Date();
|
|
|
temp.setTime(sc.getTime().getTime()+s);
|
|
|
sc.setTime(temp);
|
|
|
//如果结束时间大于排班时间则不再拆分号源
|
|
|
if(sc.getTime().after(timeDO.getEndTime())){
|
|
|
break;
|
|
|
}
|
|
|
t.put("endTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
//如果号源被预约了，标记为true
|
|
|
Boolean registered = false;
|
|
|
if(registerTimeDOs!=null&®isterTimeDOs.size()>0){
|
|
|
for(WlyyPatientRegisterTimeDO registerTimeDO : registerTimeDOs){
|
|
|
if(t.get("startTime").equals(DateUtil.dateToStr(registerTimeDO.getStartTime(),"yyyy-MM-dd HH:mm:ss"))){
|
|
|
registered = true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(!registered){
|
|
|
rs.add(t);
|
|
|
}
|
|
|
}
|
|
|
return rs.size();
|
|
|
}
|
|
|
|
|
|
@Deprecated
|
|
|
public List<Map<String,Object>> findWorkTimeInfoOld(String id){
|
|
|
WlyyDoctorWorkTimeDO timeDO = doctorWorkTimeDao.findOne(id);
|
|
|
Calendar sc = Calendar.getInstance();
|
|
|
sc.setTime(timeDO.getStartTime());
|
|
|
|
|
|
List<Map<String,Object>> rs = new ArrayList<>();
|
|
|
|
|
|
//1.根据当前时间，去取已过时间的号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
if(new Date().before(sc.getTime())){
|
|
|
break;
|
|
|
}
|
|
|
//加上时间间隔
|
|
|
sc.add(Calendar.MINUTE,timeDO.getTimeInterval());
|
|
|
}
|
|
|
|
|
|
List<WlyyPatientRegisterTimeDO> registerTimeDOs = patientRegisterTimeDao.findByDoctorAndWorkId(timeDO.getDoctor(),id);
|
|
|
|
|
|
//2.根据时间间隔拆分号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
|
|
|
Map<String,Object> t = new HashedMap();
|
|
|
t.put("startTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
//加上时间间隔
|
|
|
sc.add(Calendar.MINUTE,timeDO.getTimeInterval());
|
|
|
//如果结束时间大于排班时间则不再拆分号源
|
|
|
if(sc.getTime().after(timeDO.getEndTime())){
|
|
|
break;
|
|
|
}
|
|
|
t.put("endTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
//如果号源被预约了，标记为true
|
|
|
Boolean registered = false;
|
|
|
if(registerTimeDOs!=null&®isterTimeDOs.size()>0){
|
|
|
for(WlyyPatientRegisterTimeDO registerTimeDO : registerTimeDOs){
|
|
|
if(t.get("startTime").equals(DateUtil.dateToStr(registerTimeDO.getStartTime(),"yyyy-MM-dd HH:mm:ss"))){
|
|
|
registered = true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
t.put("registered",registered);
|
|
|
rs.add(t);
|
|
|
}
|
|
|
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
public Integer findWorkTimeCount(String id){
|
|
|
WlyyDoctorWorkTimeDO timeDO = doctorWorkTimeDao.findOne(id);
|
|
|
Calendar sc = Calendar.getInstance();
|
|
|
sc.setTime(timeDO.getStartTime());
|
|
|
|
|
|
List<Map<String,Object>> rs = new ArrayList<>();
|
|
|
|
|
|
//1.根据当前时间，去取已过时间的号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
if(new Date().before(sc.getTime())){
|
|
|
break;
|
|
|
}
|
|
|
//加上时间间隔
|
|
|
sc.add(Calendar.MINUTE,timeDO.getTimeInterval());
|
|
|
}
|
|
|
|
|
|
List<WlyyPatientRegisterTimeDO> registerTimeDOs = patientRegisterTimeDao.findByDoctorAndWorkId(timeDO.getDoctor(),id);
|
|
|
|
|
|
//2.根据时间间隔拆分号源
|
|
|
while (sc.getTime().before(timeDO.getEndTime())){
|
|
|
|
|
|
Map<String,Object> t = new HashedMap();
|
|
|
t.put("startTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
//加上时间间隔
|
|
|
sc.add(Calendar.MINUTE,timeDO.getTimeInterval());
|
|
|
|
|
|
if(sc.getTime().after(timeDO.getEndTime())){
|
|
|
break;
|
|
|
}
|
|
|
t.put("endTime",DateUtil.dateToStr(sc.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
if(registerTimeDOs!=null&®isterTimeDOs.size()>0){
|
|
|
Boolean registered = false;
|
|
|
for(WlyyPatientRegisterTimeDO registerTimeDO : registerTimeDOs){
|
|
|
if(t.get("startTime").equals(DateUtil.dateToStr(registerTimeDO.getStartTime(),"yyyy-MM-dd HH:mm:ss"))){
|
|
|
registered = true;
|
|
|
}
|
|
|
}
|
|
|
if(!registered){
|
|
|
rs.add(t);
|
|
|
}
|
|
|
}else {
|
|
|
rs.add(t);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return rs.size();
|
|
|
}
|
|
|
|
|
|
public Map<String,Object> findDoctorInfo(String doctor,String withWork){
|
|
|
BaseDoctorDO doctorDO = baseDoctorDao.findById(doctor);
|
|
|
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
if(doctorDO!=null){
|
|
|
rs.put("doctor",doctor);
|
|
|
rs.put("doctorSex",doctorDO.getSex());
|
|
|
if(StringUtils.isNoneBlank(doctorDO.getIdcard())){
|
|
|
rs.put("doctorAge",IdCardUtil.getAgeForIdcard(doctorDO.getIdcard()));
|
|
|
}else{
|
|
|
rs.put("doctorAge","");
|
|
|
}
|
|
|
rs.put("doctor",doctorDO.getName());
|
|
|
rs.put("jobTitleCode",doctorDO.getJobTitleCode());
|
|
|
rs.put("jobTitleName",doctorDO.getJobTitleName());
|
|
|
rs.put("chargeType",doctorDO.getChargeType());
|
|
|
rs.put("photo",doctorDO.getPhoto());
|
|
|
rs.put("consultStatus",doctorDO.getConsultStatus());
|
|
|
rs.put("outpatientType",doctorDO.getOutpatientType());
|
|
|
rs.put("expertise",doctorDO.getExpertise());
|
|
|
rs.put("introduce",doctorDO.getIntroduce());
|
|
|
rs.put("consultStatus",doctorDO.getConsultStatus());// 咨询在线状态
|
|
|
|
|
|
//机构科室信息
|
|
|
List<BaseDoctorHospitalDO> hospitalDOs = baseDoctorHospitalDao.findByDoctorCode(doctorDO.getId());
|
|
|
if(hospitalDOs!=null&&hospitalDOs.size()>0){
|
|
|
rs.put("hospital",hospitalDOs.get(0));
|
|
|
BaseOrgDO org = baseOrgDao.findByCode(hospitalDOs.get(0).getOrgCode());
|
|
|
rs.put("winNo",org.getWinNo());
|
|
|
rs.put("deptName",hospitalDOs.get(0).getDeptName());
|
|
|
rs.put("dept",hospitalDOs.get(0).getDeptCode());
|
|
|
|
|
|
if(StringUtils.isNotBlank(withWork)&&"1".equals(withWork)){
|
|
|
List<WlyyDoctorWorkTimeVO> times = findDoctorWorkTime(doctor,hospitalDOs.get(0).getOrgCode());
|
|
|
rs.put("workTime",times);
|
|
|
}
|
|
|
}else{
|
|
|
rs.put("hospital",null);
|
|
|
rs.put("winNo",null);
|
|
|
rs.put("deptName",null);
|
|
|
rs.put("dept",null);
|
|
|
rs.put("workTime",null);
|
|
|
}
|
|
|
|
|
|
|
|
|
//医生角色
|
|
|
String sql = "SELECT " +
|
|
|
" t. CODE AS \"roleCode\", " +
|
|
|
" t. NAME AS \"roleName\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor_role r " +
|
|
|
" JOIN base_doctor_role_dict t ON t.`code` = r.role_code " +
|
|
|
" WHERE " +
|
|
|
" r.doctor_code = '"+doctor+"'";
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
if(list!=null&&list.size()>0){
|
|
|
rs.put("roles",list);
|
|
|
}else{
|
|
|
rs.put("roles",null);
|
|
|
}
|
|
|
//医生预约量
|
|
|
List<WlyyPatientRegisterTimeDO> registerTimeDOs = patientRegisterTimeDao.findByDoctor(doctor);
|
|
|
if(registerTimeDOs!=null&®isterTimeDOs.size()>0){
|
|
|
rs.put("registerCount",registerTimeDOs.size());
|
|
|
}else{
|
|
|
rs.put("registerCount",0);
|
|
|
}
|
|
|
//医生问诊量
|
|
|
// List<WlyyOutpatientDO> wlyyOutpatientDOs = outpatientDao.findByDoctorAndStatus(doctor,"2");
|
|
|
// if(wlyyOutpatientDOs!=null&&wlyyOutpatientDOs.size()>0){
|
|
|
// rs.put("outpatientCount",wlyyOutpatientDOs.size());
|
|
|
// }else{
|
|
|
// rs.put("outpatientCount",0);
|
|
|
// }
|
|
|
//
|
|
|
// //协同门诊量
|
|
|
// Integer coordinationCout = outpatientDao.countByDoctorAndStatusAndOutpatientType(doctor,"2","2");
|
|
|
// rs.put("coordinationCout",coordinationCout);
|
|
|
|
|
|
|
|
|
|
|
|
//专家咨询
|
|
|
String zjCountsql = "SELECT id AS \"id\" FROM wlyy_consult_team WHERE doctor='"+doctor+"' AND (type=1 OR type=15)";
|
|
|
List<Map<String,Object>> zjList = jdbcTemplate.queryForList(zjCountsql);
|
|
|
|
|
|
if(zjList!=null&&zjList.size()>0){
|
|
|
rs.put("zjCount",zjList.size());
|
|
|
}else{
|
|
|
rs.put("zjCount",0);
|
|
|
}
|
|
|
|
|
|
//查询医生各项评价平均分
|
|
|
String sqlscore = "SELECT " +
|
|
|
"AVG(a.score) AS \"score\"," +
|
|
|
"a.score_type AS \"score_type\" " +
|
|
|
"FROM base_evaluate a,base_evaluate_score b " +
|
|
|
"WHERE " +
|
|
|
"a.relation_code=b.id " +
|
|
|
"AND b.doctor='"+doctor+"' " +
|
|
|
"GROUP BY a.score_type";
|
|
|
List<Map<String,Object>> listscore = jdbcTemplate.queryForList(sqlscore);
|
|
|
|
|
|
Double doctorScore = new Double("0");
|
|
|
|
|
|
if(listscore!=null&&listscore.size()>0){
|
|
|
for(Map<String,Object> _listscore :listscore){
|
|
|
doctorScore += (Double)_listscore.get("score");
|
|
|
}
|
|
|
}
|
|
|
doctorScore = doctorScore/3;
|
|
|
rs.put("doctorScore",doctorScore);
|
|
|
|
|
|
if(listscore!=null&&listscore.size()>0){
|
|
|
rs.put("scoreDoctor",listscore);
|
|
|
}else{
|
|
|
rs.put("scoreDoctor",null);
|
|
|
}
|
|
|
|
|
|
//查询评价明细
|
|
|
String sqlScoreList = "SELECT " +
|
|
|
"a.score as \"score\"," +
|
|
|
"b.score as \"doctorscore\"," +
|
|
|
"a.score_type as \"score_type\"," +
|
|
|
"a.content as \"content\"," +
|
|
|
"b.create_time as \"create_time\"," +
|
|
|
"c.type as \"type\"," +
|
|
|
"c.name as \"patientname\"," +
|
|
|
"b.id as \"id\"," +
|
|
|
"c.photo as \"patientphoto\"," +
|
|
|
"b.type as \"niming\" " +
|
|
|
"FROM " +
|
|
|
"base_evaluate a " +
|
|
|
"LEFT JOIN base_evaluate_score b ON b.id=a.relation_code " +
|
|
|
"LEFT JOIN wlyy_consult_team c ON c.consult=b.relation_code AND c.doctor='"+doctor+"' " +
|
|
|
"WHERE a.relation_code=b.id AND b.doctor='"+doctor+"' ";
|
|
|
List<Map<String,Object>> scoreList = jdbcTemplate.queryForList(sqlScoreList);
|
|
|
|
|
|
if(scoreList!=null&&scoreList.size()>0){
|
|
|
|
|
|
// Set<String> datelist = new HashSet<>();
|
|
|
|
|
|
HashMap<String,List<Map<String,Object>>> waitinglist = new HashMap<>();
|
|
|
|
|
|
if(scoreList!=null&&scoreList.size()>0){
|
|
|
for(Map<String,Object> scorepatient :scoreList){
|
|
|
String id = (String)scorepatient.get("id");
|
|
|
|
|
|
if(id == null){
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if(waitinglist.keySet().contains(id)){
|
|
|
waitinglist.get(id).add(scorepatient);
|
|
|
}else{
|
|
|
List<Map<String,Object>> _cu = new ArrayList<>();
|
|
|
_cu.add(scorepatient);
|
|
|
waitinglist.put(id,_cu);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
rs.put("scoreList",waitinglist);
|
|
|
}else{
|
|
|
rs.put("scoreList",null);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
public Map<String,Object> findDoctorBaseInfo(String doctor){
|
|
|
BaseDoctorDO doctorDO = baseDoctorDao.findById(doctor);
|
|
|
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
if(doctorDO!=null){
|
|
|
rs.put("doctor",doctor);
|
|
|
rs.put("doctor",doctorDO.getName());
|
|
|
rs.put("jobTitleCode",doctorDO.getJobTitleCode());
|
|
|
rs.put("jobTitleName",doctorDO.getJobTitleName());
|
|
|
rs.put("chargeType",doctorDO.getChargeType());
|
|
|
rs.put("photo",doctorDO.getPhoto());
|
|
|
rs.put("consultStatus",doctorDO.getConsultStatus());
|
|
|
rs.put("outpatientType",doctorDO.getOutpatientType());
|
|
|
rs.put("expertise",doctorDO.getExpertise());
|
|
|
rs.put("introduce",doctorDO.getIntroduce());
|
|
|
rs.put("townCode",doctorDO.getTownCode());
|
|
|
rs.put("townName",doctorDO.getTownName());
|
|
|
rs.put("consultStatus",doctorDO.getConsultStatus());// 咨询在线状态
|
|
|
|
|
|
//机构科室信息
|
|
|
List<BaseDoctorHospitalDO> hospitalDOs = baseDoctorHospitalDao.findByDoctorCode(doctorDO.getId());
|
|
|
if(hospitalDOs!=null&&hospitalDOs.size()>0){
|
|
|
rs.put("hospital",hospitalDOs.get(0));
|
|
|
BaseOrgDO org = baseOrgDao.findByCode(hospitalDOs.get(0).getOrgCode());
|
|
|
if(org!=null){
|
|
|
rs.put("winNo",org.getWinNo());
|
|
|
rs.put("deptName",hospitalDOs.get(0).getDeptName());
|
|
|
rs.put("deptCode",hospitalDOs.get(0).getDeptCode());
|
|
|
}
|
|
|
}else{
|
|
|
rs.put("hospital",null);
|
|
|
rs.put("winNo",null);
|
|
|
rs.put("deptName",null);
|
|
|
rs.put("deptCode",null);
|
|
|
}
|
|
|
|
|
|
//多科室兼容
|
|
|
rs.put("hospitalList",hospitalDOs);
|
|
|
|
|
|
|
|
|
//医生角色
|
|
|
String sql = "SELECT " +
|
|
|
" t.CODE AS \"roleCode\", " +
|
|
|
" t.NAME AS \"roleName\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor_role r " +
|
|
|
" JOIN base_doctor_role_dict t ON t.code = r.role_code " +
|
|
|
" WHERE " +
|
|
|
" r.doctor_code = '"+doctor+"'";
|
|
|
logger.info(sql);
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
if(list!=null&&list.size()>0){
|
|
|
rs.put("roles",list);
|
|
|
}else{
|
|
|
rs.put("roles",null);
|
|
|
}
|
|
|
|
|
|
//密码过期
|
|
|
rs.put("authPw",baseDoctorService.findDoctorPwlimitDate(doctor));
|
|
|
}
|
|
|
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 居民取消复诊或者医生拒绝接诊
|
|
|
* @param outPatientId
|
|
|
* @param cancelType
|
|
|
* @param cancelValue
|
|
|
* @param cancelRemark
|
|
|
* @param operator 1居民 2医生
|
|
|
* @return
|
|
|
*/
|
|
|
public Map<String,Object> cancelOutPatient(String outPatientId,String cancelType,String cancelValue,String cancelRemark,Integer operator){
|
|
|
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
//判断医生是否接诊
|
|
|
List<WlyyHospitalWaitingRoomDO> roomDOs =hospitalWaitingRoomDao.findByOutpatientId(outPatientId);
|
|
|
if(roomDOs!=null&&roomDOs.size()>0){
|
|
|
for(WlyyHospitalWaitingRoomDO roomDO:roomDOs){
|
|
|
if(roomDO.getVisitStatus()==2){
|
|
|
rs.put("code",-1);
|
|
|
rs.put("mes","医生已经接诊，无法取消");
|
|
|
return rs;
|
|
|
}else{
|
|
|
roomDO.setVisitStatus(-1);
|
|
|
hospitalWaitingRoomDao.save(roomDO);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//更改门诊状态
|
|
|
WlyyOutpatientDO wlyyOutpatientDO = outpatientDao.findOne(outPatientId);
|
|
|
wlyyOutpatientDO.setStatus("-1");
|
|
|
if (1 == operator){
|
|
|
//居民取消
|
|
|
wlyyOutpatientDO.setPatientCancelRemark(cancelRemark);
|
|
|
wlyyOutpatientDO.setPatientCancelType(cancelType);
|
|
|
wlyyOutpatientDO.setPatientCancelValue(cancelValue);
|
|
|
}else{
|
|
|
//医生拒绝接诊
|
|
|
wlyyOutpatientDO.setDoctorCancelRemark(cancelRemark);
|
|
|
wlyyOutpatientDO.setDoctorCancelType(cancelType);
|
|
|
wlyyOutpatientDO.setDoctorCancelValue(cancelValue);
|
|
|
}
|
|
|
|
|
|
outpatientDao.save(wlyyOutpatientDO);
|
|
|
|
|
|
//删除门诊号源
|
|
|
List<WlyyPatientRegisterTimeDO> list = patientRegisterTimeDao.findByOutpatientId(wlyyOutpatientDO.getId());
|
|
|
if(list!=null&&list.size()>0){
|
|
|
patientRegisterTimeDao.delete(list);
|
|
|
}
|
|
|
|
|
|
rs.put("code",1);
|
|
|
rs.put("mes","取消成功");
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
public List<WlyyHospitalSysDictDO> findCancelReasonList(){
|
|
|
return sysDictDao.findByDictName("PatientCancel");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 獲取快速咨詢時間
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findFastRegisterDate(){
|
|
|
int days = 7;
|
|
|
String AMStartTime ="8:00";
|
|
|
String AMEndTime ="12:00";
|
|
|
String PMStartTime ="14:00";
|
|
|
String PMEndTime ="17:00";
|
|
|
|
|
|
//设置上午过号时间
|
|
|
Calendar scTime = Calendar.getInstance();
|
|
|
scTime.setTime(new Date());
|
|
|
|
|
|
Calendar ecTime = Calendar.getInstance();
|
|
|
ecTime.setTime(new Date());
|
|
|
|
|
|
List<Map<String,Object>> times = new ArrayList<>();
|
|
|
for(int i=0;i<days;i++){
|
|
|
//設置上午時段
|
|
|
Map<String,Object> time = new HashedMap();
|
|
|
time.put("timeType","1");
|
|
|
time.put("date",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd"));
|
|
|
time.put("weekDay",scTime.get(Calendar.DAY_OF_WEEK));
|
|
|
|
|
|
String ts[] = AMStartTime.split(":");
|
|
|
scTime.set(scTime.get(Calendar.YEAR),scTime.get(Calendar.MONTH),scTime.get(Calendar.DAY_OF_MONTH),Integer.parseInt(ts[0]),Integer.parseInt(ts[1]),00);
|
|
|
time.put("startTime",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
String ts2[] = AMEndTime.split(":");
|
|
|
scTime.set(scTime.get(Calendar.YEAR),scTime.get(Calendar.MONTH),scTime.get(Calendar.DAY_OF_MONTH),Integer.parseInt(ts2[0]),Integer.parseInt(ts2[1]),00);
|
|
|
time.put("endTime",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
times.add(time);
|
|
|
|
|
|
//設置下午時段
|
|
|
Map<String,Object> time2 = new HashedMap();
|
|
|
time2.put("timeType","2");
|
|
|
time2.put("date",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd"));
|
|
|
time2.put("weekDay",scTime.get(Calendar.DAY_OF_WEEK));
|
|
|
|
|
|
String pts[] = PMStartTime.split(":");
|
|
|
scTime.set(scTime.get(Calendar.YEAR),scTime.get(Calendar.MONTH),scTime.get(Calendar.DAY_OF_MONTH),Integer.parseInt(pts[0]),Integer.parseInt(pts[1]),00);
|
|
|
time2.put("startTime",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
String pts2[] = PMEndTime.split(":");
|
|
|
scTime.set(scTime.get(Calendar.YEAR),scTime.get(Calendar.MONTH),scTime.get(Calendar.DAY_OF_MONTH),Integer.parseInt(pts2[0]),Integer.parseInt(pts2[1]),00);
|
|
|
time2.put("endTime",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
times.add(time2);
|
|
|
//生成下一天
|
|
|
scTime.add(Calendar.DAY_OF_MONTH,1);
|
|
|
}
|
|
|
|
|
|
if(DateUtil.strToDate(DateUtil.getTimeShort(),DateUtil.HH_MM).after(DateUtil.strToDate(AMEndTime,DateUtil.HH_MM))) {
|
|
|
times.remove(0);
|
|
|
}
|
|
|
if(DateUtil.strToDate(DateUtil.getTimeShort(),DateUtil.HH_MM).after(DateUtil.strToDate(PMEndTime,DateUtil.HH_MM))) {
|
|
|
times.remove(0);
|
|
|
}
|
|
|
return times;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 医生可接单列表(图文复诊、视频复诊、协同门诊)
|
|
|
* @param doctor
|
|
|
* @param type 1：图文诊室，2:视频诊室（视频复诊、协同门诊）
|
|
|
* @query_status 0:图文复诊候诊 1:图文复诊抢单列表
|
|
|
* @dept 部门
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findWaitingRoomOutpatientByDoctor(String doctor, Integer type,Integer query_status,String dept) {
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
"room.outpatient_id AS id," +
|
|
|
"room.patient_id AS patient_id," +
|
|
|
"room.patient_name AS name," +
|
|
|
"patient.sex AS sex," +
|
|
|
"patient.idcard AS idcard," +
|
|
|
"patient.photo AS photo," +
|
|
|
"outpatient.mobile AS mobile," +
|
|
|
"patient.birthday AS birthday," +
|
|
|
"room.consult_type AS consult_type," +
|
|
|
"date_format(room.reservation_time ,'%Y-%m-%d %H:%i:%S' ) AS timedate_format," +
|
|
|
"outpatient.disease_img AS disease_img," +
|
|
|
"outpatient.description AS description," +
|
|
|
"room.reservation_type AS reservation_type," +
|
|
|
"outpatient.origin_con_no AS origin_con_no " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"base_patient patient," +
|
|
|
"wlyy_outpatient outpatient " +
|
|
|
"WHERE " +
|
|
|
"room.patient_id=patient.id " +
|
|
|
"AND room.outpatient_id=outpatient.id " +
|
|
|
"AND outpatient.status = 0 ";
|
|
|
//视频复诊，协同门诊 医生抢单
|
|
|
if(type == 2 ){
|
|
|
sql += "AND room.doctor IS NULL ";
|
|
|
}else{
|
|
|
//图文复诊候诊列表
|
|
|
if(0 == query_status){
|
|
|
sql += "AND room.doctor='"+doctor+"' ";
|
|
|
}else{
|
|
|
//图文复诊医生抢单列表
|
|
|
sql += "AND room.doctor IS NULL ";
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//协同门诊
|
|
|
if(3 == type){
|
|
|
sql += " AND room.reservation_type=2 ";
|
|
|
}else{
|
|
|
//在线复诊
|
|
|
sql += " AND room.reservation_type=1 AND room.consult_type="+type ;
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNoneBlank(dept)){
|
|
|
sql += " AND outpatient.dept='"+dept+"' ";
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
if(list!=null&&list.size()>0){
|
|
|
//根据身份证计算年龄
|
|
|
for(Map<String,Object> outpatient :list){
|
|
|
String idcard = (String)outpatient.get("idcard");
|
|
|
outpatient.put("age",DateUtil.getAgeForIdcard(idcard));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
public List<Map<String,Object>> findWaitingRoomPatient(String dept, Integer type) {
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
"patient.id AS id," +
|
|
|
"patient.name AS name," +
|
|
|
"patient.sex AS sex," +
|
|
|
"patient.idcard AS idcard," +
|
|
|
"patient.photo AS photo," +
|
|
|
"waitingroom.reservation_type AS type," +
|
|
|
"waitingroom.consult_type AS consult_type," +
|
|
|
"waitingroom.reservation_time AS reservation_time " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room waitingroom," +
|
|
|
"base_patient patient " +
|
|
|
"WHERE waitingroom.consult_type=2 AND doctor IS NOT NULL ";
|
|
|
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
if(list!=null&&list.size()>0){
|
|
|
//根据身份证计算年龄
|
|
|
for(Map<String,Object> roompatient :list){
|
|
|
String idcard = (String)roompatient.get("idcard");
|
|
|
roompatient.put("age",DateUtil.getAgeForIdcard(idcard));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
public JSONObject findWaitingRoomStatusCount(String dept) {
|
|
|
|
|
|
String totalSql = "SELECT count(id) AS total FROM wlyy_hospital_waiting_room WHERE visit_status=1 ";
|
|
|
totalSql += " AND reservation_time >='"+DateUtil.dateToStrShort(new Date())+" 00:00:00'";
|
|
|
totalSql += " AND reservation_time <='"+DateUtil.dateToStrShort(new Date())+" 23:59:59'";
|
|
|
List<Map<String, Object>> rstotal = jdbcTemplate.queryForList(totalSql);
|
|
|
Long count = 0L;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
count = (Long) rstotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
JSONObject result = new JSONObject();
|
|
|
result.put("waiting_count",count);
|
|
|
result.put("outpatient_count",count);
|
|
|
result.put("waiting_count_difference",count);
|
|
|
result.put("outpatient_count_difference",count);
|
|
|
result.put("yesterday_waiting_count",count);
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
public List<JSONObject> findClinicRoomList(String dept,String date,String consult_status) {
|
|
|
if(StringUtils.isBlank(date)){
|
|
|
date = DateUtil.getStringDateShort();
|
|
|
}
|
|
|
|
|
|
//获取今天的排班列表
|
|
|
String doctorsql ="SELECT doctor,doctor_name,dept,dept_name FROM wlyy_doctor_work_time WHERE date='"+date+"'";
|
|
|
|
|
|
if(StringUtils.isNoneBlank(dept)){
|
|
|
doctorsql = doctorsql + " and dept = '"+dept+"' ";
|
|
|
}
|
|
|
doctorsql = doctorsql+ " GROUP BY doctor";
|
|
|
|
|
|
List<Map<String,Object>> doctorlist = jdbcTemplate.queryForList(doctorsql);
|
|
|
|
|
|
HashMap<String ,JSONObject> result = new HashMap<>();
|
|
|
|
|
|
for (int i = 0; i < doctorlist.size(); i++) {
|
|
|
JSONObject jsonObject = new JSONObject();
|
|
|
jsonObject.put("id",(String)doctorlist.get(0).get("doctor"));
|
|
|
|
|
|
if(StringUtils.isNoneBlank((String)doctorlist.get(0).get("doctor_name"))){
|
|
|
jsonObject.put("doctor_name",(String)doctorlist.get(0).get("doctor_name"));
|
|
|
jsonObject.put("dept_name",(String)doctorlist.get(0).get("dept_name"));
|
|
|
jsonObject.put("dept_code",(String)doctorlist.get(0).get("dept"));
|
|
|
}else{
|
|
|
jsonObject.put("doctor_name","");
|
|
|
jsonObject.put("dept_name","");
|
|
|
jsonObject.put("dept_code","");
|
|
|
}
|
|
|
jsonObject.put("visit_status",1);
|
|
|
jsonObject.put("waiting_count",0);
|
|
|
jsonObject.put("patient_name","");
|
|
|
jsonObject.put("time_cost",0);
|
|
|
|
|
|
result.put((String)doctorlist.get(0).get("doctor"),jsonObject);
|
|
|
}
|
|
|
|
|
|
//获取预约了今天的候诊居民
|
|
|
String waitingSql ="SELECT count(op.id) AS waitCount," +
|
|
|
"room.doctor AS doctor, " +
|
|
|
"room.doctor_name AS doctorName " +
|
|
|
"FROM wlyy_outpatient op,wlyy_hospital_waiting_room room " +
|
|
|
"WHERE op.`status`=0 AND room.outpatient_id=op.id AND room.consult_type=2 " +
|
|
|
"AND room.doctor IS NOT NULL ";
|
|
|
if(StringUtils.isNoneBlank(dept)){
|
|
|
waitingSql = waitingSql + " and op.dept = '"+dept+"' ";
|
|
|
}
|
|
|
waitingSql = waitingSql + "AND room.reservation_time>='"+date+" 00:00:00' AND room.reservation_time<='"+date+" 23:59:59' GROUP BY room.doctor; ";
|
|
|
|
|
|
List<Map<String,Object>> waitinglist = jdbcTemplate.queryForList(waitingSql);
|
|
|
if(waitinglist!=null&&waitinglist.size()>0){
|
|
|
//根据身份证计算年龄
|
|
|
for(Map<String,Object> waitObj :waitinglist){
|
|
|
String doctor = (String) waitObj.get("doctor");
|
|
|
if(StringUtils.isNoneBlank(doctor)){
|
|
|
Long waitCount = (Long) waitObj.get("waitCount");
|
|
|
if(result.keySet().contains(doctor)){
|
|
|
result.get(doctor).put("waiting_count",waitCount);
|
|
|
}else{
|
|
|
JSONObject jsonObject = new JSONObject();
|
|
|
jsonObject.put("id",doctor);
|
|
|
jsonObject.put("visit_status",1);
|
|
|
jsonObject.put("waiting_count",waitCount);
|
|
|
if(StringUtils.isNoneBlank((String)waitObj.get("doctorName"))){
|
|
|
jsonObject.put("doctor_name",(String)waitObj.get("doctorName"));
|
|
|
}else{
|
|
|
jsonObject.put("doctor_name","");
|
|
|
}
|
|
|
jsonObject.put("patient_name","");
|
|
|
jsonObject.put("time_cost",0);
|
|
|
result.put(doctor,jsonObject);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//获取进行中的居民
|
|
|
String onlineSql ="SELECT " +
|
|
|
"room.outpatient_id AS id," +
|
|
|
"room.patient_id AS patient_id," +
|
|
|
"room.patient_name AS patient_name," +
|
|
|
"patient.sex AS sex," +
|
|
|
"patient.idcard AS idcard," +
|
|
|
"patient.photo AS photo," +
|
|
|
"patient.birthday AS birthday," +
|
|
|
"room.consult_type AS consult_type," +
|
|
|
"date_format(room.reservation_time ,'%Y-%m-%d %H:%i:%S' ) AS time," +
|
|
|
"TIMESTAMPDIFF(MINUTE, room.reservation_time,NOW()) AS time_cost," +
|
|
|
"room.doctor AS doctor, " +
|
|
|
"room.doctor_name AS doctorName " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"base_patient patient," +
|
|
|
"wlyy_outpatient outpatient," +
|
|
|
"wlyy_consult_team consult " +
|
|
|
"WHERE " +
|
|
|
"room.patient_id=patient.id " +
|
|
|
"AND room.outpatient_id=outpatient.id " +
|
|
|
"AND consult.relation_code=outpatient.id " +
|
|
|
"AND consult.status=0 " +
|
|
|
"AND room.consult_type=2 ";
|
|
|
if(StringUtils.isNoneBlank(dept)){
|
|
|
onlineSql = onlineSql + " and outpatient.dept = '"+dept+"' ";
|
|
|
}
|
|
|
onlineSql = onlineSql+ "AND room.reservation_time>='"+date+" 00:00:00' AND room.reservation_time<='"+date+" 23:59:59' GROUP BY room.doctor";
|
|
|
|
|
|
List<Map<String,Object>> onlinelist = jdbcTemplate.queryForList(onlineSql);
|
|
|
if(onlinelist!=null&&onlinelist.size()>0){
|
|
|
//根据身份证计算年龄
|
|
|
for(Map<String,Object> onlineObj :onlinelist){
|
|
|
String doctor = (String) onlineObj.get("doctor");
|
|
|
if(StringUtils.isNoneBlank(doctor)){
|
|
|
if(result.keySet().contains(doctor)){
|
|
|
result.get(doctor).put("visit_status",2);
|
|
|
result.get(doctor).put("patient_name",(String) onlineObj.get("patient_name"));
|
|
|
result.get(doctor).put("time_cost",(Long) onlineObj.get("time_cost"));
|
|
|
}else{
|
|
|
JSONObject jsonObject = new JSONObject();
|
|
|
jsonObject.put("id",doctor);
|
|
|
|
|
|
if(StringUtils.isNoneBlank((String) onlineObj.get("doctorName"))){
|
|
|
jsonObject.put("doctor_name",(String) onlineObj.get("doctorName"));
|
|
|
}else{
|
|
|
jsonObject.put("doctor_name","");
|
|
|
}
|
|
|
jsonObject.put("visit_status",2);
|
|
|
jsonObject.put("waiting_count",0);
|
|
|
jsonObject.put("patient_name",(String) onlineObj.get("patient_name"));
|
|
|
jsonObject.put("time_cost",(Long) onlineObj.get("time_cost"));
|
|
|
result.put(doctor,jsonObject);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
List<JSONObject> finalresult = new ArrayList<>();
|
|
|
|
|
|
for (JSONObject jsonObject : result.values()) {
|
|
|
|
|
|
//离线：在线状态=离线
|
|
|
//空闲：在线状态=在线 and 接诊状态=空闲
|
|
|
//接诊中：在线状态=在线 and 接诊状态=接诊中
|
|
|
|
|
|
//过滤空闲或者接诊中的居民
|
|
|
if(StringUtils.isBlank(consult_status)){
|
|
|
finalresult.add(jsonObject);
|
|
|
}else{
|
|
|
if("0".equals(consult_status)){
|
|
|
//只显示在线
|
|
|
}else if("1".equals(consult_status) && "1".equals(jsonObject.getString("visit_status"))){
|
|
|
//空闲
|
|
|
finalresult.add(jsonObject);
|
|
|
}else if("2".equals(consult_status) && "2".equals(jsonObject.getString("visit_status"))){
|
|
|
//接诊
|
|
|
finalresult.add(jsonObject);
|
|
|
}else{}
|
|
|
}
|
|
|
}
|
|
|
Integer room_no = 1;
|
|
|
for(JSONObject jsonObject :finalresult){
|
|
|
String roomname = "";
|
|
|
if(room_no < 10){
|
|
|
roomname = "0"+room_no+"诊室";
|
|
|
}else{
|
|
|
roomname = room_no+"诊室";
|
|
|
}
|
|
|
jsonObject.put("room_name",roomname);
|
|
|
room_no ++;
|
|
|
}
|
|
|
|
|
|
return finalresult;
|
|
|
}
|
|
|
|
|
|
public WlyyDoctorClinicRoomDO findClinicRoomStatus(String id) {
|
|
|
return wlyyDoctorClinicRoomDao.findOne(id);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取快速咨询时间分段
|
|
|
* @param startTime
|
|
|
* @param endTime
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findByTimeSlot(String startTime,String endTime){
|
|
|
int interval = 30;
|
|
|
List<Map<String,Object>> times = new ArrayList<>();
|
|
|
//设置上午过号时间
|
|
|
Calendar scTime = Calendar.getInstance();
|
|
|
scTime.setTime(DateUtil.stringToDate(startTime,"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
Calendar ecTime = Calendar.getInstance();
|
|
|
ecTime.setTime(DateUtil.stringToDate(endTime,"yyyy-MM-dd HH:mm:ss"));
|
|
|
|
|
|
while (scTime.getTime().before(ecTime.getTime())){
|
|
|
if(new Date().before(scTime.getTime())){
|
|
|
Map<String,Object> time = new HashedMap();
|
|
|
time.put("startTime",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
scTime.add(Calendar.MINUTE,interval);
|
|
|
time.put("endTime",DateUtil.dateToStr(scTime.getTime(),"yyyy-MM-dd HH:mm:ss"));
|
|
|
times.add(time);
|
|
|
}else{
|
|
|
scTime.add(Calendar.MINUTE,interval);
|
|
|
}
|
|
|
}
|
|
|
return times;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 根据疾病名称，热门部门查询医生
|
|
|
* @param orgCode 机构码
|
|
|
* @param dept 部门CODE
|
|
|
* @param diseaseKey 疾病名称
|
|
|
* @param jobTitleNameKey
|
|
|
* @param outpatientType
|
|
|
* @param keyName
|
|
|
* @param workingTime
|
|
|
* @param consutlSort
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findDoctorByHospitalAndDiseaseAndDept(String iswork,String patientid,String orgCode, String dept,
|
|
|
String diseaseKey, String doctorNameKey,
|
|
|
String jobTitleNameKey, String outpatientType,
|
|
|
String keyName, String workingTime, String consultStatus,String chargType,String consutlSort,Integer page,Integer pagesize) {
|
|
|
|
|
|
/* if(page >=1){
|
|
|
page --;
|
|
|
}
|
|
|
|
|
|
if (pagesize <= 0) {
|
|
|
pagesize = 10;
|
|
|
}*/
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.photo AS \"photo\", " +
|
|
|
" d.name AS \"name\", " +
|
|
|
" d.expertise AS \"expertise\"," +
|
|
|
" d.introduce AS \"introduce\"," +
|
|
|
" d.job_title_code AS \"jobTitleCode\", " +
|
|
|
" d.job_title_name AS \"jobTitleName\"," +
|
|
|
" d.charge_type AS \"chargeType\"," +
|
|
|
" h.dept_name AS \"deptName\"," +
|
|
|
" d.consult_status AS \"consultStatus\"," +
|
|
|
" d.outpatient_type AS \"outpatientType\"," +
|
|
|
" a.total AS \"consultTotal\"," +
|
|
|
" h.org_name AS \"orgName\"," +
|
|
|
" follow.patient AS \"followid\"," +
|
|
|
" h.org_code AS \"orgCode\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON h.doctor_code = d.id "+
|
|
|
" Left join base_doctor_patient_follow follow on follow.doctor = d.id and follow.patient='"+patientid+"'"+
|
|
|
" Left join ( select count(id) as total,doctor from wlyy_outpatient where status = 2 GROUP BY doctor ) a on a.doctor = d.id ";
|
|
|
|
|
|
if(StringUtils.isNotBlank(workingTime)){
|
|
|
sql+=" JOIN wlyy_doctor_work_time wk on wk.doctor = d.id ";
|
|
|
}
|
|
|
|
|
|
sql += " WHERE 1=1 ";
|
|
|
|
|
|
Map<String, Object> params = new HashedMap();
|
|
|
|
|
|
if(StringUtils.isBlank(chargType)){
|
|
|
sql +=" AND d.charge_type is not null ";
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(chargType)){
|
|
|
if("all".equals(chargType)){
|
|
|
//不过滤
|
|
|
}else{
|
|
|
sql+=" AND d.charge_type = :chargType";
|
|
|
params.put("chargType",chargType);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(iswork)&&"1".equals(iswork)){
|
|
|
logger.info("iswork:"+iswork);
|
|
|
Date date = new Date();
|
|
|
sql+=" AND (" +
|
|
|
" EXISTS ( " +
|
|
|
" SELECT " +
|
|
|
" 1 " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time t " +
|
|
|
" WHERE " +
|
|
|
" t.doctor = d.id " +
|
|
|
" AND t.start_time <=:startTime" +
|
|
|
" AND t.end_time >=:endTime"+
|
|
|
" ) OR " +
|
|
|
" d.consult_status = '1') ";
|
|
|
params.put("startTime",date);
|
|
|
params.put("endTime",date);
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(orgCode)){
|
|
|
sql += " AND h.org_code = :orgCode";
|
|
|
params.put("orgCode",orgCode);
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(diseaseKey)){
|
|
|
sql+=" AND d.expertise like :diseaseKey";
|
|
|
params.put("diseaseKey","%"+diseaseKey+"%");
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(doctorNameKey)){
|
|
|
sql+=" AND d.name like :doctorNameKey";
|
|
|
params.put("doctorNameKey","%"+doctorNameKey+"%");
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(dept)){
|
|
|
sql+=" AND h.dept_code = :dept ";
|
|
|
params.put("dept",dept);
|
|
|
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(jobTitleNameKey)){
|
|
|
sql+=" AND d.job_title_name = :jobTitleNameKey ";
|
|
|
params.put("jobTitleNameKey",jobTitleNameKey);
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(outpatientType)){
|
|
|
if(outpatientType.contains("or")){
|
|
|
String[] outpatientTypeArray = outpatientType.split("or");
|
|
|
sql+= " AND ( ";
|
|
|
|
|
|
for (int i = 0; i < outpatientTypeArray.length; i++) {
|
|
|
sql +=" d.outpatient_type like'%"+outpatientTypeArray[i]+"%'";
|
|
|
if(i != outpatientTypeArray.length -1){
|
|
|
sql += " or ";
|
|
|
}
|
|
|
}
|
|
|
sql+= " ) ";
|
|
|
}else{
|
|
|
sql+= " AND d.outpatient_type like'%"+outpatientType+"%'";
|
|
|
}
|
|
|
}else{
|
|
|
sql+=" AND d.outpatient_type is not null ";
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(keyName)){
|
|
|
sql+=" AND (h.dept_name like '%"+keyName+"%' or d.name like '%"+keyName+"%' or d.expertise like '%"+keyName+"%' )";
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(workingTime)){
|
|
|
sql+=" AND wk.date = :workingTime ";
|
|
|
params.put("workingTime",workingTime);
|
|
|
}
|
|
|
|
|
|
|
|
|
if(StringUtils.isNotBlank(consultStatus)){
|
|
|
sql+=" AND d.consult_status = :consultStatus ";
|
|
|
params.put("consultStatus",consultStatus);
|
|
|
|
|
|
}
|
|
|
|
|
|
sql += " and d.del='1' order by a.total "+ consutlSort;
|
|
|
|
|
|
List<Map<String,Object>> list = hibenateUtils.createSQLQuery(sql,params,page,pagesize);
|
|
|
|
|
|
logger.info("findDoctorByHospitalAndDiseaseAndDept end:"+DateUtil.dateToStr(new Date(),"yyyy-MM-dd HH:mm:ss:SSS"));
|
|
|
logger.info("sql:"+sql);
|
|
|
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取常见疾病、热门部门、医生拒绝接诊原因 字典
|
|
|
* @param dictName 字典名称
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findHotDeptAndDiseaseDict(String dictName) {
|
|
|
String sql ="SELECT * from wlyy_hospital_sys_dict where dict_name='"+dictName+"' ORDER BY sort ASC";
|
|
|
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 查询排班规则
|
|
|
* @return
|
|
|
*/
|
|
|
public List<WlyyHospitalSysDictVO> findWorkRule(String dictName,String hospital){
|
|
|
List<WlyyHospitalSysDictDO> list = sysDictDao.findByHospitalAndDictNameOrderBySortAsc(hospital,dictName);
|
|
|
List<WlyyHospitalSysDictVO> vos = new ArrayList<>();
|
|
|
return convertToModels(list,vos,WlyyHospitalSysDictVO.class);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 保存排班规则
|
|
|
* @param workRoleJsons
|
|
|
* @return
|
|
|
*/
|
|
|
public Boolean updateWorkRule(String workRoleJsons){
|
|
|
List<WlyyHospitalSysDictDO> sysDicts = (List<WlyyHospitalSysDictDO>) com.alibaba.fastjson.JSONArray.parseArray(workRoleJsons, WlyyHospitalSysDictDO.class);
|
|
|
List<WlyyHospitalSysDictDO> list = sysDictDao.findByHospitalAndDictNameOrderBySortAsc(sysDicts.get(0).getHospital(),sysDicts.get(0).getDictName());
|
|
|
sysDictDao.delete(list);
|
|
|
sysDictDao.save(sysDicts);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @param type
|
|
|
* @param codes
|
|
|
* @param workTimeJson
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public Boolean saveDoctorWorkTimeJson(String type,String codes,String workTimeJson,String date)throws Exception{
|
|
|
|
|
|
com.alibaba.fastjson.JSONArray works = JSON.parseArray(workTimeJson);
|
|
|
List<WlyyDoctorWorkTimeDO> wlyyDoctorWorkTimeDOs = new ArrayList<>();
|
|
|
for(int i=0;i<works.size();i++){
|
|
|
com.alibaba.fastjson.JSONObject work = (com.alibaba.fastjson.JSONObject)works.get(i);
|
|
|
WlyyDoctorWorkTimeDO timeDO = objectMapper.readValue(work.toJSONString(),WlyyDoctorWorkTimeDO.class);
|
|
|
wlyyDoctorWorkTimeDOs.add(timeDO);
|
|
|
}
|
|
|
|
|
|
//全院医生
|
|
|
if("1".equals(type)){
|
|
|
String sql ="SELECT " +
|
|
|
" DISTINCT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.name AS \"name\", " +
|
|
|
" h.org_code AS \"org_code\", " +
|
|
|
" h.org_name AS \"org_name\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON d.id= h.doctor_code " +
|
|
|
" WHERE " +
|
|
|
" h.org_code ='"+codes+"'";
|
|
|
List<Map<String,Object>> doctors = jdbcTemplate.queryForList(sql);
|
|
|
List<WlyyDoctorWorkTimeDO> workTimeDOs =makeDoctorWorkTimeDOList(doctors,wlyyDoctorWorkTimeDOs);
|
|
|
saveDoctorWorkTime(workTimeDOs,date,doctors);
|
|
|
//科室
|
|
|
}else if("2".equals(type)){
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
" DISTINCT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.name AS \"name\", " +
|
|
|
" h.org_code AS \"org_code\", " +
|
|
|
" h.org_name AS \"org_name\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON d.id= h.doctor_code " +
|
|
|
" WHERE " +
|
|
|
" h.dept_code in ("+sqlCode(codes)+")";
|
|
|
List<Map<String,Object>> doctors = jdbcTemplate.queryForList(sql);
|
|
|
List<WlyyDoctorWorkTimeDO> workTimeDOs =makeDoctorWorkTimeDOList(doctors,wlyyDoctorWorkTimeDOs);
|
|
|
saveDoctorWorkTime(workTimeDOs,date,doctors);
|
|
|
//医生批量
|
|
|
}else if("3".equals(type)){
|
|
|
String sql ="SELECT " +
|
|
|
" DISTINCT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.name AS \"name\", " +
|
|
|
" h.org_code AS \"org_code\", " +
|
|
|
" h.org_name AS \"org_name\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_hospital h ON d.id= h.doctor_code " +
|
|
|
" WHERE " +
|
|
|
" d.id in ("+sqlCode(codes)+")";
|
|
|
List<Map<String,Object>> doctors = jdbcTemplate.queryForList(sql);
|
|
|
List<WlyyDoctorWorkTimeDO> workTimeDOs =makeDoctorWorkTimeDOList(doctors,wlyyDoctorWorkTimeDOs);
|
|
|
saveDoctorWorkTime(workTimeDOs,date,doctors);
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
public String sqlCode(String codes){
|
|
|
String code[] = codes.split(",");
|
|
|
String rs = "";
|
|
|
for(String c:code){
|
|
|
rs+="'"+c+"',";
|
|
|
}
|
|
|
rs = rs.substring(0,rs.length()-1);
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
public List<WlyyDoctorWorkTimeDO> makeDoctorWorkTimeDOList(List<Map<String,Object>> doctors,List<WlyyDoctorWorkTimeDO> wlyyDoctorWorkTimeDOs){
|
|
|
List<WlyyDoctorWorkTimeDO> rs = new ArrayList<>();
|
|
|
if(doctors!=null&&doctors.size()>0){
|
|
|
//构建医生排班
|
|
|
for(Map<String,Object> doctor:doctors){
|
|
|
for(WlyyDoctorWorkTimeDO time:wlyyDoctorWorkTimeDOs){
|
|
|
WlyyDoctorWorkTimeDO t = new WlyyDoctorWorkTimeDO();
|
|
|
t.setDoctor((String)doctor.get("id"));
|
|
|
t.setDoctorName((String)doctor.get("name"));
|
|
|
// t.setDept((String)doctor.get("dept_code"));
|
|
|
// t.setDeptName((String)doctor.get("dept_name"));
|
|
|
t.setHospital((String)doctor.get("org_code"));
|
|
|
t.setHospitalName((String)doctor.get("org_name"));
|
|
|
t.setCreateTime(new Date());
|
|
|
|
|
|
t.setType(time.getType());
|
|
|
t.setTimeType(time.getTimeType());
|
|
|
t.setStartTime(time.getStartTime());
|
|
|
t.setEndTime(time.getEndTime());
|
|
|
t.setDate(time.getDate());
|
|
|
t.setTimeInterval(time.getTimeInterval());
|
|
|
t.setSourceNumber(time.getSourceNumber());
|
|
|
rs.add(t);
|
|
|
}
|
|
|
logger.info(rs.size()+"");
|
|
|
}
|
|
|
}
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 批量更新医生多月份排班数据
|
|
|
* @param workTimeDOs
|
|
|
* @return
|
|
|
*/
|
|
|
public Boolean saveDoctorWorkTime(List<WlyyDoctorWorkTimeDO> workTimeDOs,String date,List<Map<String,Object>> doctors){
|
|
|
|
|
|
if(workTimeDOs!=null&&workTimeDOs.size()>0){
|
|
|
//按月按医生分组标记排班数据
|
|
|
List<String> workMonths = new ArrayList<>();
|
|
|
|
|
|
for(WlyyDoctorWorkTimeDO time : workTimeDOs){
|
|
|
//医生工作月份
|
|
|
String workMonth = time.getDoctor()+","+time.getDate().substring(0,7);
|
|
|
//判断是否是首次插入医生月份数据，如果是首次，则删除该医生当前月份排班数据数据
|
|
|
if(!workMonths.contains(workMonth)){
|
|
|
workMonths.add(workMonth);
|
|
|
List<WlyyDoctorWorkTimeDO> oldTimes = doctorWorkTimeDao.findDoctorWorkTimeByMonth(time.getDoctor(),"%"+time.getDate().substring(0,7)+"%");
|
|
|
doctorWorkTimeDao.delete(oldTimes);
|
|
|
}
|
|
|
}
|
|
|
doctorWorkTimeDao.save(workTimeDOs);
|
|
|
}else{
|
|
|
//如果排班数据为空，删除医生月份下排班数据
|
|
|
if(StringUtils.isNotBlank(date)){
|
|
|
String d[] = date.split(",");
|
|
|
for(String dt:d){
|
|
|
for(Map<String,Object> doc:doctors){
|
|
|
List<WlyyDoctorWorkTimeDO> oldTimes = doctorWorkTimeDao.findDoctorWorkTimeByMonth((String)doc.get("id"),"%"+dt+"%");
|
|
|
doctorWorkTimeDao.delete(oldTimes);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 查询某个医生某个月份排班记录
|
|
|
* @param doctor
|
|
|
* @param date
|
|
|
* @return
|
|
|
*/
|
|
|
public List<WlyyDoctorWorkTimeVO> findDoctorWorkTimeByMonth(String doctor,String date,String startDate,String endDate){
|
|
|
|
|
|
if(StringUtils.isNotBlank(date)){
|
|
|
List<WlyyDoctorWorkTimeDO> times = doctorWorkTimeDao.findDoctorWorkTimeByMonth(doctor,"%"+date+"%");
|
|
|
List<WlyyDoctorWorkTimeVO> timeVOs = new ArrayList<>();
|
|
|
return convertToModels(times,timeVOs,WlyyDoctorWorkTimeVO.class);
|
|
|
}else{
|
|
|
List<WlyyDoctorWorkTimeDO> times = doctorWorkTimeDao.findDoctorWorkTimeByTime(doctor,DateUtil.stringToDate(startDate+" 00:00:00","yyyy-MM-dd HH:mm:ss"),DateUtil.stringToDate(endDate+" 23:59:59","yyyy-MM-dd HH:mm:ss"));
|
|
|
List<WlyyDoctorWorkTimeVO> timeVOs = new ArrayList<>();
|
|
|
return convertToModels(times,timeVOs,WlyyDoctorWorkTimeVO.class);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public Map<String,Object> findPatientInfo(String patient){
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
BasePatientDO basePatientDO = basePatientDao.findById(patient);
|
|
|
rs.put("id",patient);
|
|
|
rs.put("name",basePatientDO.getName());
|
|
|
rs.put("sex",basePatientDO.getSex());
|
|
|
rs.put("provinceCode",basePatientDO.getProvinceCode());
|
|
|
rs.put("provinceName",basePatientDO.getProvinceName());
|
|
|
rs.put("cityCode",basePatientDO.getCityCode());
|
|
|
rs.put("cityName",basePatientDO.getCityName());
|
|
|
rs.put("townCode",basePatientDO.getTownCode());
|
|
|
rs.put("townName",basePatientDO.getTownName());
|
|
|
rs.put("idcard",basePatientDO.getIdcard());
|
|
|
rs.put("age",IdCardUtil.getAgeForIdcard(basePatientDO.getIdcard()));
|
|
|
rs.put("mobile",basePatientDO.getMobile());
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
public Map<String,Object> getPatientInfoMap(BasePatientDO basePatientDO){
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
rs.put("id",basePatientDO.getId());
|
|
|
rs.put("name",basePatientDO.getName());
|
|
|
rs.put("sex",basePatientDO.getSex());
|
|
|
rs.put("provinceCode",basePatientDO.getProvinceCode());
|
|
|
rs.put("provinceName",basePatientDO.getProvinceName());
|
|
|
rs.put("cityCode",basePatientDO.getCityCode());
|
|
|
rs.put("cityName",basePatientDO.getCityName());
|
|
|
rs.put("townCode",basePatientDO.getTownCode());
|
|
|
rs.put("townName",basePatientDO.getTownName());
|
|
|
rs.put("idcard",basePatientDO.getIdcard());
|
|
|
rs.put("age",IdCardUtil.getAgeForIdcard(basePatientDO.getIdcard()));
|
|
|
rs.put("mobile",basePatientDO.getMobile());
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
|
|
|
@Autowired
|
|
|
private FileUploadService fileUploadService;
|
|
|
|
|
|
public Map<String,Object> test() throws Exception{
|
|
|
entranceService.MS02014(false);
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
public String test2(String no) throws Exception{
|
|
|
TransRequest e = new TransRequest();
|
|
|
e.setMethod("ehc.ehealthcard.auth.query");
|
|
|
e.setApp_id("1BQA48ETK000A718A8C000001FFAA482");
|
|
|
e.setTerm_id("35020010001");
|
|
|
e.setVersion("X.M.0.1");
|
|
|
e.setTimestamp(DateUtil.dateToStr(new Date(),"yyyyMMddHHmmss"));
|
|
|
e.setSign_type("MD5");
|
|
|
e.setEnc_type("AES");
|
|
|
com.alibaba.fastjson.JSONObject bizContent = new com.alibaba.fastjson.JSONObject();
|
|
|
bizContent.put("out_authorize_no", no);
|
|
|
bizContent.put("out_authorize_time", DateUtils.getOutTradeTime());
|
|
|
e.setBiz_content(JSON.toJSONString(bizContent));
|
|
|
EhcHandler ehcHandler = new EhcHandler("http://www.mstpay.com:1811/ehcService/gateway.do", "1BQA48ETK000A718A8C000001FFAA482", "35020010001", "1BQA48ETK001A718A8C00000FE996B9B");
|
|
|
TransResponse re = ehcHandler.execute(e);
|
|
|
String rs = com.alibaba.fastjson.JSONObject.toJSONString(re);
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 获取正在进行中的视频复诊/协同门诊
|
|
|
* @param doctor
|
|
|
* @param general_doctor
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> getVideoPrescriptionByDoctor(String doctor,String general_doctor) {
|
|
|
String sql ="SELECT " +
|
|
|
"room.outpatient_id AS id," +
|
|
|
"room.patient_id AS patient_id," +
|
|
|
"room.patient_name AS name," +
|
|
|
"patient.sex AS sex," +
|
|
|
"patient.idcard AS idcard," +
|
|
|
"patient.photo AS photo," +
|
|
|
"patient.birthday AS birthday," +
|
|
|
"patient.mobile AS mobile," +
|
|
|
"room.consult_type AS consult_type," +
|
|
|
"date_format(room.reservation_time ,'%Y-%m-%d %H:%i:%S' ) AS time," +
|
|
|
"room.reservation_type AS reservation_type," +
|
|
|
"outpatient.disease_img AS disease_img," +
|
|
|
"outpatient.description AS description," +
|
|
|
"outpatient.origin_con_no AS origin_con_no, " +
|
|
|
"consult.consult AS consult " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"base_patient patient," +
|
|
|
"wlyy_outpatient outpatient, " +
|
|
|
"wlyy_consult_team consult " +
|
|
|
"WHERE " +
|
|
|
"room.patient_id=patient.id " +
|
|
|
"AND room.outpatient_id=outpatient.id " +
|
|
|
"AND consult.relation_code=outpatient.id " +
|
|
|
"AND consult.status = 0 ";
|
|
|
if(StringUtils.isNoneBlank(doctor)){
|
|
|
sql = sql +"AND room.doctor='"+doctor+"' " +
|
|
|
"AND room.consult_type= 2";
|
|
|
}else if(StringUtils.isNoneBlank(general_doctor)){
|
|
|
sql = sql +"AND room.general_doctor='"+general_doctor+"' " +
|
|
|
"AND room.consult_type= 2";
|
|
|
}else{}
|
|
|
|
|
|
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
if(list!=null&&list.size()>0){
|
|
|
//根据身份证计算年龄
|
|
|
for(Map<String,Object> outpatient :list){
|
|
|
String idcard = (String)outpatient.get("idcard");
|
|
|
String patient_id = (String)outpatient.get("patient_id");
|
|
|
outpatient.put("age",DateUtil.getAgeForIdcard(idcard));
|
|
|
|
|
|
String outpatient_id = (String)outpatient.get("id");
|
|
|
|
|
|
String isAlert = redisTemplate.opsForValue().get("patient_alert_"+patient_id);
|
|
|
if(StringUtils.isBlank(isAlert)){
|
|
|
outpatient.put("alert_tag",0);//已提醒
|
|
|
}else{
|
|
|
outpatient.put("alert_tag",1);//未提醒
|
|
|
}
|
|
|
outpatient.put("online_tag",1);//未提醒
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
public com.alibaba.fastjson.JSONArray getWaitingForVisitVideoPrescriptionByDoctor(String doctor) {
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
"room.outpatient_id AS id," +
|
|
|
"room.patient_id AS patient_id," +
|
|
|
"room.patient_name AS name," +
|
|
|
"patient.sex AS sex," +
|
|
|
"patient.idcard AS idcard," +
|
|
|
"patient.photo AS photo," +
|
|
|
"patient.birthday AS birthday," +
|
|
|
"patient.mobile AS mobile," +
|
|
|
"outpatient.mobile AS outpatient_mobile," +
|
|
|
"room.consult_type AS consult_type," +
|
|
|
"date_format(room.reservation_time ,'%Y-%m-%d %H:%i:%S' ) AS time," +
|
|
|
"date_format(room.reservation_time ,'%Y-%m-%d' ) AS group_date," +
|
|
|
"room.reservation_type AS reservation_type," +
|
|
|
"outpatient.disease_img AS disease_img," +
|
|
|
"outpatient.description AS description," +
|
|
|
"outpatient.origin_con_no AS origin_con_no, " +
|
|
|
"room.reservation_type AS reservation_type " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"base_patient patient," +
|
|
|
"wlyy_outpatient outpatient " +
|
|
|
"WHERE " +
|
|
|
"room.patient_id=patient.id " +
|
|
|
"AND room.outpatient_id=outpatient.id " +
|
|
|
"AND outpatient.status = 0 " +
|
|
|
"AND room.doctor='"+doctor+"' " +
|
|
|
"AND room.reservation_time is not null " +
|
|
|
"AND room.consult_type= 2 AND room.reservation_time >= '"+DateUtil.dateToStrShort(new Date())+" 00:00:00' order by room.reservation_time ASC ";
|
|
|
// "AND room.reservation_time>='"+DateUtil.getStringDate("yyyy-MM-dd")+" 00:00:00"+"' ";
|
|
|
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
Set<String> datelist = new HashSet<>();
|
|
|
|
|
|
HashMap<String,List<Map<String,Object>>> waitinglist = new HashMap<>();
|
|
|
|
|
|
if(list!=null&&list.size()>0){
|
|
|
//根据身份证计算年龄
|
|
|
for(Map<String,Object> outpatient :list){
|
|
|
String idcard = (String)outpatient.get("idcard");
|
|
|
String patient_id = (String)outpatient.get("patient_id");
|
|
|
outpatient.put("age",DateUtil.getAgeForIdcard(idcard));
|
|
|
|
|
|
String group_date = (String)outpatient.get("group_date");
|
|
|
|
|
|
if(waitinglist.keySet().contains(group_date)){
|
|
|
waitinglist.get(group_date).add(outpatient);
|
|
|
}else{
|
|
|
List<Map<String,Object>> _cu = new ArrayList<>();
|
|
|
_cu.add(outpatient);
|
|
|
waitinglist.put(group_date,_cu);
|
|
|
}
|
|
|
|
|
|
//全科医生来源
|
|
|
outpatient.put("general_doctor_info","");//全科医生名字
|
|
|
outpatient.put("general_doctor_hospital","");//全科医生社区
|
|
|
String isAlert = redisTemplate.opsForValue().get("patient_alert_"+patient_id);
|
|
|
if(StringUtils.isBlank(isAlert)){
|
|
|
outpatient.put("alert_tag",0);//已提醒
|
|
|
}else{
|
|
|
outpatient.put("alert_tag",1);//未提醒
|
|
|
}
|
|
|
|
|
|
outpatient.put("online_tag",1);//在线状态
|
|
|
|
|
|
String outpatient_mobile = (String)outpatient.get("outpatient_mobile");
|
|
|
if(StringUtils.isNoneBlank(outpatient_mobile)){
|
|
|
outpatient.put("mobile",outpatient_mobile);//复诊有手机号，传递复诊手机号
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Collection<String> keyset= waitinglist.keySet();
|
|
|
List<String> _list = new ArrayList<String>(keyset);
|
|
|
|
|
|
//对key键值按字典升序排序
|
|
|
Collections.sort(_list);
|
|
|
com.alibaba.fastjson.JSONArray result = new com.alibaba.fastjson.JSONArray();
|
|
|
|
|
|
|
|
|
for (int i = 0; i < _list.size(); i++) {
|
|
|
com.alibaba.fastjson.JSONObject object = new com.alibaba.fastjson.JSONObject();
|
|
|
if(_list.get(i).equals(DateUtil.getStringDateShort())){
|
|
|
object.put("day","today");
|
|
|
}else{
|
|
|
object.put("day",_list.get(i));
|
|
|
}
|
|
|
object.put("data",waitinglist.get(_list.get(i)));
|
|
|
result.add(object);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 医生抢单(视频)
|
|
|
* @param outpatientCode
|
|
|
* @param doctor
|
|
|
*/
|
|
|
public void pickVideoPrescripitonWaitingPeople(String outpatientCode, String doctor) throws Exception{
|
|
|
BaseDoctorDO baseDoctorDO = baseDoctorDao.findById(doctor);
|
|
|
List<WlyyHospitalWaitingRoomDO> roomDOs =hospitalWaitingRoomDao.findByOutpatientId(outpatientCode);
|
|
|
if(roomDOs!=null&&roomDOs.size()>0){
|
|
|
for(WlyyHospitalWaitingRoomDO roomDO:roomDOs){
|
|
|
roomDO.setDoctor(doctor);
|
|
|
roomDO.setDoctorName(baseDoctorDO.getName());
|
|
|
hospitalWaitingRoomDao.save(roomDO);
|
|
|
}
|
|
|
}
|
|
|
WlyyOutpatientDO wlyyOutpatientDO = outpatientDao.findOne(outpatientCode);
|
|
|
wlyyOutpatientDO.setDoctor(doctor);
|
|
|
wlyyOutpatientDO.setDoctorName(baseDoctorDO.getName());
|
|
|
outpatientDao.save(wlyyOutpatientDO);
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 复诊视频咨询人数, 协同门诊人数
|
|
|
* @param doctor
|
|
|
* @param outpatient_type 1复诊 2协同
|
|
|
* @return
|
|
|
*/
|
|
|
public Long doctorIndexConsultCount(String doctor,String outpatient_type) {
|
|
|
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
"count(room.outpatient_id) AS total " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"base_patient patient," +
|
|
|
"wlyy_outpatient outpatient, " +
|
|
|
"wlyy_consult_team consult " +
|
|
|
"WHERE " +
|
|
|
"room.patient_id=patient.id " +
|
|
|
"AND room.outpatient_id=outpatient.id " +
|
|
|
"AND consult.relation_code=outpatient.id " +
|
|
|
"AND consult.status = 0 " +
|
|
|
"AND outpatient_type.doctor='"+outpatient_type+"'" +
|
|
|
"AND room.doctor='"+doctor+"' ";
|
|
|
if("1".equals(outpatient_type)){
|
|
|
sql = sql + " AND room.consult_type= 2 ";
|
|
|
}else if("2".equals(outpatient_type)){
|
|
|
}else{}
|
|
|
|
|
|
List<Map<String, Object>> rstotal = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
Long videoOnlineCount = 0l;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
videoOnlineCount = (Long) rstotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
return videoOnlineCount;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 根据门诊唯一号，处方号，到顺丰下单，下单成功返回面单信息
|
|
|
* @param admNo 门诊唯一号
|
|
|
* @param realOrder 处方号
|
|
|
* @return
|
|
|
*/
|
|
|
public Object getSFExpressInfo(String admNo,String realOrder)throws Exception {
|
|
|
|
|
|
//根据门诊唯一号取就诊记录
|
|
|
List<WlyyOutpatientDO> wlyyOutpatientDOs = outpatientDao.findByAdmNo(admNo);
|
|
|
|
|
|
Object result = "";
|
|
|
|
|
|
|
|
|
if(!wlyyOutpatientDOs.isEmpty() && wlyyOutpatientDOs.size()>0){
|
|
|
List<WlyyPrescriptionExpressageDO> expressageDOList = sfexpressService.findByField("outpatientId",wlyyOutpatientDOs.get(0).getId());
|
|
|
WlyyPrescriptionExpressageDO sfexpress_obj = null;
|
|
|
if(CollectionUtils.isEmpty(expressageDOList)){
|
|
|
throw new Exception("顺丰快递下单失败，未找到该处方的派送地址！");
|
|
|
}else{
|
|
|
sfexpress_obj = expressageDOList.get(0);
|
|
|
//如果该处方的快递单号已生成，则说明已经下单成功，不需要重复下单，直接返回面单信息
|
|
|
if(org.apache.commons.lang.StringUtils.isNotBlank(sfexpress_obj.getMailno())){
|
|
|
//处方已下单成功
|
|
|
}else{
|
|
|
//如果该处方的快递单号未生成，则继续下单
|
|
|
//根据业务订单号判断是否已经下单成功
|
|
|
boolean go_on = sfexpressService.sfOrderSearchService(sfexpress_obj);
|
|
|
|
|
|
//如果该业务订单号未下单成功过，则重新下单
|
|
|
if(go_on){
|
|
|
//请求顺丰接口下单，成功下单后，返回快递单号
|
|
|
sfexpress_obj = sfexpressService.postSFOrderService(sfexpress_obj);
|
|
|
//保存快递单号和增加处方物流记录为配送
|
|
|
sfexpressService.updatePrescriptionExpressage(sfexpress_obj);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if(sfexpress_obj != null && StringUtils.isNoneBlank(sfexpress_obj.getMailno())){
|
|
|
com.alibaba.fastjson.JSONObject sfJsonObject = new com.alibaba.fastjson.JSONObject();
|
|
|
|
|
|
sfJsonObject.put("mailno", sfexpress_obj.getMailno());
|
|
|
sfJsonObject.put("mailtype", "标准快递");
|
|
|
sfJsonObject.put("destcode", "592");
|
|
|
sfJsonObject.put("j_name", "厦门大学附属中山医院");
|
|
|
sfJsonObject.put("j_provinceName", "福建省");
|
|
|
sfJsonObject.put("j_cityName", "厦门市");
|
|
|
sfJsonObject.put("j_townName", "思明区");
|
|
|
sfJsonObject.put("j_address", "湖滨南路201-209号");
|
|
|
sfJsonObject.put("j_phone", "4003008888");
|
|
|
sfJsonObject.put("d_name", sfexpress_obj.getName());
|
|
|
sfJsonObject.put("d_provinceName", sfexpress_obj.getProvinceName());
|
|
|
sfJsonObject.put("d_cityName", sfexpress_obj.getCityName());
|
|
|
sfJsonObject.put("d_townName", sfexpress_obj.getTownName());
|
|
|
sfJsonObject.put("d_address", sfexpress_obj.getAddress());
|
|
|
sfJsonObject.put("d_phone",sfexpress_obj.getMobile());
|
|
|
sfJsonObject.put("express_type",11);
|
|
|
sfJsonObject.put("pay_method",2);
|
|
|
sfJsonObject.put("receive_time","");
|
|
|
sfJsonObject.put("dispensaryType",2);
|
|
|
result = sfJsonObject;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 根据类型获取候诊居民数量
|
|
|
* @param doctor
|
|
|
* @param outpatient_type 1复诊 2协同
|
|
|
* @param type 1图文 2视频
|
|
|
* @return
|
|
|
*/
|
|
|
public Long getWaitVideoCount(String doctor,String type,String outpatient_type) {
|
|
|
String sql ="SELECT " +
|
|
|
"count(outpatient.id) AS total " +
|
|
|
"FROM " +
|
|
|
"wlyy_outpatient outpatient," +
|
|
|
"base_patient patient " +
|
|
|
"WHERE " +
|
|
|
"outpatient.patient=patient.id " +
|
|
|
"AND outpatient.status in (0,1) " +
|
|
|
"AND outpatient.doctor='"+doctor+"' " +
|
|
|
"AND outpatient.outpatient_type= '"+outpatient_type+"' ";
|
|
|
if("1".equals(outpatient_type)){//复诊
|
|
|
sql = sql + " AND outpatient.type= '"+type+"' ";
|
|
|
if("2".equals(type)){//视频复诊才需要判断时间，
|
|
|
sql = sql + " AND outpatient.register_date is not null AND outpatient.register_date >= '"+DateUtil.dateToStrShort(new Date())+" 00:00:00' ";
|
|
|
}
|
|
|
}else if("2".equals(outpatient_type)){
|
|
|
//协同门诊也需要判断时间
|
|
|
sql = sql + " AND outpatient.register_date is not null AND outpatient.register_date >= '"+DateUtil.dateToStrShort(new Date())+" 00:00:00' ";
|
|
|
}
|
|
|
List<Map<String, Object>> rstotal = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
Long waitVideoCount = 0l;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
waitVideoCount = Long.parseLong(rstotal.get(0).get("total").toString());
|
|
|
}
|
|
|
|
|
|
return waitVideoCount;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 保存在线排班
|
|
|
* @param onlineWorkJson
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public Envelop saveDoctorOnlineWork(String onlineWorkJson)throws Exception{
|
|
|
WlyyDoctorOnlineTimeDO timeDO = objectMapper.readValue(onlineWorkJson,WlyyDoctorOnlineTimeDO.class);
|
|
|
List<WlyyDoctorOnlineTimeDO> list = wlyyDoctorOnlineTimeDao.findWorkExistList(timeDO.getDoctor(),timeDO.getStartTime(),timeDO.getEndTime());
|
|
|
if(list!=null&&list.size()>0){
|
|
|
return Envelop.getError("排班已存在",-1);
|
|
|
}
|
|
|
timeDO.setCreateTime(new Date());
|
|
|
return Envelop.getSuccess("保存成功");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 删除在线排班
|
|
|
* @param id
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public Envelop delDoctorOnlineWork(String id)throws Exception{
|
|
|
wlyyDoctorOnlineTimeDao.delete(id);
|
|
|
return Envelop.getSuccess("删除成功");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 查询医生在线排班
|
|
|
* @param doctor
|
|
|
* @param startDate
|
|
|
* @param endDate
|
|
|
* @return
|
|
|
*/
|
|
|
public List<WlyyDoctorOnlineTimeDO> findDoctorOnlineWorkList(String doctor,String startDate,String endDate){
|
|
|
return wlyyDoctorOnlineTimeDao.findWorkList(doctor,DateUtil.stringToDate(startDate+" 00:00:00","yyyy-MM-dd HH:mm:ss"),DateUtil.stringToDate(endDate+" 23:59:59","yyyy-MM-dd HH:mm:ss"));
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 发起图文和视频协同门诊复诊
|
|
|
* @param outpatientJson
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public WlyyOutpatientDO cooperativeOutpatient(String outpatientJson,String registerJson,String chargeType)throws Exception{
|
|
|
|
|
|
//1.保存就诊实体
|
|
|
WlyyOutpatientDO outpatientDO = objectMapper.readValue(outpatientJson,WlyyOutpatientDO.class);
|
|
|
BasePatientDO patientDO = basePatientDao.findById(outpatientDO.getPatient());
|
|
|
|
|
|
outpatientDO.setMjz("mz");
|
|
|
outpatientDO.setStatus("0");
|
|
|
outpatientDO.setCreateTime(new Date());
|
|
|
outpatientDO.setIdcard(patientDO.getIdcard());
|
|
|
outpatientDO.setOutpatientType("2");
|
|
|
outpatientDO.setCreateTime(new Date());
|
|
|
|
|
|
if(outpatientDO.getRegisterDate()==null){
|
|
|
outpatientDO.setRegisterDate(new Date());
|
|
|
}
|
|
|
|
|
|
WlyyOutpatientDO outpatient = outpatientDao.save(outpatientDO);
|
|
|
|
|
|
WlyyPatientRegisterTimeDO registerTimeDO = null;
|
|
|
|
|
|
try {
|
|
|
//如果是视频预约咨询
|
|
|
if(StringUtils.isNotBlank(registerJson)){
|
|
|
registerTimeDO = objectMapper.readValue(registerJson,WlyyPatientRegisterTimeDO.class);
|
|
|
registerTimeDO.setOutpatientId(outpatient.getId());
|
|
|
registerTimeDO.setCreateTime(new Date());
|
|
|
patientRegisterTimeDao.save(registerTimeDO);
|
|
|
}
|
|
|
}catch (Exception e){
|
|
|
throw new RuntimeException("号源已经被预约，请选择其他号源");
|
|
|
}
|
|
|
|
|
|
//3.创建候诊室
|
|
|
createRoom(outpatient,chargeType);
|
|
|
|
|
|
return outpatient;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 发送新增门诊信息
|
|
|
* @param outpatient
|
|
|
* @return
|
|
|
*/
|
|
|
public SystemMessageDO sendOutPatientMes(WlyyOutpatientDO outpatient){
|
|
|
SystemMessageDO systemMessageDO = new SystemMessageDO();
|
|
|
try{
|
|
|
//1.在线复诊2.协同门诊
|
|
|
if("2".equals(outpatient.getOutpatientType())){
|
|
|
systemMessageDO.setTitle("协同门诊");
|
|
|
systemMessageDO.setType("3");
|
|
|
}else{
|
|
|
//1.图文 2.视频
|
|
|
if("1".equals(outpatient.getType())){
|
|
|
systemMessageDO.setTitle("图文复诊");
|
|
|
systemMessageDO.setType("1");
|
|
|
}else {
|
|
|
systemMessageDO.setTitle("视频复诊");
|
|
|
systemMessageDO.setType("2");
|
|
|
}
|
|
|
}
|
|
|
systemMessageDO.setReceiver(outpatient.getDoctor());
|
|
|
systemMessageDO.setReceiverName(outpatient.getDoctorName());
|
|
|
systemMessageDO.setRelationCode(outpatient.getId());
|
|
|
systemMessageDO.setSender(outpatient.getPatient());
|
|
|
systemMessageDO.setSenderName(outpatient.getPatientName());
|
|
|
systemMessageDO.setRelationCode(outpatient.getId());
|
|
|
|
|
|
JSONObject data = new JSONObject();
|
|
|
data.put("name",outpatient.getPatientName());
|
|
|
data.put("age",IdCardUtil.getAgeForIdcard(outpatient.getIdcard()));
|
|
|
data.put("gender",IdCardUtil.getSexForIdcard_new(outpatient.getIdcard()));
|
|
|
data.put("question",outpatient.getDescription());
|
|
|
systemMessageDO.setData(data.toString());
|
|
|
|
|
|
systemMessageService.saveMessage(systemMessageDO);
|
|
|
|
|
|
}catch (Exception e){
|
|
|
logger.error("sendOutPatientMes :"+e.toString());
|
|
|
return null;
|
|
|
}
|
|
|
return systemMessageDO;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 指定门诊医生医生
|
|
|
* @param outpatientJson
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public WlyyOutpatientDO saveOutpatientDoctor(String outpatientJson,String registerJson,String chargeType)throws Exception{
|
|
|
|
|
|
//1.保存就诊实体
|
|
|
WlyyOutpatientDO outpatientDO = objectMapper.readValue(outpatientJson,WlyyOutpatientDO.class);
|
|
|
|
|
|
WlyyOutpatientDO one = outpatientDao.findOne(outpatientDO.getId());
|
|
|
if(StringUtils.isNotBlank(one.getDoctor())){
|
|
|
throw new RuntimeException("已有医生接诊");
|
|
|
}
|
|
|
one.setDoctor(outpatientDO.getDoctor());
|
|
|
one.setDoctorName(outpatientDO.getDoctorName());
|
|
|
one.setRegisterDate(outpatientDO.getRegisterDate());
|
|
|
one.setDept(outpatientDO.getDept());
|
|
|
one.setDeptName(outpatientDO.getDeptName());
|
|
|
one.setType(outpatientDO.getType());
|
|
|
WlyyOutpatientDO outpatient = outpatientDao.save(one);
|
|
|
|
|
|
WlyyPatientRegisterTimeDO registerTimeDO = null;
|
|
|
|
|
|
try {
|
|
|
//如果是视频预约咨询
|
|
|
if(StringUtils.isNotBlank(registerJson)){
|
|
|
//删除预约记录
|
|
|
List<WlyyPatientRegisterTimeDO> registerTimeDOs = patientRegisterTimeDao.findByOutpatientId(outpatientDO.getId());
|
|
|
if(registerTimeDOs!=null&®isterTimeDOs.size()>0){
|
|
|
patientRegisterTimeDao.delete(registerTimeDOs);
|
|
|
}
|
|
|
|
|
|
registerTimeDO = objectMapper.readValue(registerJson,WlyyPatientRegisterTimeDO.class);
|
|
|
registerTimeDO.setOutpatientId(outpatient.getId());
|
|
|
registerTimeDO.setCreateTime(new Date());
|
|
|
patientRegisterTimeDao.save(registerTimeDO);
|
|
|
}
|
|
|
}catch (Exception e){
|
|
|
throw new RuntimeException("号源已经被预约，请选择其他号源");
|
|
|
}
|
|
|
|
|
|
//更新候诊室
|
|
|
List<WlyyHospitalWaitingRoomDO> roomDOs = hospitalWaitingRoomDao.findByOutpatientId(outpatientDO.getId());
|
|
|
|
|
|
if(roomDOs!=null&&roomDOs.size()>0){
|
|
|
for(WlyyHospitalWaitingRoomDO room:roomDOs){
|
|
|
room.setDept(outpatientDO.getDept());
|
|
|
room.setDeptName(outpatientDO.getDeptName());
|
|
|
room.setDoctor(outpatientDO.getDoctor());
|
|
|
room.setDoctorName(outpatientDO.getDoctorName());
|
|
|
room.setChargeType(chargeType);
|
|
|
}
|
|
|
hospitalWaitingRoomDao.save(roomDOs);
|
|
|
}
|
|
|
|
|
|
return outpatient;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 验证电子健康卡授权
|
|
|
* @param authorizeNo
|
|
|
* @return
|
|
|
*/
|
|
|
public Map<String,Object> checkOauthQRCode(String authorizeNo){
|
|
|
|
|
|
Map<String,Object> rsMap = new HashedMap();
|
|
|
OauthYlzConfigDO oauthYlzConfigDO = oauthYlzConfigDao.findOne("ylz_config");
|
|
|
try {
|
|
|
TransRequest e = new TransRequest();
|
|
|
e.setMethod("ehc.ehealthcard.auth.query");
|
|
|
e.setApp_id(oauthYlzConfigDO.getAppId());
|
|
|
e.setTerm_id(oauthYlzConfigDO.getTermId());
|
|
|
e.setVersion(oauthYlzConfigDO.getVersion());
|
|
|
e.setTimestamp(DateUtil.dateToStr(new Date(),"yyyyMMddHHmmss"));
|
|
|
e.setSign_type(oauthYlzConfigDO.getSignType());
|
|
|
e.setEnc_type(oauthYlzConfigDO.getEncType());
|
|
|
com.alibaba.fastjson.JSONObject bizContent = new com.alibaba.fastjson.JSONObject();
|
|
|
bizContent.put("out_authorize_no", authorizeNo);
|
|
|
e.setBiz_content(JSON.toJSONString(bizContent));
|
|
|
|
|
|
EhcHandler ehcHandler = new EhcHandler(oauthYlzConfigDO.getUrl(), oauthYlzConfigDO.getAppId(), oauthYlzConfigDO.getTermId(), oauthYlzConfigDO.getAppKey());
|
|
|
TransResponse re = ehcHandler.execute(e);
|
|
|
String rs = com.alibaba.fastjson.JSONObject.toJSONString(re);
|
|
|
com.alibaba.fastjson.JSONObject json = (com.alibaba.fastjson.JSONObject) com.alibaba.fastjson.JSONObject.parse(rs);
|
|
|
logger.info("checkOauthQRCode:"+rs);
|
|
|
String ret_code = json.getString("ret_code");
|
|
|
if("0000".equals(ret_code)){
|
|
|
logger.info("biz_content: "+json.getString("biz_content"));
|
|
|
String strBiz = json.getString("biz_content");
|
|
|
com.alibaba.fastjson.JSONObject biz = (com.alibaba.fastjson.JSONObject) com.alibaba.fastjson.JSONObject.parse(strBiz);
|
|
|
// com.alibaba.fastjson.JSONObject biz = json.getJSONObject("biz_content");
|
|
|
String auth_status = biz.getString("auth_status");
|
|
|
if("succ".equals(auth_status)){
|
|
|
String idcard = biz.getString("id_no");
|
|
|
BasePatientDO patientDO = basePatientDao.findByIdcardAndDel(idcard,"1");
|
|
|
if(patientDO == null){
|
|
|
BasePatientDO patient = new BasePatientDO();
|
|
|
|
|
|
String salt = UUID.randomUUID().toString().substring(0,5);
|
|
|
String mobile = biz.getString("mobile_phone");
|
|
|
String pw = mobile.substring(mobile.length()-6);
|
|
|
|
|
|
patient.setIdcard(idcard);
|
|
|
patient.setName(biz.getString("user_name"));
|
|
|
patient.setPassword(MD5.md5Hex(pw + "{" + salt + "}"));
|
|
|
patient.setSalt(salt);
|
|
|
patient.setMobile(mobile);
|
|
|
patient.setDel("1");
|
|
|
patient.setEnabled(1);
|
|
|
patient.setLocked(0);
|
|
|
patient.setCreateTime(new Date());
|
|
|
patient.setUpdateTime(new Date());
|
|
|
patient.setBirthday(DateUtil.strToDate(biz.getString("birthday"),"yyyyMMdd"));
|
|
|
|
|
|
basePatientDao.save(patient);
|
|
|
rsMap.put("sCode",auth_status);
|
|
|
rsMap.put("sMes","success");
|
|
|
rsMap.put("patient",getPatientInfoMap(patient));
|
|
|
return rsMap;
|
|
|
}else{
|
|
|
rsMap.put("sCode",auth_status);
|
|
|
rsMap.put("sMes","success");
|
|
|
rsMap.put("patient",getPatientInfoMap(patientDO));
|
|
|
return rsMap;
|
|
|
}
|
|
|
}else if("ing".equals(auth_status)){
|
|
|
rsMap.put("sCode",auth_status);
|
|
|
rsMap.put("sMes","正在授权");
|
|
|
return rsMap;
|
|
|
}else if("fail".equals(auth_status)){
|
|
|
rsMap.put("sCode",auth_status);
|
|
|
rsMap.put("sMes","授权失败");
|
|
|
return rsMap;
|
|
|
}else if("cancel".equals(auth_status)){
|
|
|
rsMap.put("sCode",auth_status);
|
|
|
rsMap.put("sMes","取消授权");
|
|
|
return rsMap;
|
|
|
}
|
|
|
}
|
|
|
rsMap.put("sCode","err");
|
|
|
rsMap.put("sMes","请求失败");
|
|
|
return rsMap;
|
|
|
|
|
|
}catch (Exception e){
|
|
|
e.printStackTrace();
|
|
|
}
|
|
|
rsMap.put("sCode","err");
|
|
|
rsMap.put("sMes","请求失败");
|
|
|
return rsMap;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 查询协同门诊记录
|
|
|
* @param generalDoctor
|
|
|
* @param startDate
|
|
|
* @param endDate
|
|
|
* @param status
|
|
|
* @return
|
|
|
*/
|
|
|
public Envelop findByGeneralDoctor(String generalDoctor,String startDate,String endDate,String status,String sort,Integer page,Integer size){
|
|
|
|
|
|
String sqlTotal ="SELECT " +
|
|
|
" count(1) AS total "+
|
|
|
" FROM " +
|
|
|
" wlyy_outpatient o " +
|
|
|
" WHERE " +
|
|
|
" o.general_doctor = '"+generalDoctor+"'";
|
|
|
if(StringUtils.isNotBlank(startDate)){
|
|
|
sqlTotal += " AND o.register_date >='"+startDate+" 00:00:00' ";
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(endDate)){
|
|
|
sqlTotal += " AND o.register_date <='"+endDate+" 23:59:59' ";
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(status)){
|
|
|
sqlTotal += " AND o.status ='"+status+"'";
|
|
|
}
|
|
|
|
|
|
List<Map<String, Object>> rstotal = jdbcTemplate.queryForList(sqlTotal);
|
|
|
|
|
|
Long total = 0l;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
total = (Long) rstotal.get(0).get("total");
|
|
|
}
|
|
|
String sql ="SELECT " +
|
|
|
" o.id AS id, " +
|
|
|
" o.adm_no AS admNo, " +
|
|
|
" o.origin_adm_no AS originAdmNo, " +
|
|
|
" o.register_no AS registerNo, " +
|
|
|
" o.origin_register_no AS originRegisterNo, " +
|
|
|
" o.origin_con_no AS originConNo, " +
|
|
|
" o.con_no AS conNo, " +
|
|
|
" o.outpatient_type AS outpatientType, " +
|
|
|
" o.type AS type, " +
|
|
|
" o.hospital AS hospital, " +
|
|
|
" o.hospital_name AS hospitalName, " +
|
|
|
" o.win_no AS winNo, " +
|
|
|
" o.dept AS dept, " +
|
|
|
" o.dept_name AS deptName, " +
|
|
|
" o.patient AS patient, " +
|
|
|
" o.patient_name AS patientName, " +
|
|
|
" o.doctor AS doctor, " +
|
|
|
" o.doctor_name AS doctorName, " +
|
|
|
" o.general_doctor AS generalDoctor, " +
|
|
|
" o.general_doctor_name AS generalDoctorName, " +
|
|
|
" o.idcard AS idcard, " +
|
|
|
" o.card_no AS cardNo, " +
|
|
|
" o.mjz AS mjz, " +
|
|
|
" o.icd10 AS icd10, "+
|
|
|
" o.icd10_name AS icd10Name, " +
|
|
|
" o.advice AS advice, " +
|
|
|
" o.adm_date AS admDate, " +
|
|
|
" o.description AS description, " +
|
|
|
" o.disease_img AS diseaseImg, " +
|
|
|
" o.create_time AS createTime, " +
|
|
|
" o.con_date AS conDate, " +
|
|
|
" o.patient_cancel_type AS patientCancelType, " +
|
|
|
" o.patient_cancel_value AS patientCancelValue, " +
|
|
|
" o.patient_cancel_remark AS patientCancelRemark, " +
|
|
|
" o.register_date AS registerDate, " +
|
|
|
" o.`status` AS STATUS, " +
|
|
|
" o.evaluate_status AS evaluateStatus " +
|
|
|
" FROM " +
|
|
|
" wlyy_outpatient o " +
|
|
|
" WHERE " +
|
|
|
" o.general_doctor = '"+generalDoctor+"'";
|
|
|
if(StringUtils.isNotBlank(startDate)){
|
|
|
sql+=" AND o.register_date >='"+startDate+" 00:00:00'";
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(endDate)){
|
|
|
sql+=" AND o.register_date <='"+endDate+" 23:59:59'";
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(status)){
|
|
|
sql+=" AND o.status ='"+status+"'";
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(sort)){
|
|
|
sql += " ORDER BY o.register_date "+sort+" LIMIT " + (page - 1) * size + "," + size + "";
|
|
|
}else{
|
|
|
sql += " ORDER BY o.register_date ASC LIMIT " + (page - 1) * size + "," + size + "";
|
|
|
}
|
|
|
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
//List<WlyyOutpatientDO> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper(WlyyOutpatientDO.class));
|
|
|
return MixEnvelop.getSuccessListWithPage(BaseHospitalRequestMapping.Prescription.api_success, list, page, size, total);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 全科医生首页协同门诊统计列表.
|
|
|
* @param generalDoctor
|
|
|
* @return
|
|
|
*/
|
|
|
public Map<String,Object> findGeneralDoctorInfo(String generalDoctor){
|
|
|
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
Date startTime = DateUtil.strToDate(DateUtil.dateToStr(new Date(),"yyyy-MM-dd")+" 00:00:00","yyyy-MM-dd HH:mm:ss");
|
|
|
Date endTime = DateUtil.strToDate(DateUtil.dateToStr(new Date(),"yyyy-MM-dd")+" 23:59:59","yyyy-MM-dd HH:mm:ss");
|
|
|
|
|
|
//今天协同门诊列表
|
|
|
List<WlyyOutpatientDO> todayList = outpatientDao.findByGeneralDoctor(generalDoctor,startTime,endTime,"0");
|
|
|
|
|
|
rs.put("todayList",todayList);
|
|
|
|
|
|
List<WlyyOutpatientDO> todayBeginList = outpatientDao.findByGeneralDoctor(generalDoctor,startTime,endTime,"1");
|
|
|
|
|
|
rs.put("todayBeginList",todayBeginList);
|
|
|
|
|
|
Calendar tomorrowTime = Calendar.getInstance();
|
|
|
tomorrowTime.setTime(startTime);
|
|
|
tomorrowTime.add(Calendar.DATE,1);
|
|
|
|
|
|
Calendar tomorrowEndtime = Calendar.getInstance();
|
|
|
tomorrowEndtime.setTime(endTime);
|
|
|
tomorrowEndtime.add(Calendar.DATE,1);
|
|
|
//明天协同门诊列表
|
|
|
List<WlyyOutpatientDO> tomorrowList = outpatientDao.findByGeneralDoctor(generalDoctor,tomorrowTime.getTime(),tomorrowEndtime.getTime(),"0");
|
|
|
rs.put("tomorrowList",tomorrowList);
|
|
|
|
|
|
//统计科预约医生
|
|
|
String sql = "SELECT " +
|
|
|
" COUNT(1) AS total " +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_role r ON d.id = r.doctor_code " +
|
|
|
" WHERE " +
|
|
|
" r.role_code ='specialist'" +
|
|
|
" AND d.charge_type is not null " +
|
|
|
" AND d.outpatient_type like '%xt%' ";
|
|
|
List<Map<String, Object>> rstotal = jdbcTemplate.queryForList(sql);
|
|
|
|
|
|
Long doctorTotal = 0l;
|
|
|
if (rstotal != null && rstotal.size() > 0) {
|
|
|
doctorTotal = (Long) rstotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
rs.put("doctorTotal",doctorTotal);
|
|
|
|
|
|
//统计在线医生
|
|
|
String onlineSql="SELECT " +
|
|
|
" COUNT(1) AS total " +
|
|
|
" FROM " +
|
|
|
" base_doctor d " +
|
|
|
" JOIN base_doctor_role r ON d.id = r.doctor_code " +
|
|
|
" WHERE " +
|
|
|
" r.role_code ='specialist' " +
|
|
|
" AND d.consult_status ='1' " +
|
|
|
" AND d.charge_type is not null " +
|
|
|
" AND d.outpatient_type like '%xt%' ";
|
|
|
List<Map<String, Object>> oltotal = jdbcTemplate.queryForList(onlineSql);
|
|
|
|
|
|
Long onlineTotal = 0l;
|
|
|
if (oltotal != null && oltotal.size() > 0) {
|
|
|
onlineTotal = (Long) oltotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
rs.put("onlineTotal",onlineTotal);
|
|
|
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 查询医生所有可抢单的数量
|
|
|
* @param doctor
|
|
|
* @param dept
|
|
|
* @return
|
|
|
*/
|
|
|
public com.alibaba.fastjson.JSONObject findWaitingRoomOutpatientNumberByDoctor(String doctor,String dept) {
|
|
|
|
|
|
com.alibaba.fastjson.JSONObject object = new com.alibaba.fastjson.JSONObject();
|
|
|
|
|
|
|
|
|
//总数
|
|
|
String sqlAll = "SELECT " +
|
|
|
" COUNT(room.outpatient_id) AS total " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"wlyy_outpatient outpatient " +
|
|
|
"WHERE " +
|
|
|
" room.outpatient_id=outpatient.id " +
|
|
|
"AND outpatient.status = 0 AND room.doctor IS NULL AND outpatient.dept='"+dept+"' ";
|
|
|
|
|
|
List<Map<String, Object>> alltotal = jdbcTemplate.queryForList(sqlAll);
|
|
|
|
|
|
Long totalsqlAll = 0l;
|
|
|
if (alltotal != null && alltotal.size() > 0) {
|
|
|
totalsqlAll = (Long) alltotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
object.put("all",totalsqlAll);
|
|
|
|
|
|
//图文复诊
|
|
|
String imgAll = "SELECT " +
|
|
|
" COUNT(room.outpatient_id) AS total " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"wlyy_outpatient outpatient " +
|
|
|
"WHERE " +
|
|
|
" room.outpatient_id=outpatient.id " +
|
|
|
"AND outpatient.status = 0 AND room.doctor IS NULL AND room.reservation_type=1 AND room.consult_type=1 AND outpatient.dept='"+dept+"' ";
|
|
|
|
|
|
List<Map<String, Object>> imgtotal = jdbcTemplate.queryForList(imgAll);
|
|
|
|
|
|
Long twCount = 0l;
|
|
|
if (imgtotal != null && imgtotal.size() > 0) {
|
|
|
twCount = (Long) imgtotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
object.put("twCount",twCount);
|
|
|
|
|
|
//视频复诊
|
|
|
String spsql = "SELECT " +
|
|
|
" COUNT(room.outpatient_id) AS total " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"wlyy_outpatient outpatient " +
|
|
|
"WHERE " +
|
|
|
" room.outpatient_id=outpatient.id " +
|
|
|
"AND outpatient.status = 0 AND room.doctor IS NULL AND room.reservation_type=1 AND room.consult_type=2 AND outpatient.dept='"+dept+"' ";
|
|
|
|
|
|
List<Map<String, Object>> sptotal = jdbcTemplate.queryForList(spsql);
|
|
|
|
|
|
Long spcount = 0l;
|
|
|
if (sptotal != null && sptotal.size() > 0) {
|
|
|
spcount = (Long) sptotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
object.put("spCount",spcount);
|
|
|
|
|
|
|
|
|
//协同门诊
|
|
|
String xtsql = "SELECT " +
|
|
|
" COUNT(room.outpatient_id) AS total " +
|
|
|
"FROM " +
|
|
|
"wlyy_hospital_waiting_room room," +
|
|
|
"wlyy_outpatient outpatient " +
|
|
|
"WHERE " +
|
|
|
" room.outpatient_id=outpatient.id " +
|
|
|
"AND outpatient.status = 0 AND room.doctor IS NULL AND room.reservation_type=2 AND outpatient.dept='"+dept+"' ";
|
|
|
|
|
|
List<Map<String, Object>> xttotal = jdbcTemplate.queryForList(xtsql);
|
|
|
|
|
|
Long xtcount = 0l;
|
|
|
if (xttotal != null && xttotal.size() > 0) {
|
|
|
xtcount = (Long) xttotal.get(0).get("total");
|
|
|
}
|
|
|
|
|
|
object.put("xtCount",xtcount);
|
|
|
|
|
|
|
|
|
return object;
|
|
|
}
|
|
|
|
|
|
public Map<String,Object> refuseOutpatientByDoctor(String outPatientId, String cancelType, String cancelValue, String cancelRemark) {
|
|
|
Map<String,Object> rs = new HashedMap();
|
|
|
//判断医生是否接诊
|
|
|
List<WlyyHospitalWaitingRoomDO> roomDOs =hospitalWaitingRoomDao.findByOutpatientId(outPatientId);
|
|
|
if(roomDOs!=null&&roomDOs.size()>0){
|
|
|
for(WlyyHospitalWaitingRoomDO roomDO:roomDOs){
|
|
|
if(roomDO.getVisitStatus()==2){
|
|
|
rs.put("code",-1);
|
|
|
rs.put("mes","医生已经接诊，无法取消");
|
|
|
return rs;
|
|
|
}else{
|
|
|
roomDO.setVisitStatus(-1);
|
|
|
hospitalWaitingRoomDao.save(roomDO);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//更改门诊状态
|
|
|
WlyyOutpatientDO wlyyOutpatientDO = outpatientDao.findOne(outPatientId);
|
|
|
wlyyOutpatientDO.setStatus("-1");
|
|
|
wlyyOutpatientDO.setDoctorCancelRemark(cancelRemark);
|
|
|
wlyyOutpatientDO.setDoctorCancelType(cancelType);
|
|
|
wlyyOutpatientDO.setDoctorCancelValue(cancelValue);
|
|
|
outpatientDao.save(wlyyOutpatientDO);
|
|
|
|
|
|
//删除门诊号源
|
|
|
List<WlyyPatientRegisterTimeDO> list = patientRegisterTimeDao.findByOutpatientId(wlyyOutpatientDO.getId());
|
|
|
if(list!=null&&list.size()>0){
|
|
|
patientRegisterTimeDao.delete(list);
|
|
|
}
|
|
|
|
|
|
rs.put("code",1);
|
|
|
rs.put("mes","取消成功");
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取居民当日就诊列表
|
|
|
* @param patient
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> getTodayOutpatinetList(String patient) {
|
|
|
String sql ="SELECT date_format(p.register_date ,'%Y-%m-%d %H:%i:%S' ) AS time,d.NAME as doctorName,d.job_title_name,d.photo AS photo,p.id as outpatientid FROM wlyy_outpatient p,base_doctor d " +
|
|
|
"WHERE p.patient='"+patient+"' AND p.doctor=d.id AND p.status=0 AND p.register_date BETWEEN '"+DateUtil.dateToStrShort(new Date())+" 00:00:00' AND '"+DateUtil.dateToStrShort(new Date())+" 23:59:59'";
|
|
|
List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取doctormappingcode
|
|
|
* @param doctor
|
|
|
* @param orgCode
|
|
|
* @return
|
|
|
*/
|
|
|
public DoctorMappingDO getDoctorMapping(String doctor,String orgCode){
|
|
|
return doctorMappingService.findMappingCode(doctor,orgCode);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取医生简介
|
|
|
* @param doctorCode
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public net.sf.json.JSON getDoctorIntroduction(String doctorCode) throws Exception {
|
|
|
DoctorMappingDO doctorMappingDO = doctorMappingService.findMappingCode(doctorCode,"350211A1002");
|
|
|
if(doctorMappingDO==null){
|
|
|
throw new RuntimeException("未找到医生映射信息");
|
|
|
}
|
|
|
return entranceService.BS16010(doctorMappingDO.getMappingCode(),demoFlag);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
*
|
|
|
* @param name
|
|
|
* @param hospital
|
|
|
* @return
|
|
|
*/
|
|
|
public List<WlyyHospitalSysDictDO> findByDict(String name,String hospital){
|
|
|
return sysDictDao.findByHospitalAndDictNameOrderBySortAsc(hospital,name);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 建立档案
|
|
|
* @param json
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONObject setRecord(String json,String type)throws Exception{
|
|
|
JSONObject rs = new JSONObject();
|
|
|
ArchiveVO archiveVO = objectMapper.readValue(json,ArchiveVO.class);
|
|
|
if(archiveVO!=null){
|
|
|
if(StringUtils.isBlank(archiveVO.getBrnl00())){
|
|
|
archiveVO.setBrnl00(IdCardUtil.getAgeForIdcard(archiveVO.getSfzhao())+"");
|
|
|
}
|
|
|
if(StringUtils.isBlank(archiveVO.getCsrq00())){
|
|
|
archiveVO.setCsrq00(DateUtil.dateToStr(IdCardUtil.getBirthdayForIdcard(archiveVO.getSfzhao()),"yyyyMMdd"));
|
|
|
}
|
|
|
//1为需要同步建档
|
|
|
if("1".equals(type)){
|
|
|
rs = entranceService.BS16018(archiveVO,demoFlag);
|
|
|
}
|
|
|
//保存互联网医院居民账户
|
|
|
BasePatientDO patientDO = savePatient(archiveVO);
|
|
|
rs.put("patient",patientDO.getId());
|
|
|
}
|
|
|
return rs;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 存储居民
|
|
|
* @param archiveVO
|
|
|
* @return
|
|
|
*/
|
|
|
public BasePatientDO savePatient(ArchiveVO archiveVO)throws Exception{
|
|
|
BasePatientDO patientDO = basePatientDao.findByIdcardAndDel(archiveVO.getSfzhao(),"1");
|
|
|
if(patientDO == null) {
|
|
|
BasePatientDO patient = new BasePatientDO();
|
|
|
|
|
|
String salt = UUID.randomUUID().toString().substring(0, 5);
|
|
|
String mobile = archiveVO.getYytel0();
|
|
|
String pw = mobile.substring(mobile.length() - 6);
|
|
|
|
|
|
patient.setIdcard(archiveVO.getSfzhao());
|
|
|
patient.setName(archiveVO.getXming0());
|
|
|
patient.setPassword(MD5.md5Hex(pw + "{" + salt + "}"));
|
|
|
patient.setSalt(salt);
|
|
|
patient.setMobile(mobile);
|
|
|
patient.setDel("1");
|
|
|
patient.setEnabled(1);
|
|
|
patient.setLocked(0);
|
|
|
patient.setCreateTime(new Date());
|
|
|
patient.setUpdateTime(new Date());
|
|
|
patient.setBirthday(IdCardUtil.getBirthdayForIdcard(archiveVO.getSfzhao()));
|
|
|
|
|
|
return basePatientDao.save(patient);
|
|
|
}
|
|
|
return patientDO;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取HIIS居民档案信息
|
|
|
* @param idcard
|
|
|
* @param patient
|
|
|
* @param admitNum
|
|
|
* @return
|
|
|
* @throws Exception
|
|
|
*/
|
|
|
public JSONArray findPatientRecord(String idcard,String patient,String admitNum,String ybcard)throws Exception{
|
|
|
String patientId = null;
|
|
|
if(StringUtils.isNotBlank(patient)){
|
|
|
patientId = patientMappingService.findHisPatNoByPatient(patient);
|
|
|
}
|
|
|
return entranceService.BS10008(idcard,patientId,admitNum,ybcard,demoFlag);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 获取医生信息
|
|
|
* @param hospital
|
|
|
* @param name
|
|
|
* @return
|
|
|
*/
|
|
|
public List<Map<String,Object>> findDoctorByName(String hospital, String name,String chargeType){
|
|
|
String sql ="SELECT " +
|
|
|
" d.id AS \"id\", " +
|
|
|
" d.`name` AS \"name\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor d ";
|
|
|
if(StringUtils.isNotBlank(hospital)){
|
|
|
sql +=" JOIN base_doctor_hospital h ON h.doctor_code = d.id";
|
|
|
}
|
|
|
sql +=" JOIN base_doctor_role r ON r.doctor_code = d.id ";
|
|
|
sql +=" WHERE " +
|
|
|
" d. NAME LIKE '%"+name+"%'";
|
|
|
if(StringUtils.isNotBlank(hospital)){
|
|
|
sql +=" AND h.org_code ='"+hospital+"'";
|
|
|
}
|
|
|
|
|
|
if(StringUtils.isNotBlank(chargeType)){
|
|
|
if("all".equals(chargeType)){
|
|
|
//查询全部号源
|
|
|
}else{
|
|
|
sql+=" AND d.charge_type ='"+chargeType+"'";
|
|
|
}
|
|
|
}else{
|
|
|
sql+=" AND d.charge_type is not null ";
|
|
|
}
|
|
|
|
|
|
sql += " AND r.role_code ='specialist'";
|
|
|
|
|
|
logger.info("findDoctorByName :"+sql);
|
|
|
|
|
|
List<Map<String,Object>> list = hibenateUtils.createSQLQuery(sql);
|
|
|
if(list!=null&&list.size()>0){
|
|
|
for(int i=0;i<list.size();i++){
|
|
|
Map<String,Object> d = list.get(i);
|
|
|
List<BaseDoctorHospitalDO> depts = baseDoctorHospitalDao.findByDoctorCode(d.get("id").toString());
|
|
|
d.put("depts",depts);
|
|
|
}
|
|
|
}
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
public void followOrgByPatient(String patientid, String doctorid, String type) {
|
|
|
List<BaseDoctorPatientFollowDO> list =baseOrgPatientDao.findByDoctorAndPatient(patientid,doctorid);
|
|
|
if("1".equals(type)){//关注
|
|
|
if(list.isEmpty()){
|
|
|
BaseDoctorPatientFollowDO baseOrgPatientFollowDO = new BaseDoctorPatientFollowDO();
|
|
|
baseOrgPatientFollowDO.setDoctor(doctorid);
|
|
|
baseOrgPatientFollowDO.setPatient(patientid);
|
|
|
baseOrgPatientDao.save(baseOrgPatientFollowDO);
|
|
|
}
|
|
|
}else if("0".equals(type)){//取消关注
|
|
|
if(!list.isEmpty()){
|
|
|
for (BaseDoctorPatientFollowDO baseOrgPatientFollowDO:list){
|
|
|
baseOrgPatientDao.delete(baseOrgPatientFollowDO.getId());
|
|
|
}
|
|
|
}
|
|
|
}else{}
|
|
|
}
|
|
|
|
|
|
public List<Map<String,Object>> findDeptByKeyWord(String keyWord,Integer page,Integer pagesize) {
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
"dept.code AS \"deptCode\"," +
|
|
|
"dept.name AS \"deptName\"," +
|
|
|
"org.CODE AS \"orgCode\", " +
|
|
|
"org.NAME AS \"orgName\" " +
|
|
|
"FROM " +
|
|
|
"dict_hospital_dept dept," +
|
|
|
"base_org org " +
|
|
|
"WHERE org.CODE=dept.org_code " +
|
|
|
"AND org.del=1 ";
|
|
|
|
|
|
if(StringUtils.isNoneBlank(keyWord)){
|
|
|
sql = sql + "AND dept.NAME LIKE '%"+keyWord+"%' ";
|
|
|
}
|
|
|
List<Map<String,Object>> list = hibenateUtils.createSQLQuery(sql,page,pagesize);
|
|
|
logger.info("sql:"+sql);
|
|
|
return list;
|
|
|
}
|
|
|
|
|
|
public List<Map<String,Object>> findDeptWithDoctorWorkTime(String hospital,String keyWord,Integer page,Integer pagesize ){
|
|
|
|
|
|
String now = DateUtil.dateToStr(new Date(),"yyyy-MM-dd");
|
|
|
// Date startDate = DateUtil.stringToDate(now+" 00:00:00","yyyy-MM-dd HH:mm:ss");
|
|
|
// Date endDate = DateUtil.stringToDate(now+" 23:59:59","yyyy-MM-dd HH:mm:ss");
|
|
|
|
|
|
String sql ="SELECT " +
|
|
|
" DISTINCT " +
|
|
|
" h.dept_code AS \"deptCode\", " +
|
|
|
" h.dept_name AS \"deptName\"," +
|
|
|
" h.org_code AS \"orgCode\"," +
|
|
|
" h.org_name AS \"orgName\"" +
|
|
|
" FROM " +
|
|
|
" base_doctor_hospital h " +
|
|
|
" JOIN base_doctor d ON h.doctor_code = d.id" +
|
|
|
" WHERE " +
|
|
|
" ( EXISTS ( " +
|
|
|
" SELECT " +
|
|
|
" w.doctor " +
|
|
|
" FROM " +
|
|
|
" wlyy_doctor_work_time w " +
|
|
|
" WHERE " +
|
|
|
" w.doctor = h.doctor_code " +
|
|
|
" AND start_time <=:startTime " +
|
|
|
" AND end_time >=:endDate " +
|
|
|
" ) OR d.consult_status ='1') " +
|
|
|
" AND h.dept_code IS NOT NULL " +
|
|
|
" AND h.dept_code !=''";
|
|
|
Map<String,Object> params = new HashedMap();
|
|
|
params.put("startTime",new Date());
|
|
|
params.put("endDate",new Date());
|
|
|
if(StringUtils.isNotBlank(hospital)){
|
|
|
sql +=" AND h.org_code =:hospital";
|
|
|
params.put("hospital",hospital);
|
|
|
}
|
|
|
if(StringUtils.isNotBlank(keyWord)){
|
|
|
sql +=" AND h.dept_name like:keyWord";
|
|
|
params.put("keyWord","%"+keyWord+"%");
|
|
|
}
|
|
|
logger.info(sql);
|
|
|
return hibenateUtils.createSQLQuery(sql,params,page,pagesize);
|
|
|
}
|
|
|
}
|
humingfen