业务对接接口

data-service/pom.xml

@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>emrais</artifactId>
+        <groupId>com.lantone</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>data-service</artifactId>
+    <name>data-service</name>
+    <packaging>jar</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.lantone</groupId>
+            <artifactId>common</artifactId>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.springframework.boot</groupId>
+                    <artifactId>spring-boot-starter-data-redis</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-oauth2</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.nimbusds</groupId>
+            <artifactId>nimbus-jose-jwt</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-openfeign</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.github.openfeign</groupId>
+            <artifactId>feign-okhttp</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>com.spotify</groupId>
+                <artifactId>docker-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>

data-service/src/main/java/com/lantone/DataServiceApplication.java

@@ -0,0 +1,18 @@
+package com.lantone;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
+import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+
+@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
+@EnableEurekaClient
+@EnableFeignClients
+public class DataServiceApplication{
+
+    public static void main(String[] args) {
+        SpringApplication.run(DataServiceApplication.class, args);
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/ColumnFacade.java

@@ -0,0 +1,251 @@
+package com.lantone.data.facade;
+
+import com.alibaba.fastjson.JSON;
+import com.diagbot.dto.OutputInfo;
+import com.diagbot.dto.Response;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.ModeIdEnum;
+import com.diagbot.facade.QcClientFacade;
+import com.diagbot.facade.str.*;
+import com.diagbot.service.impl.ColumnServiceImpl;
+import com.diagbot.vo.QueryVo;
+import com.diagbot.vo.str.StrContentVO;
+import com.lantone.data.facade.data.MedAbnormalInfoFacade;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+@Component
+public class ColumnFacade extends ColumnServiceImpl {
+    @Autowired
+    private QcClientFacade qcClientFacade;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+
+    /**
+     * 解析
+     * @param queryVo
+     */
+    public void analyseRec(QueryVo queryVo) {
+        try {
+            Response<OutputInfo> resp=qcClientFacade.analyseField(queryVo);
+            if(resp.getData()!=null && resp.getData().getPageData()!=null){
+                Map<String, Object> pageData=resp.getData().getPageData();
+                pageData.forEach((key,value)->{
+                    List<Map<String, Object>> listMap=(List<Map<String,Object>>)resp.getData().getPageData().get(key);
+                    Map<String, String> columnMap=this.getColumn(CacheKeyEnum.getName(key));
+
+                    Map<String, Object> entityMap=new HashMap<String, Object>();
+                    listMap.forEach(s->{
+                        columnMap.forEach((k, v) -> {
+                            entityMap.put(v,s.get(k));
+                        });
+                        //数据解析
+                        analysisData(key,entityMap,Long.valueOf(queryVo.getHospitalId()),JSON.toJSONString(s));
+                    });
+                });
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("数据解析","", JSON.toJSONString(queryVo),"",e.getMessage());
+        }
+
+    }
+
+    /**
+     * @Description:解析his传输过来的wholeData
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void analyseWholeData(StrContentVO strContentVO) throws Exception{
+        //调用解析接口
+        Response<OutputInfo> resp=null;
+        //qcClientFacade.analyseField(queryVo);
+        if(resp.getData()!=null && resp.getData().getPageData()!=null){
+            Map<String, Object> pageData=resp.getData().getPageData();
+            pageData.forEach((key,value)->{
+                List<Map<String, Object>> listMap=(List<Map<String,Object>>)resp.getData().getPageData().get(key);
+                Map<String, String> columnMap=this.getColumn(CacheKeyEnum.getName(key));
+
+                Map<String, Object> entityMap=new HashMap<String, Object>();
+                listMap.forEach(s->{
+                    columnMap.forEach((k, v) -> {
+                        entityMap.put(v,s.get(k));
+                    });
+                    //数据解析
+                    analysisData(ModeIdEnum.getName(Integer.parseInt(strContentVO.getModelId())),entityMap,strContentVO.getHospitalId(),JSON.toJSONString(s));
+                });
+            });
+        }
+    }
+
+    /**
+     * @Description: 不解析时，先入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void addWholeData(StrContentVO strContentVO){
+        String modelName=ModeIdEnum.getName(Integer.parseInt(strContentVO.getModelId()));
+        if("入院记录".equals(modelName)){
+            bStrAdmissionNoteFacade.dealData(strContentVO);
+        }else if("首次病程录".equals(modelName)){
+            bStrFirstRecordFacade.dealData(strContentVO);
+        }else if("输血后效果评价".equals(modelName)){
+            bStrBloodResultFacade.dealData(strContentVO);
+        }else if("输血/血制品病程记录".equals(modelName)){
+            bStrBloodTransfusionFacade.dealData(strContentVO);
+        }else if("转入记录".equals(modelName)){
+            bStrTransferInNoteFacade.dealData(strContentVO);
+        }else if("转出记录".equals(modelName)){
+            bStrTransferOutNoteFacade.dealData(strContentVO);
+        }else if("病危通知书".equals(modelName)){
+            bStrIllCriticallyFacade.dealData(strContentVO);
+        }else if("病重通知书".equals(modelName)){
+            bStrIllSeriouslFacade.dealData(strContentVO);
+        }else if("疑难病例讨论记录".equals(modelName)){
+            bStrDifficultCaseFacade.dealData(strContentVO);
+        }else if("死亡记录".equals(modelName)){
+            bStrDeathNoteFacade.dealData(strContentVO);
+        }else if("死亡病例讨论记录".equals(modelName)){
+            bStrDeathDiscussionFacade.dealData(strContentVO);
+        }else if("查房记录".equals(modelName)){
+            bStrWardRecordFacade.dealData(strContentVO);
+        }else if("术后首次病程及谈话记录".equals(modelName)){
+            bStrOperativeFirstRecordFacade.dealData(strContentVO);
+        }else if("术前讨论、术前小结".equals(modelName)){
+            bStrPreoperativeDiscussionFacade.dealData(strContentVO);
+        }else if("手术记录".equals(modelName)){
+            bStrOperativeNoteFacade.dealData(strContentVO);
+        }else if("抢救记录".equals(modelName)){
+            bStrRescueNoteFacade.dealData(strContentVO);
+        }else if("危急值记录".equals(modelName)){
+            bStrCrisisNoteFacade.dealData(strContentVO);
+        }else if("出院小结".equals(modelName)){
+            bStrLeaveHospitalFacade.dealData(strContentVO);
+        }else if("会诊申请单".equals(modelName)){
+            bStrConsultationApplyFacade.dealData(strContentVO);
+        }else if("会诊结果单".equals(modelName)){
+            bStrConsultationResultFacade.dealData(strContentVO);
+        }else if("会诊单".equals(modelName)){
+            bStrConsultationNoteFacade.dealData(strContentVO);
+        }else if ("会诊记录".equals(modelName)){
+            bStrConsultationRecordFacade.dealData(strContentVO);
+        } else if("阶段小结".equals(modelName)){
+            bStrPeriodConclusionFacade.dealData(strContentVO);
+        }
+    }
+
+    /**
+     * 数据解析
+     * @param modelName
+     * @param entityMap
+     * @param hospitalId
+     */
+    private void analysisData(String modelName,Map<String, Object> entityMap,Long hospitalId,String columnMap){
+        try{
+            if("入院记录".equals(modelName)){
+                bStrAdmissionNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("首次病程录".equals(modelName)){
+                bStrFirstRecordFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("输血后效果评价".equals(modelName)){
+                bStrBloodResultFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("输血/血制品病程记录".equals(modelName)){
+                bStrBloodTransfusionFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("转入记录".equals(modelName)){
+                bStrTransferInNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("转出记录".equals(modelName)){
+                bStrTransferOutNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("病危通知书".equals(modelName)){
+                bStrIllCriticallyFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("病重通知书".equals(modelName)){
+                bStrIllSeriouslFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("疑难病例讨论记录".equals(modelName)){
+                bStrDifficultCaseFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("死亡记录".equals(modelName)){
+                bStrDeathNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("死亡病例讨论记录".equals(modelName)){
+                bStrDeathDiscussionFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("查房记录".equals(modelName)){
+                bStrWardRecordFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("术后首次病程及谈话记录".equals(modelName)){
+                bStrOperativeFirstRecordFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("术前讨论、术前小结".equals(modelName)){
+                bStrPreoperativeDiscussionFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("手术记录".equals(modelName)){
+                bStrOperativeNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("抢救记录".equals(modelName)){
+                bStrRescueNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("危急值记录".equals(modelName)){
+                bStrCrisisNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("出院小结".equals(modelName)){
+                bStrLeaveHospitalFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("会诊申请单".equals(modelName)){
+                bStrConsultationApplyFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("会诊结果单".equals(modelName)){
+                bStrConsultationResultFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if("会诊单".equals(modelName)){
+                bStrConsultationNoteFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }else if ("会诊记录".equals(modelName)){
+                bStrConsultationRecordFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            } else if("阶段小结".equals(modelName)){
+                bStrPeriodConclusionFacade.dealData(columnMap,entityMap,Long.valueOf(hospitalId));
+            }
+            log.info(modelName+"---- 解析完成！");
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("数据解析异常", "",JSON.toJSONString(columnMap),"",e.getMessage());
+        }
+    }
+
+    @Autowired
+    private BStrAdmissionNoteFacade bStrAdmissionNoteFacade;
+    @Autowired
+    private BStrFirstRecordFacade bStrFirstRecordFacade;
+    @Autowired
+    private BStrPeriodConclusionFacade bStrPeriodConclusionFacade;
+    @Autowired
+    private BStrBloodResultFacade bStrBloodResultFacade;
+    @Autowired
+    private BStrBloodTransfusionFacade bStrBloodTransfusionFacade;
+    @Autowired
+    private BStrTransferInNoteFacade bStrTransferInNoteFacade;
+    @Autowired
+    private BStrTransferOutNoteFacade bStrTransferOutNoteFacade;
+    @Autowired
+    private BStrIllSeriouslFacade bStrIllSeriouslFacade;
+    @Autowired
+    private BStrIllCriticallyFacade bStrIllCriticallyFacade;
+    @Autowired
+    private BStrDifficultCaseFacade bStrDifficultCaseFacade;
+    @Autowired
+    private BStrDeathNoteFacade bStrDeathNoteFacade;
+    @Autowired
+    private BStrDeathDiscussionFacade bStrDeathDiscussionFacade;
+    @Autowired
+    private BStrWardRecordFacade bStrWardRecordFacade;
+    @Autowired
+    private BStrOperativeFirstRecordFacade bStrOperativeFirstRecordFacade;
+    @Autowired
+    private BStrPreoperativeDiscussionFacade bStrPreoperativeDiscussionFacade;
+    @Autowired
+    private BStrOperativeNoteFacade bStrOperativeNoteFacade;
+    @Autowired
+    private BStrRescueNoteFacade bStrRescueNoteFacade;
+    @Autowired
+    private BStrCrisisNoteFacade bStrCrisisNoteFacade;
+    @Autowired
+    private BStrLeaveHospitalFacade bStrLeaveHospitalFacade;
+    @Autowired
+    private BStrConsultationApplyFacade bStrConsultationApplyFacade;
+    @Autowired
+    private BStrConsultationResultFacade bStrConsultationResultFacade;
+    @Autowired
+    private BStrConsultationNoteFacade bStrConsultationNoteFacade;
+    @Autowired
+    private BStrConsultationRecordFacade bStrConsultationRecordFacade;
+}

data-service/src/main/java/com/lantone/data/facade/DataFacade.java

@@ -0,0 +1,4 @@
+package com.lantone.data.facade;
+
+public class DataFacade {
+}

data-service/src/main/java/com/lantone/data/facade/data/BasDeptInfoFacade.java

@@ -0,0 +1,113 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ABasDeptInfoDTO;
+import com.diagbot.entity.BasDeptInfo;
+import com.diagbot.service.impl.BasDeptInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ABasDeptInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class BasDeptInfoFacade extends BasDeptInfoServiceImpl{
+
+    @Autowired
+    @Qualifier("basDeptInfoServiceImpl")
+    private BasDeptInfoServiceImpl basDeptInfoService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 同步前一天科室的信息
+     */
+    public void executeDept() {
+        String sql="select * from hi_deptinfo where cjcxrq>=dateadd(day,-2,getdate()) and cjcxrq<=getdate()";
+        List<BasDeptInfo> basDeptInfoList = tzDBConn.getDeptInfo(sql);
+        execute(basDeptInfoList);
+    }
+
+    /**
+     * 同步历史数据
+     */
+    public void executeDeptPast(){
+        String sql="select * from hi_deptinfo where cjcxrq>=dateadd(day,-1,getdate()) and cjcxrq<=getdate()";
+        List<BasDeptInfo> basDeptInfoList = tzDBConn.getDeptInfo(sql);
+        execute(basDeptInfoList);
+    }
+
+    /**
+     * 通过接口同步数据
+     * @param list
+     * @return
+     */
+    public RespDTO<List<ABasDeptInfoDTO>> executeDept(List<ABasDeptInfoVO> list) {
+        try{
+            if(list!=null && list.size()>0){
+                List<BasDeptInfo> basDeptInfoList=Lists.newArrayList();
+                basDeptInfoList=BeanUtil.listCopyTo(list,BasDeptInfo.class);
+
+                //循环验证数据有效性
+                for (BasDeptInfo basDeptInfo:basDeptInfoList) {
+                    if("".equals(basDeptInfo.getDeptId())) {
+                        return RespDTO.onError("请输入科室编码!");
+                    }else if(basDeptInfo.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(basDeptInfo.getDeptName())){
+                        return RespDTO.onError("请输入科室名称!");
+                    }
+                }
+                execute(basDeptInfoList);
+
+                if(logSwitch){
+                    basDeptInfoList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("科室信息-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else {
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("科室信息-异常","", JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    public void execute(List<BasDeptInfo> basDeptInfoList){
+        List<BasDeptInfo> addE=Lists.newArrayList();
+        List<BasDeptInfo> updateE=Lists.newArrayList();
+        basDeptInfoList.stream().forEach(s -> {
+            BasDeptInfo basDeptInfo =this.getOne(new QueryWrapper<BasDeptInfo>()
+                    .eq("dept_id", s.getDeptId())
+                    .eq("hospital_id", s.getHospitalId()), false);
+            if (basDeptInfo != null) {
+                s.setGmtModified(new Date());
+                updateE.add(s);
+            } else {
+                s.setGmtCreate(new Date());
+                addE.add(s);
+            }
+        });
+        if(updateE.size()>0){
+            basDeptInfoService.updateBatchByKey(updateE);
+        }
+        if(addE.size()>0){
+            basDeptInfoService.saveBatch(addE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/BasDoctorInfoFacade.java

@@ -0,0 +1,125 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ABasDoctorInfoDTO;
+import com.diagbot.entity.BasDoctorInfo;
+import com.diagbot.idc.VisibleIdCreater;
+import com.diagbot.service.impl.BasDoctorInfoServiceImpl;
+import com.diagbot.util.*;
+import com.diagbot.vo.data.ABasDoctorInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class BasDoctorInfoFacade extends BasDoctorInfoServiceImpl {
+    @Autowired
+    @Qualifier("basDoctorInfoServiceImpl")
+    private BasDoctorInfoServiceImpl basDoctorInfoService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    private static final String DOCTORS = "doctors::";
+
+    @Autowired
+    private RedisUtil redisUtil;
+    @Autowired
+    private VisibleIdCreater visibleIdCreater;
+
+    /**
+     * 同步历史数据
+     */
+    public void executeDoctorPast() {
+        String sql="select * from gi_userinfo";
+        List<BasDoctorInfo> basDeptInfoList = tzDBConn.getBasDoctorInfo(sql);
+        execute(basDeptInfoList);
+
+    }
+    /**
+     * 同步前一天医生信息
+     */
+    public void executeDoctor() {
+        String sql="select * from gi_userinfo";
+        List<BasDoctorInfo> basDeptInfoList = tzDBConn.getBasDoctorInfo(sql);
+        execute(basDeptInfoList);
+    }
+    /**
+     * 从接口接收医生信息
+     * @param list
+     * @return
+     */
+    public RespDTO<List<ABasDoctorInfoDTO>> executeDoctor(List<ABasDoctorInfoVO> list) {
+        try {
+            if(list!=null && list.size()>0){
+                List<BasDoctorInfo> basDoctorInfoList=Lists.newArrayList();
+                basDoctorInfoList=BeanUtil.listCopyTo(list,BasDoctorInfo.class);
+                //循环验证数据有效性
+                for (BasDoctorInfo basDoctorInfo:basDoctorInfoList) {
+                    if("".equals(basDoctorInfo.getDoctorId())) {
+                        return RespDTO.onError("请输入医生编码!");
+                    }else if(basDoctorInfo.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }
+                }
+
+                //execute(basDoctorInfoList);
+
+                String mrId = visibleIdCreater.getNextId(9).toString();
+                Boolean flag=redisUtil.setFlag(DOCTORS+mrId,basDoctorInfoList);
+
+                if(logSwitch){
+                    basDoctorInfoList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("医生信息-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                if(flag){
+                    return RespDTO.onSuc("操作正常！");
+                }else{
+                    return RespDTO.onError(DOCTORS+"数据存储到REDIS异常!");
+                }
+                //return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("医生信息-异常","", JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    public void execute(List<BasDoctorInfo> basDoctorInfoList){
+        List<BasDoctorInfo> addE=Lists.newArrayList();
+        List<BasDoctorInfo> updateE=Lists.newArrayList();
+        basDoctorInfoList.stream().forEach(s -> {
+            BasDoctorInfo basDoctorInfo =this.baseMapper.selectOne(new QueryWrapper<BasDoctorInfo>()
+                    .eq("doctor_id", s.getDoctorId())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (basDoctorInfo != null) {
+                s.setGmtModified(new Date());
+                updateE.add(s);
+            } else {
+                s.setGmtCreate(new Date());
+                addE.add(s);
+            }
+        });
+        if(updateE.size()>0){
+            boolean flag=basDoctorInfoService.updateBatchByKey(updateE,200);
+        }
+        if(addE.size()>0){
+            boolean flag=basDoctorInfoService.saveBatch(addE,1000);
+        }
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/data/BehospitalInfoFacade.java

@@ -0,0 +1,217 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ABehospitalInfoDTO;
+import com.diagbot.entity.BehospitalInfo;
+import com.diagbot.entity.QcType;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.QcTypeFacade;
+import com.diagbot.service.impl.BehospitalInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.APlaceFileVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class BehospitalInfoFacade extends BehospitalInfoServiceImpl {
+    @Autowired
+    @Qualifier("behospitalInfoServiceImpl")
+    private BehospitalInfoServiceImpl behospitalInfoService;
+    @Autowired
+    private QcTypeFacade qcTypeFacade;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 通过接口更新病人住院记录信息
+     * @param list
+     * @return
+     */
+    public RespDTO<List<ABehospitalInfoDTO>> executeBehospital(List<ABehospitalInfoVO> list) {
+        try {
+            if(list!=null && list.size()>0) {
+                //循环验证数据有效性
+                for (ABehospitalInfoVO behospitalInfo:list) {
+                    if("".equals(behospitalInfo.getBehospitalCode())) {
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }else if(behospitalInfo.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(behospitalInfo.getBehDeptId())){
+                        return RespDTO.onError("请输入住院科室编码!");
+                    }else if("".equals(behospitalInfo.getBehDeptName())){
+                        return RespDTO.onError("请输入住院科室名称!");
+                    }
+                }
+
+                List<BehospitalInfo> behospitalInfoList = Lists.newArrayList();
+                list.stream().forEach(s->{
+                    BehospitalInfo behospitalInfo=new BehospitalInfo();
+                    BeanUtil.copyProperties(s,behospitalInfo);
+                    if(StringUtil.isNotBlank(s.getBirthday())) {
+                        behospitalInfo.setBirthday(DateUtil.parseDate(s.getBirthday()));
+                    }
+                    if(StringUtil.isNotBlank(s.getLeaveHospitalDate())) {
+                        behospitalInfo.setLeaveHospitalDate(DateUtil.parseDateTime(s.getLeaveHospitalDate()));
+                    }
+                    if(StringUtil.isNotBlank(s.getBehospitalDate())){
+                        behospitalInfo.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));
+                    }
+                    if(StringUtil.isNotBlank(s.getPlacefileDate())){
+                        behospitalInfo.setPlacefileDate(DateUtil.parseDateTime(s.getPlacefileDate()));
+                    }
+                    behospitalInfoList.add(behospitalInfo);
+                });
+
+                execute(behospitalInfoList);
+
+                if(logSwitch){
+                    behospitalInfoList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院登记-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院登记-异常","", JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    public void execute(List<BehospitalInfo> behospitalInfoList){
+        List<BehospitalInfo> addE=Lists.newArrayList();
+        List<BehospitalInfo> updateE=Lists.newArrayList();
+        behospitalInfoList.stream().forEach(s -> {
+            BehospitalInfo behospitalInfo = this.getOne(new QueryWrapper<BehospitalInfo>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (behospitalInfo != null) {
+                s.setIsDeleted(IsDeleteEnum.N.getKey());
+                s.setGmtModified(DateUtil.now());
+                updateE.add(s);
+            } else {
+                s.setGmtCreate(new Date());
+                s.setIsPlacefile("0");//默认为未归档状态
+                s.setPlacefileDate(null);//默认归档时间为空
+                addE.add(s);
+            }
+        });
+        if(updateE.size()>0){
+            behospitalInfoService.updateBatchByKey(updateE);
+        }
+        if(addE.size()>0){
+            behospitalInfoService.saveBatch(addE);
+        }
+    }
+
+    /**
+     * 初始化QcTypeId
+     * @param s
+     * @return
+     */
+    private Long initQcTypeId(BehospitalInfo s) {
+        Long qcTypeId = Long.valueOf("0");
+        //根据科室查找对应质控类型
+        QcType qcTypeList = qcTypeFacade.getOne(new QueryWrapper<QcType>()
+                .eq("beh_dept_id", s.getBehDeptId())
+                .eq("hospital_id", s.getHospitalId())
+                .eq("default_module", 0)
+                .eq("sex",s.getSex())
+                .eq("is_deleted", IsDeleteEnum.N));
+        if(qcTypeList == null){
+            //无质控类型时，新增后初始化
+            QcType qcType = qcTypeFacade.getOne(new QueryWrapper<QcType>()
+                    .eq("default_module", 1)
+                    .eq("hospital_id", s.getHospitalId())
+                    .eq("sex",s.getSex())
+                    .eq("is_deleted", IsDeleteEnum.N));
+            if(qcType!=null){
+                qcTypeId = qcType.getId();
+            }
+        }else {
+            qcTypeId = qcTypeList.getId();
+        }
+        return qcTypeId;
+    }
+
+    /**
+     * @Description:归档/取消归档
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getBehospitalCode())){
+                return RespDTO.onError("请输入病人住院编码!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else {
+                UpdateWrapper<BehospitalInfo> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("behospital_code", aDeleteFlagVO.getBehospitalCode());
+                updateWrapper.eq("hospital_id", aDeleteFlagVO.getHospitalId());
+                updateWrapper.eq("is_deleted",IsDeleteEnum.N);
+                updateWrapper.set("is_deleted",IsDeleteEnum.Y);
+                updateWrapper.set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new BehospitalInfo(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院登记-删除",JSON.toJSONString(aDeleteFlagVO),"","删除成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院登记-删除","",JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+
+    public RespDTO placeFileFlag(APlaceFileVO aPlaceFileVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isBlank(aPlaceFileVO.getBehospitalCode())){
+                return RespDTO.onError("请输入病人住院编码!");
+            }else if(aPlaceFileVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else{
+                UpdateWrapper<BehospitalInfo> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("behospital_code", aPlaceFileVO.getBehospitalCode());
+                updateWrapper.eq("hospital_id", aPlaceFileVO.getHospitalId());
+                updateWrapper.eq("is_deleted",IsDeleteEnum.N);
+                if("0".equals(aPlaceFileVO.getPlaceState())){
+                    //取消归档为运行病历
+                    updateWrapper.set("is_placefile","0");
+                }else if("1".equals(aPlaceFileVO.getPlaceState())){
+                    //归档为终末病历
+                    updateWrapper.set("is_placefile","1");
+                }
+                updateWrapper.set("placefile_date",aPlaceFileVO.getPlaceFileDate().isEmpty()?DateUtil.formatDateTime(DateUtil.now()):DateUtil.parseDateTime(aPlaceFileVO.getPlaceFileDate()));
+                updateWrapper.set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new BehospitalInfo(),updateWrapper);
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院登记-归档","",JSON.toJSONString(aPlaceFileVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/DoctorAdviceFacade.java

@@ -0,0 +1,140 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.DoctorAdvice;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.DoctorAdviceServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.ADoctorAdviceVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class DoctorAdviceFacade extends DoctorAdviceServiceImpl{
+
+    @Autowired
+    @Qualifier("doctorAdviceServiceImpl")
+    private DoctorAdviceServiceImpl doctorAdviceService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 数据引擎-通过接口更新医生医嘱信息
+     * @param list
+     * @return
+     */
+    public RespDTO executeDoctorAdvice(List<ADoctorAdviceVO> list) {
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (ADoctorAdviceVO doctorAdvice:list) {
+                    if("".equals(doctorAdvice.getDoctorAdviceId())) {
+                        return RespDTO.onError("请输入病人医嘱编码!");
+                    }else if(doctorAdvice.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(doctorAdvice.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<DoctorAdvice> doctorAdviceList=Lists.newArrayList();
+                list.stream().forEach(s->{
+                    DoctorAdvice doctorAdvice=new DoctorAdvice();
+                    BeanUtil.copyProperties(s,doctorAdvice);
+                    if(StringUtil.isNotBlank(s.getDaStartDate())){
+                        doctorAdvice.setDaStartDate(DateUtil.parseDateTime(s.getDaStartDate()));
+                    }
+                    if(StringUtil.isNotBlank(s.getDaStopDate())){
+                        doctorAdvice.setDaStopDate(DateUtil.parseDateTime(s.getDaStopDate()));
+                    }
+                    doctorAdviceList.add(doctorAdvice);
+                });
+                execute(doctorAdviceList);
+                if(logSwitch){
+                    doctorAdviceList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院医嘱-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院医嘱-异常","", JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    public void execute(List<DoctorAdvice> doctorAdviceList){
+        List<DoctorAdvice> addE = Lists.newLinkedList();
+        List<DoctorAdvice> updateE = Lists.newLinkedList();
+        if (doctorAdviceList != null && doctorAdviceList.size() > 0) {
+            doctorAdviceList.stream().forEach(s -> {
+                DoctorAdvice doctorAdvice = this.getOne(new QueryWrapper<DoctorAdvice>()
+                        .eq("doctor_advice_id", s.getDoctorAdviceId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()));
+                if (doctorAdvice != null) {
+                    s.setIsDeleted(IsDeleteEnum.N.getKey());
+                    s.setGmtModified(DateUtil.now());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            doctorAdviceService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            doctorAdviceService.updateBatchByKey(updateE);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getDoctorAdviceId())) {
+                return RespDTO.onError("请输入病人医嘱编码!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else if(StringUtil.isEmpty(aDeleteFlagVO.getBehospitalCode())){
+                return RespDTO.onError("请输入病人住院编码!");
+            }else {
+                UpdateWrapper<DoctorAdvice> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("doctor_advice_id", aDeleteFlagVO.getDoctorAdviceId())
+                        .eq("behospital_code", aDeleteFlagVO.getBehospitalCode())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new DoctorAdvice(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院医嘱-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病人住院医嘱-删除","",JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/HomeDiagnoseInfoFacade.java

@@ -0,0 +1,123 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.AHomeDiagnoseDTO;
+import com.diagbot.entity.HomeDiagnoseInfo;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.HomeDiagnoseInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.AHomeDiagnoseVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class HomeDiagnoseInfoFacade extends HomeDiagnoseInfoServiceImpl{
+
+    @Autowired
+    @Qualifier("homeDiagnoseInfoServiceImpl")
+    private HomeDiagnoseInfoServiceImpl homeDiagnoseInfoService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 数据引擎-通过接口更新病案首页诊断
+     * @param list
+     * @return
+     */
+    public RespDTO<List<AHomeDiagnoseDTO>> executeHomeDiagnose(List<AHomeDiagnoseVO> list) {
+        try{
+            if(list!=null && list.size()>0){
+                List<HomeDiagnoseInfo> homeDiagnoseList=Lists.newArrayList();
+                homeDiagnoseList=BeanUtil.listCopyTo(list,HomeDiagnoseInfo.class);
+                execute(homeDiagnoseList);
+                if(logSwitch){
+                    homeDiagnoseList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页医嘱-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页医嘱-异常","", JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+
+    }
+
+    public void execute(List<HomeDiagnoseInfo> homeDiagnoseList){
+        List<HomeDiagnoseInfo> addE = Lists.newLinkedList();
+        List<HomeDiagnoseInfo> updateE = Lists.newLinkedList();
+        if (homeDiagnoseList != null && homeDiagnoseList.size() > 0) {
+            homeDiagnoseList.stream().forEach(s -> {
+                if(s.getHomePageId()!=null && !"".equals(s.getDiagnoseOrderNo())){
+                    HomeDiagnoseInfo diagnoseInfo = this.getOne(new QueryWrapper<HomeDiagnoseInfo>()
+                            .eq("home_page_id", s.getHomePageId())
+                            .eq("hospital_id", s.getHospitalId())
+                            .eq("diagnose_order_no", s.getDiagnoseOrderNo()), false);
+                    if (diagnoseInfo != null) {
+                        s.setGmtModified(new Date());
+                        s.setIsDeleted(IsDeleteEnum.N.getKey());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                }
+            });
+        }
+        if(addE.size()>0){
+            homeDiagnoseInfoService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            homeDiagnoseInfoService.updateBatchByKey(updateE);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getHomePageId())) {
+                return RespDTO.onError("出院诊断未输入病案首页编号!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("出院诊断未输入医院编码!");
+            }else if(StringUtil.isEmpty(aDeleteFlagVO.getDiagnoseOrderNo())){
+                return RespDTO.onError("出院诊断未输入顺序号!");
+            }else {
+                UpdateWrapper<HomeDiagnoseInfo> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("home_page_id", aDeleteFlagVO.getHomePageId())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("diagnose_order_no", aDeleteFlagVO.getDiagnoseOrderNo())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new HomeDiagnoseInfo(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页-诊断-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页-诊断-删除","",JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/HomeOperationInfoFacade.java

@@ -0,0 +1,127 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.HomeOperationInfo;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.HomeOperationInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.AHomeOperationVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class HomeOperationInfoFacade extends HomeOperationInfoServiceImpl{
+
+    @Autowired
+    @Qualifier("homeOperationInfoServiceImpl")
+    private HomeOperationInfoServiceImpl homeOperationInfoService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 终末质控-通过接口更新病案首页手术
+     * @param list
+     * @return
+     */
+    public RespDTO executeHomeOperation(List<AHomeOperationVO> list) {
+        try {
+            List<HomeOperationInfo> homeOperationList=Lists.newArrayList();
+            if(list!=null && list.size()>0){
+                list.stream().forEach(s->{
+                    HomeOperationInfo homeOperationInfo=new HomeOperationInfo();
+                    BeanUtil.copyProperties(s,homeOperationInfo);
+                    homeOperationInfo.setOperationDate(DateUtil.parseDateTime(s.getOperationDate()));
+                    homeOperationList.add(homeOperationInfo);
+                });
+                execute(homeOperationList);
+                if(logSwitch){
+                    homeOperationList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页手术-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页手术-异常","",JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    public void execute(List<HomeOperationInfo> homeOperationList){
+        List<HomeOperationInfo> addE = Lists.newLinkedList();
+        List<HomeOperationInfo> updateE = Lists.newLinkedList();
+        if (homeOperationList != null && homeOperationList.size() > 0) {
+            homeOperationList.stream().forEach(s -> {
+                if(s.getHomePageId()!=null && !"".equals(s.getOperationOrderNo())) {
+                    QueryWrapper<HomeOperationInfo> queryWrapper = new QueryWrapper<>();
+                    queryWrapper.eq("home_page_id", s.getHomePageId());
+                    queryWrapper.eq("hospital_id", s.getHospitalId());
+                    queryWrapper.eq("operation_order_no", s.getOperationOrderNo());
+                    HomeOperationInfo operationInfo = this.getOne(queryWrapper, false);
+                    if (operationInfo != null) {
+                        s.setGmtModified(new Date());
+                        s.setIsDeleted(IsDeleteEnum.N.getKey());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                }
+            });
+        }
+        if(addE.size()>0){
+            homeOperationInfoService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            homeOperationInfoService.updateBatchByKey(updateE);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getHomePageId())) {
+                return RespDTO.onError("住院手术未输入病案首页编号!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("住院手术未输入医院编码!");
+            }else if(StringUtil.isEmpty(aDeleteFlagVO.getOperationOrderNo())){
+                return RespDTO.onError("住院手术未输入顺序号!");
+            }else {
+                UpdateWrapper<HomeOperationInfo> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("home_page_id", aDeleteFlagVO.getHomePageId())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("operation_order_no", aDeleteFlagVO.getOperationOrderNo())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new HomeOperationInfo(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页-手术-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页-手术-删除","",JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/HomePageFacade.java

@@ -0,0 +1,288 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.AnalyzeRunDTO;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.AHomePageDTO;
+import com.diagbot.entity.HomePage;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.BehospitalInfoFacade;
+import com.diagbot.service.impl.HomePageServiceImpl;
+import com.diagbot.util.*;
+import com.diagbot.vo.AnalyzeRunVO;
+import com.diagbot.vo.data.*;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class HomePageFacade extends HomePageServiceImpl{
+
+    @Autowired
+    @Qualifier("homePageServiceImpl")
+    private HomePageServiceImpl homePageService;
+
+    @Autowired
+    private com.diagbot.facade.data.AHomeDiagnoseInfoFacade aHomeDiagnoseInfoFacade;
+
+    @Autowired
+    private com.diagbot.facade.data.AHomeOperationInfoFacade aHomeOperationInfoFacade;
+
+    @Autowired
+    private BehospitalInfoFacade behospitalInfoFacade;
+
+    @Autowired
+    private ReadProperties readProperties;
+
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    @Value("${xml_analyse.enable}")
+    private boolean xmlAnalyse;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 运行质控-验证数据有效性
+     * @param aHomePageIngVO
+     * @return
+     */
+    public RespDTO<Map<String, Object>> executeHomePageIng(AHomePageIngVO aHomePageIngVO){
+        if(aHomePageIngVO.getHomePages()!=null && aHomePageIngVO.getHomePages().size()>0){
+            //验证数据有效性
+            for (AHomePageVO aHomePageVO:aHomePageIngVO.getHomePages()) {
+                if("".equals(aHomePageVO.getHomePageId())) {
+                    return RespDTO.onError("请输入病案首页编号!");
+                }else if(aHomePageVO.getHospitalId()==null){
+                    return RespDTO.onError("请输入医院编码!");
+                }else if("".equals(aHomePageVO.getBehospitalCode())){
+                    return RespDTO.onError("请输入病人住院编码!");
+                }
+                //出院诊断
+                if(aHomePageVO.getLeaveDiags()!=null && aHomePageVO.getLeaveDiags().size()>0){
+                    for (AHomeDiagnoseVO aHomeDiagnoseVO:aHomePageVO.getLeaveDiags()){
+                        if("".equals(aHomeDiagnoseVO.getHomePageId())) {
+                            return RespDTO.onError("出院诊断未输入病案首页编号!");
+                        }else if(aHomeDiagnoseVO.getHospitalId()==null){
+                            return RespDTO.onError("出院诊断未输入医院编码!");
+                        }else if("".equals(aHomeDiagnoseVO.getDiagnoseOrderNo())){
+                            return RespDTO.onError("出院诊断未输入顺序号!");
+                        }
+                    }
+                };
+
+                //住院手术
+                if(aHomePageVO.getOperations()!=null && aHomePageVO.getOperations().size()>0){
+                    for (AHomeOperationVO aHomeOperationVO:aHomePageVO.getOperations()){
+                        if("".equals(aHomeOperationVO.getHomePageId())) {
+                            return RespDTO.onError("住院手术未输入病案首页编号!");
+                        }else if(aHomeOperationVO.getHospitalId()==null){
+                            return RespDTO.onError("住院手术未输入医院编码!");
+                        }else if("".equals(aHomeOperationVO.getOperationOrderNo())){
+                            return RespDTO.onError("住院手术未输入顺序号!");
+                        }
+                    }
+                }
+            }
+
+            //装载数据
+            updateHomePageIng(aHomePageIngVO);
+
+            if(xmlAnalyse){
+                //评分后返回结构体
+                return homePageIng(aHomePageIngVO);
+            }
+            //评分后返回结构体
+            return RespDTO.onSuc("操作成功!");
+        }else{
+            return RespDTO.onError("未接收到数据!");
+        }
+    }
+
+    /**
+     * 更新数据到数据库
+     * @param aHomePageIngVO
+     */
+    private void updateHomePageIng(AHomePageIngVO aHomePageIngVO){
+        try {
+            List<HomePage> homePageList=Lists.newArrayList();
+            aHomePageIngVO.getHomePages().stream().forEach(s->{
+                //初始化入参
+                HomePage homePage=new HomePage();
+                BeanUtil.copyProperties(s,homePage);
+                homePage.setBirthday(DateUtil.parseDate(s.getBirthday()));
+                homePageList.add(homePage);
+
+                //初始化诊断和手术，并同步到数据库
+                aHomeDiagnoseInfoFacade.executeHomeDiagnose(s.getLeaveDiags());//首页诊断
+                aHomeOperationInfoFacade.executeHomeOperation(s.getOperations());//首页手术
+            });
+            execute(homePageList);
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页","", JSON.toJSONString(aHomePageIngVO),"",e.getMessage());
+        }
+    }
+
+    /**
+     * 评分后返回结构体
+     * @param aHomePageIngVO
+     * @return
+     */
+    private RespDTO<Map<String, Object>> homePageIng(AHomePageIngVO aHomePageIngVO){
+        String behospitalCode =aHomePageIngVO.getHomePages().get(0).getBehospitalCode();
+        Long hospitalId=aHomePageIngVO.getHomePages().get(0).getHospitalId();
+        Long modeId=Long.valueOf("6");//病案首页默认为6
+        if(aHomePageIngVO.getDockModeType().equals("0")){
+            Map<String,Object> map=new HashMap<String,Object>();
+            List<AHomePageDTO> homePageDtoList=BeanUtil.listCopyTo(aHomePageIngVO.getHomePages(),AHomePageDTO.class);
+            map.put("homePages",homePageDtoList);
+            return RespDTO.onSuc(map);
+        }else if(aHomePageIngVO.getDockModeType().equals("1")){
+            //页面模式
+            String url=readProperties.getProcessQcUrl()+"?behospitalCode="+behospitalCode+"&hospitalId="+hospitalId+"&modeId="+modeId;
+            Map<String,Object> map=new HashMap<String,Object>();
+            map.put("url",url);
+            return RespDTO.onSuc(map);
+        }else if(aHomePageIngVO.getDockModeType().equals("2")){
+            AnalyzeRunVO analyzeRunVO=new AnalyzeRunVO();
+            analyzeRunVO.setBehospitalCode(behospitalCode);
+            analyzeRunVO.setHospitalId(hospitalId);
+            analyzeRunVO.setModeId(modeId);
+            AnalyzeRunDTO analyzeRunDTO=behospitalInfoFacade.analyzeRun(analyzeRunVO);
+            Map<String,Object> map=new HashMap<String,Object>();
+            if(analyzeRunDTO.getMsgDTOList().size()>0){
+                map.put("analyze",analyzeRunDTO.getMsgDTOList());
+            }
+            return RespDTO.onSuc(map);
+        }else{
+            //页面模式+接口引擎模式
+            String url=readProperties.getProcessQcUrl()+"?behospitalCode="+behospitalCode+"&hospitalId="+hospitalId+"&modeId="+modeId;
+
+            AnalyzeRunVO analyzeRunVO=new AnalyzeRunVO();
+            analyzeRunVO.setBehospitalCode(behospitalCode);
+            analyzeRunVO.setHospitalId(hospitalId);
+            analyzeRunVO.setModeId(modeId);
+            AnalyzeRunDTO analyzeRunDTO=behospitalInfoFacade.analyzeRun(analyzeRunVO);
+            Map<String,Object> map=new HashMap<String,Object>();
+            if(analyzeRunDTO.getMsgDTOList().size()>0){
+                map.put("url",url);
+                map.put("analyze",analyzeRunDTO.getMsgDTOList());
+            }
+            return RespDTO.onSuc(map);
+        }
+    }
+
+
+    /**
+     * 通过接口更新病案首页-不包含医嘱和手术
+     * @param list
+     * @return
+     */
+    public RespDTO<List<AHomePageDTO>> executeHomePage(List<AHomePageVO> list) {
+        if(list!=null && list.size()>0){
+            //循环验证数据有效性
+            for (AHomePageVO aHomePageVO:list) {
+                if("".equals(aHomePageVO.getHomePageId())) {
+                    return RespDTO.onError("请输入病案首页编号!");
+                }else if(aHomePageVO.getHospitalId()==null){
+                    return RespDTO.onError("请输入医院编码!");
+                }else if("".equals(aHomePageVO.getBehospitalCode())){
+                    return RespDTO.onError("请输入病人住院编码!");
+                }
+            }
+            //装载数据
+            List<HomePage> homePageList=Lists.newArrayList();
+            list.stream().forEach(s->{
+                //初始化入参
+                HomePage homePage=new HomePage();
+                BeanUtil.copyProperties(s,homePage);
+                homePage.setBirthday(DateUtil.parseDate(s.getBirthday()));
+                homePage.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));
+                homePage.setLeaveHospitalDate(DateUtil.parseDateTime(s.getLeaveHospitalDate()));
+                homePage.setQcDate(DateUtil.parseDateTime(s.getQcDate()));
+                homePageList.add(homePage);
+            });
+            execute(homePageList);
+            List<AHomePageDTO> homePageDtoList=BeanUtil.listCopyTo(list,AHomePageDTO.class);
+            return RespDTO.onSuc(homePageDtoList);
+        }else{
+            return RespDTO.onError("未接收到数据!");
+        }
+    }
+
+    /**
+     * 病案首页
+     * @param homePageList
+     */
+    public void execute(List<HomePage> homePageList){
+        try {
+            List<HomePage> addE = Lists.newLinkedList();
+            List<HomePage> updateE = Lists.newLinkedList();
+            if (homePageList != null && homePageList.size() > 0) {
+                homePageList.stream().forEach(s -> {
+                    HomePage homePage = this.getOne(new QueryWrapper<HomePage>()
+                            .eq("home_page_id", s.getHomePageId())
+                            .eq("hospital_id", s.getHospitalId())
+                            .eq("behospital_code", s.getBehospitalCode()), false);
+                    if (homePage != null) {
+                        s.setGmtModified(new Date());
+                        s.setIsDeleted(IsDeleteEnum.N.getKey());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                });
+            }
+            if(addE.size()>0){
+                homePageService.saveBatch(addE);
+            }
+            if(updateE.size()>0){
+                homePageService.updateBatchByKey(updateE);
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页","", JSON.toJSONString(homePageList),"",e.getMessage());
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getHomePageId())) {
+                return RespDTO.onError("请输入病案首页编号!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else if(StringUtil.isEmpty(aDeleteFlagVO.getBehospitalCode())){
+                return RespDTO.onError("请输入病人住院编码!");
+            }else {
+                UpdateWrapper<HomePage> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("home_page_id", aDeleteFlagVO.getHomePageId())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("behospital_code", aDeleteFlagVO.getBehospitalCode())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+                Boolean flag=update(new HomePage(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病案首页-删除","",JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/LogInfoFacade.java

@@ -0,0 +1,8 @@
+package com.lantone.data.facade.data;
+
+import com.diagbot.service.impl.LogInfoServiceImpl;
+import org.springframework.stereotype.Component;
+
+@Component
+public class LogInfoFacade extends LogInfoServiceImpl {
+}

data-service/src/main/java/com/lantone/data/facade/data/MedAbnormalInfoFacade.java

@@ -0,0 +1,28 @@
+package com.lantone.data.facade.data;
+
+import com.diagbot.entity.MedAbnormalInfo;
+import com.diagbot.service.impl.MedAbnormalInfoServiceImpl;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+
+@Component
+public class MedAbnormalInfoFacade extends MedAbnormalInfoServiceImpl {
+    /**
+     * 接口日志记录
+     *
+     * @param paramIn
+     * @param paramOut
+     * @param remark
+     */
+    public void saveAbnormalInfo(String moduleName, String recId, String paramIn, String paramOut, String remark) {
+        MedAbnormalInfo medAbnormalInfo = new MedAbnormalInfo();
+        medAbnormalInfo.setModuleName(moduleName);
+        medAbnormalInfo.setRecId(recId);
+        medAbnormalInfo.setParamIn(paramIn);
+        medAbnormalInfo.setParamOut(paramOut);
+        medAbnormalInfo.setRamark(remark);
+        medAbnormalInfo.setGmtCreate(new Date());
+        this.save(medAbnormalInfo);
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedCrisisFacade.java

@@ -0,0 +1,105 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.AMedCrisisDTO;
+import com.diagbot.entity.MedCrisisInfo;
+import com.diagbot.service.impl.MedCrisisInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.vo.data.AMedCrisisVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class MedCrisisFacade extends MedCrisisInfoServiceImpl {
+
+    @Autowired
+    @Qualifier("medCrisisInfoServiceImpl")
+    private MedCrisisInfoServiceImpl medCrisisInfoService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public RespDTO<List<AMedCrisisDTO>> executeMedCrisis(List<AMedCrisisVO> list) {
+        try{
+            if (list != null && list.size() > 0) {
+                //循环验证数据有效性
+                for (AMedCrisisVO aMedCrisisVO : list) {
+                    if ("".equals(aMedCrisisVO.getRecId())) {
+                        return RespDTO.onError("请输入文书编码!");
+                    } else if ("".equals(aMedCrisisVO.getBehospitalCode())) {
+                        return RespDTO.onError("请输入病人住院编码!");
+                    } else if (aMedCrisisVO.getHospitalId() == null) {
+                        return RespDTO.onError("请输入医院编码!");
+                    } else if ("".equals(aMedCrisisVO.getRecType())) {
+                        return RespDTO.onError("请输入危急值类型!");
+                    }
+                }
+
+                List<MedCrisisInfo> medCrisisList = Lists.newArrayList();
+                list.stream().forEach(s -> {
+                    MedCrisisInfo medCrisisInfo = new MedCrisisInfo();
+                    BeanUtil.copyProperties(s, medCrisisInfo);
+                    medCrisisInfo.setRepDate(DateUtil.parseDateTime(s.getRepDate()));
+                    medCrisisInfo.setSendDate(DateUtil.parseDateTime(s.getSendDate()));
+                    medCrisisList.add(medCrisisInfo);
+                });
+                execute(medCrisisList);
+
+                if(logSwitch){
+                    medCrisisList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("危急值信息-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            } else {
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("危急值信息-异常","", JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    public void execute(List<MedCrisisInfo> medCrisisList) {
+        List<MedCrisisInfo> addE = Lists.newLinkedList();
+        List<MedCrisisInfo> updateE = Lists.newLinkedList();
+        if (medCrisisList != null && medCrisisList.size() > 0) {
+            medCrisisList.forEach(s -> {
+                try {
+                    MedCrisisInfo medCrisisInfo = this.getOne(new QueryWrapper<MedCrisisInfo>()
+                            .eq("rec_id", s.getRecId())
+                            .eq("hospital_id", s.getHospitalId())
+                            .eq("behospital_code", s.getBehospitalCode())
+                            .eq("rec_type", s.getRecType()), false);
+                    if (medCrisisInfo != null) {
+                        s.setGmtModified(new Date());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                } catch (Exception e) {
+                    log.error(e.getMessage(), e);
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("数据解析", s.getRecId(), JSON.toJSONString(medCrisisList), "", e.getMessage());
+                }
+            });
+        }
+        if (addE.size() > 0) {
+            medCrisisInfoService.saveBatch(addE);
+        }
+        if (updateE.size() > 0) {
+            medCrisisInfoService.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedLisInfoFacade.java

@@ -0,0 +1,122 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.MedLisInfo;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.MedLisInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.AMedLisInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class MedLisInfoFacade extends MedLisInfoServiceImpl {
+
+    private TZDBConn tzDBConn = new TZDBConn();
+    @Autowired
+    @Qualifier("medLisInfoServiceImpl")
+    private MedLisInfoServiceImpl medLisInfoServiceImpl;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public RespDTO  dealData(List<AMedLisInfoVO> list) {
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (AMedLisInfoVO aMedLisInfoVO:list) {
+                    if(StringUtil.isEmpty(aMedLisInfoVO.getRepNo())){
+                        return RespDTO.onError("请输入报告单号!");
+                    }else if(aMedLisInfoVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if(StringUtil.isEmpty(aMedLisInfoVO.getBehospitalCode())) {
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+
+                List<MedLisInfo> medLisInfoList=Lists.newArrayList();
+                list.stream().forEach(s->{
+                    MedLisInfo medLisInfo=new MedLisInfo();
+                    BeanUtil.copyProperties(s,medLisInfo);
+                    medLisInfoList.add(medLisInfo);
+                });
+                execute(medLisInfoList);
+                if(logSwitch){
+                    medLisInfoList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("检验信息-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常!");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检验信息-异常","",JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+    
+    public void execute(List<MedLisInfo> medLisInfoList){
+        List<MedLisInfo> addE = Lists.newLinkedList();
+        List<MedLisInfo> updateE = Lists.newLinkedList();
+        if (medLisInfoList != null && medLisInfoList.size() > 0) {
+            medLisInfoList.stream().forEach(s -> {
+                MedLisInfo medLisInfo = this.getOne(new QueryWrapper<MedLisInfo>()
+                        .eq("rep_no", s.getRepNo())
+                        .eq("hospital_id", s.getHospitalId()), false);
+                if (medLisInfo != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            medLisInfoServiceImpl.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getRepNo())){
+                return RespDTO.onError("请输入报告单号!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else {
+                UpdateWrapper<MedLisInfo> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("rep_no", aDeleteFlagVO.getRepNo())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new MedLisInfo(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("检查-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检查信息-删除异常",aDeleteFlagVO.getRecId(), JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedLisResultFacade.java

@@ -0,0 +1,132 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.MedLisResult;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.MedLisResultServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.AMedLisResultVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class MedLisResultFacade extends MedLisResultServiceImpl {
+    @Autowired
+    @Qualifier("medLisResultServiceImpl")
+    private MedLisResultServiceImpl medLisResultServiceImpl;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 同步前一天
+     */
+    public void executeMedLisResult() {
+        //String sql="select * from br_rechome where cjcxrq>=dateadd(day,-2,getdate()) and cjcxrq<=getdate()";
+        //同步前一天的数据
+        String sql="select * from br_rechome where cjcxrq>=(select CONVERT(varchar,GETDATE()-2,23)) and cjcxrq<(select CONVERT(varchar,GETDATE(),23))";
+        List<MedLisResult> medLisResultList= tzDBConn.getLisResult(sql);
+        execute(medLisResultList);
+    }
+
+    public RespDTO executeMedLisResult(List<AMedLisResultVO> list) {
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (AMedLisResultVO aMedLisResultVO:list) {
+                    if(StringUtil.isEmpty(aMedLisResultVO.getRepNo())){
+                        return RespDTO.onError("请输入报告单号!");
+                    }else if(aMedLisResultVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if(StringUtil.isEmpty(aMedLisResultVO.getBehospitalCode())) {
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+
+                List<MedLisResult> medLisResultList=Lists.newArrayList();
+                list.stream().forEach(s->{
+                    MedLisResult medLisResult=new MedLisResult();
+                    BeanUtil.copyProperties(s,medLisResult);
+                    medLisResultList.add(medLisResult);
+                });
+                execute(medLisResultList);
+                if(logSwitch){
+                    medLisResultList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("检验结果-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检验结果-异常","",JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+
+    public void execute(List<MedLisResult> medLisResultList){
+        List<MedLisResult> addE = Lists.newLinkedList();
+        List<MedLisResult> updateE = Lists.newLinkedList();
+        if (medLisResultList != null && medLisResultList.size() > 0) {
+            medLisResultList.stream().forEach(s -> {
+                MedLisResult medLisResult = this.getOne(new QueryWrapper<MedLisResult>()
+                        .eq("rep_no", s.getRepNo())
+                        .eq("hospital_id", s.getHospitalId()), false);
+                if (medLisResult != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            medLisResultServiceImpl.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getRepNo())){
+                return RespDTO.onError("请输入报告单号!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else {
+                UpdateWrapper<MedLisResult> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("rep_no", aDeleteFlagVO.getRepNo())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("is_deleted",IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new MedLisResult(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("检验-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检验-删除","",JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedPacsInfoFacade.java

@@ -0,0 +1,124 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.MedPacsInfo;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.MedPacsInfoServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.AMedPacsInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class MedPacsInfoFacade extends MedPacsInfoServiceImpl {
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    @Autowired
+    @Qualifier("medPacsInfoServiceImpl")
+    private MedPacsInfoServiceImpl medPacsInfoServiceImpl;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    
+    public RespDTO dealData(List<AMedPacsInfoVO> list) {
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (AMedPacsInfoVO aMedPacsInfoVO:list) {
+                    if(StringUtil.isEmpty(aMedPacsInfoVO.getRepNo())){
+                        return RespDTO.onError("请输入报告单号!");
+                    }else if(aMedPacsInfoVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if(StringUtil.isEmpty(aMedPacsInfoVO.getBehospitalCode())) {
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+
+                List<MedPacsInfo> medPacsInfoList=Lists.newArrayList();
+                list.stream().forEach(s->{
+                    MedPacsInfo medPacsInfo=new MedPacsInfo();
+                    BeanUtil.copyProperties(s,medPacsInfo);
+                    medPacsInfoList.add(medPacsInfo);
+                });
+                execute(medPacsInfoList);
+
+                if(logSwitch){
+                    medPacsInfoList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("检查信息-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检查信息-异常","",JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+    
+    public void execute(List<MedPacsInfo> medPacsInfoList){
+        List<MedPacsInfo> addE = Lists.newLinkedList();
+        List<MedPacsInfo> updateE = Lists.newLinkedList();
+        if (medPacsInfoList != null && medPacsInfoList.size() > 0) {
+            medPacsInfoList.stream().forEach(s -> {
+                MedPacsInfo medPacsInfo = this.getOne(new QueryWrapper<MedPacsInfo>()
+                        .eq("rep_no", s.getRepNo())
+                        .eq("hospital_id", s.getHospitalId()), false);
+                if (medPacsInfo != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            medPacsInfoServiceImpl.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getRepNo())){
+                return RespDTO.onError("请输入报告单号!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else {
+                UpdateWrapper<MedPacsInfo> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("rep_no", aDeleteFlagVO.getRepNo())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new MedPacsInfo(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("检查-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检查信息-删除异常",aDeleteFlagVO.getRecId(), JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedPacsResultFacade.java

@@ -0,0 +1,134 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.MedPacsResult;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.MedPacsResultServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.AMedPacsResultVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class MedPacsResultFacade extends MedPacsResultServiceImpl {
+
+    @Autowired
+    @Qualifier("medPacsResultServiceImpl")
+    private MedPacsResultServiceImpl medPacsResultServiceImpl;
+
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 同步前一天
+     */
+    public void executeMedPacsResult() {
+        //String sql="select * from br_rechome where cjcxrq>=dateadd(day,-2,getdate()) and cjcxrq<=getdate()";
+        //同步前一天的数据
+        String sql="select * from br_rechome where cjcxrq>=(select CONVERT(varchar,GETDATE()-2,23)) and cjcxrq<(select CONVERT(varchar,GETDATE(),23))";
+        List<MedPacsResult> medPacsResultList= tzDBConn.getPacsResult(sql);
+        execute(medPacsResultList);
+    }
+
+    public RespDTO<List<AMedPacsResultVO>> executeMedPacsResult(List<AMedPacsResultVO> list) {
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (AMedPacsResultVO aMedPacsResultVO:list) {
+                    if(StringUtil.isEmpty(aMedPacsResultVO.getRepNo())){
+                        return RespDTO.onError("请输入报告单号!");
+                    }else if(aMedPacsResultVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if(StringUtil.isEmpty(aMedPacsResultVO.getBehospitalCode())) {
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+
+                List<MedPacsResult> medPacsResultList=Lists.newArrayList();
+                list.stream().forEach(s->{
+                    MedPacsResult medPacsResult=new MedPacsResult();
+                    BeanUtil.copyProperties(s,medPacsResult);
+                    medPacsResultList.add(medPacsResult);
+                });
+                execute(medPacsResultList);
+                if(logSwitch){
+                    medPacsResultList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("检查结果-正常","", JSON.toJSONString(list),"","");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检查结果-异常","",JSON.toJSONString(list),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+
+    public void execute(List<MedPacsResult> medPacsResultList){
+        List<MedPacsResult> addE = Lists.newLinkedList();
+        List<MedPacsResult> updateE = Lists.newLinkedList();
+        if (medPacsResultList != null && medPacsResultList.size() > 0) {
+            medPacsResultList.stream().forEach(s -> {
+                MedPacsResult medPacsResult = this.getOne(new QueryWrapper<MedPacsResult>()
+                        .eq("rep_no", s.getRepNo())
+                        .eq("hospital_id", s.getHospitalId()), false);
+                if (medPacsResult != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            medPacsResultServiceImpl.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if(StringUtil.isEmpty(aDeleteFlagVO.getRepNo())){
+                return RespDTO.onError("请输入报告单号!");
+            }else if(aDeleteFlagVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else {
+                UpdateWrapper<MedPacsResult> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("rep_no", aDeleteFlagVO.getRepNo())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("is_deleted",IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new MedPacsResult(),updateWrapper);
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("检查-删除","",JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedRecordTypeFacade.java

@@ -0,0 +1,100 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.AMedicalRecordTypeDTO;
+import com.diagbot.entity.MedRecordType;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.MedRecordTypeServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.AMedicalRecordTypeVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class MedRecordTypeFacade extends MedRecordTypeServiceImpl {
+
+    @Autowired
+    @Qualifier("medRecordTypeServiceImpl")
+    private MedRecordTypeServiceImpl medRecordTypeService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 终末质控-同步前一天变更的模板类型
+     */
+    public void executeMRType() {
+        //String sql="select * from ar_medirecclass where SFZFPB='1'";
+        String sql="select * from ar_medirecclass where SFZFPB='1' and cjcxrq>=(select CONVERT(varchar,GETDATE()-2,23)) and cjcxrq<(select CONVERT(varchar,GETDATE(),23))";
+        List<MedRecordType> medRecordTypeList = tzDBConn.getMedicalRecordType(sql);
+        execute(medRecordTypeList);
+    }
+    /**
+     * 数据引擎-通过接口更新病人住院记录信息
+     * @param list
+     * @return
+     */
+    public RespDTO<List<AMedicalRecordTypeDTO>> executeMRType(List<AMedicalRecordTypeVO> list) {
+        if(list!=null && list.size()>0){
+            //循环验证数据有效性
+            for (AMedicalRecordTypeVO medRecordType:list) {
+                if("".equals(medRecordType.getTypeId())) {
+                    return RespDTO.onError("请输入文书类型编码!");
+                }else if(medRecordType.getHospitalId()==null){
+                    return RespDTO.onError("请输入医院编码!");
+                }else if("".equals(medRecordType.getTypeName())){
+                    return RespDTO.onError("请文书类型名称!");
+                }
+            }
+            List<MedRecordType> medRecordTypeList=Lists.newArrayList();
+            List<AMedicalRecordTypeDTO> medRecordTypeDtoList=Lists.newArrayList();
+            medRecordTypeList=BeanUtil.listCopyTo(list,MedRecordType.class);
+            medRecordTypeDtoList=BeanUtil.listCopyTo(list,AMedicalRecordTypeDTO.class);
+            execute(medRecordTypeList);
+            return RespDTO.onSuc(medRecordTypeDtoList);
+        }else{
+            return RespDTO.onError("未接收到数据!");
+        }
+    }
+
+    public void execute(List<MedRecordType> medRecordTypeList){
+        try {
+            List<MedRecordType> addE = Lists.newLinkedList();
+            List<MedRecordType> updateE = Lists.newLinkedList();
+            if (medRecordTypeList != null && medRecordTypeList.size() != 0) {
+                medRecordTypeList.stream().forEach(s -> {
+                    MedRecordType mrType = this.getOne(new QueryWrapper<MedRecordType>()
+                            .eq("type_id", s.getTypeId())
+                            .eq("hospital_id", s.getHospitalId())
+                            .eq("is_deleted",IsDeleteEnum.N), false);
+                    if (mrType != null) {
+                        s.setGmtModified(new Date());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                });
+            }
+            if(addE.size()>0){
+                medRecordTypeService.saveBatch(addE);
+            }
+            if(updateE.size()>0){
+                medRecordTypeService.updateBatchByKey(updateE);
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("文书类别","", JSON.toJSONString(medRecordTypeList),"",e.getMessage());
+        }
+
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedicalRecordContentFacade.java

@@ -0,0 +1,125 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.AMedicalRecordContentDTO;
+import com.diagbot.entity.MedicalRecordContent;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.MedicalRecordContentServiceImpl;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.util.TZDBConn;
+import com.diagbot.vo.data.ADeleteFlagVO;
+import com.diagbot.vo.data.AMedicalRecordContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+
+@Component
+public class MedicalRecordContentFacade extends MedicalRecordContentServiceImpl{
+
+    @Qualifier("medicalRecordContentServiceImpl")
+    @Autowired
+    private MedicalRecordContentServiceImpl medicalRecordContentService;
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 终末质控-同步前一天的病历详细记录
+     */
+    public void executeMrRecordContent() {
+        //String sql="select * from mr_mrcontent  where cjcxrq>=dateadd(day,-2,getdate()) and cjcxrq<=getdate()";
+        String sql="select BLJLID,BLJLNR from mr_mrcontent  where cjcxrq>=(select CONVERT(varchar,GETDATE()-2,23)) and cjcxrq<(select CONVERT(varchar,GETDATE(),23)) ORDER BY cjcxrq DESC";
+        List<MedicalRecordContent> mrContentList = tzDBConn.getMedicalRecordContent(sql);
+        execute(mrContentList);
+    }
+
+    /**
+     * 数据引擎-通过接口更新病历内容
+     * @param list
+     * @return
+     */
+    public RespDTO<List<AMedicalRecordContentDTO>> executeMrRecordContent(List<AMedicalRecordContentVO> list) {
+        if(list!=null && list.size()>0) {
+            List<MedicalRecordContent> mrContentList=BeanUtil.listCopyTo(list,MedicalRecordContent.class);
+            List<AMedicalRecordContentDTO> mrContentDtoList=BeanUtil.listCopyTo(list,AMedicalRecordContentDTO.class);
+            execute(mrContentList);
+            return RespDTO.onSuc(mrContentDtoList);
+        }else{
+            return RespDTO.onError("未接收到数据!");
+        }
+    }
+
+    public void execute(List<MedicalRecordContent> mrContentList){
+        try {
+            List<MedicalRecordContent> addE = Lists.newLinkedList();
+            List<MedicalRecordContent> updateE = Lists.newLinkedList();
+            if (mrContentList != null && mrContentList.size() > 0) {
+                mrContentList.forEach(s -> {
+                    try {
+                    QueryWrapper<MedicalRecordContent> queryWrapper = new QueryWrapper<>();
+                    queryWrapper.eq("rec_id", s.getRecId());
+                    queryWrapper.eq("hospital_id", s.getHospitalId());
+                    MedicalRecordContent mrContent = this.getOne(queryWrapper, false);
+                    if (mrContent != null) {
+                        s.setGmtModified(new Date());
+                        s.setIsDeleted(IsDeleteEnum.N.getKey());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                    }catch (Exception e){
+                        log.error(e.getMessage(),e);
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("文书内容",s.getRecId(), JSON.toJSONString(mrContentList),"",e.getMessage());
+                    }
+                });
+            }
+            if(addE.size()>0){
+                medicalRecordContentService.saveBatch(addE);
+            }
+            if(updateE.size()>0){
+                medicalRecordContentService.updateBatchByKey(updateE);
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+        }
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO){
+        try {
+            //验证数据是否存在
+            if (StringUtil.isEmpty(aDeleteFlagVO.getRecId())) {
+                return RespDTO.onError("请输入文书序号!");
+            } else if (aDeleteFlagVO.getHospitalId() == null) {
+                return RespDTO.onError("请输入医院编码!");
+            }else {
+                UpdateWrapper<MedicalRecordContent> updateWrapper=new UpdateWrapper<>();
+                updateWrapper.eq("rec_id", aDeleteFlagVO.getRecId())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted",IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag=update(new MedicalRecordContent(),updateWrapper);
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("文书内容",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("文书内容",aDeleteFlagVO.getRecId(),JSON.toJSONString(aDeleteFlagVO),"",e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/data/MedicalRecordFacade.java

@@ -0,0 +1,500 @@
+package com.lantone.data.facade.data;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.diagbot.dto.AnalyzeRunDTO;
+import com.diagbot.dto.RecordContentDTO;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.AMedicalRecordDTO;
+import com.diagbot.entity.*;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.enums.ModeIdEnum;
+import com.diagbot.facade.*;
+import com.diagbot.service.impl.MedicalRecordServiceImpl;
+import com.diagbot.util.*;
+import com.diagbot.vo.AnalyzeRunVO;
+import com.diagbot.vo.MedrecVo;
+import com.diagbot.vo.QueryVo;
+import com.diagbot.vo.data.*;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+
+@Component
+public class MedicalRecordFacade extends MedicalRecordServiceImpl {
+
+    @Autowired
+    @Qualifier("medicalRecordServiceImpl")
+    private MedicalRecordServiceImpl medicalRecordService;
+
+    @Autowired
+    private ModelHospitalFacade modelHospitalFacade;
+
+    @Autowired
+    MedicalRecordFacade medicalRecordFacade;
+
+    @Autowired
+    private MedicalRecordContentFacade aMedicalRecordContentFacade;
+
+    @Autowired
+    private BehospitalInfoFacade behospitalInfoFacade;
+
+    @Autowired
+    private QcTypeFacade qcTypeFacade;
+
+    @Autowired
+    private com.diagbot.facade.data.ColumnFacade columnFacade;
+
+    @Autowired
+    private ReadProperties readProperties;
+
+    @Autowired
+    private BasHospitalInfoFacade basHospitalInfoFacade;
+
+    @Autowired
+    private MedAbnormalInfoFacade aMedAbnormalInfoFacade;
+
+    @Value("${encrypt.enable}")
+    Boolean encryptFlag;
+
+    @Value("${xml_analyse.enable}")
+    Boolean xmlAnalyseFlag;
+
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    private TZDBConn tzDBConn = new TZDBConn();
+
+    /**
+     * 终末质控-通过接口更新病历记录
+     *
+     * @param list
+     * @return
+     */
+    public RespDTO<List<AMedicalRecordDTO>> executeMrRecord(List<AMedicalRecordVO> list) {
+        if (list != null && list.size() > 0) {
+            //循环验证数据有效性
+            for (AMedicalRecordVO aMedicalRecordVO : list) {
+                if ("".equals(aMedicalRecordVO.getRecId())) {
+                    return RespDTO.onError("请输入文书序号!");
+                } else if (aMedicalRecordVO.getHospitalId() == null) {
+                    return RespDTO.onError("请输入医院编码!");
+                } else if ("".equals(aMedicalRecordVO.getBehospitalCode())) {
+                    return RespDTO.onError("请输入病人住院编码!");
+                }
+            }
+
+            //装载数据
+            List<MedicalRecord> medicalRecordList = Lists.newArrayList();
+            list.stream().forEach(s -> {
+                MedicalRecord medicalRecord = new MedicalRecord();
+                BeanUtil.copyProperties(s, medicalRecord);
+                medicalRecord.setRecDate(DateUtil.parseDateTime(s.getRecDate()));
+                medicalRecordList.add(medicalRecord);
+            });
+            execute(medicalRecordList);
+
+            List<AMedicalRecordDTO> medicalRecordDTOList = BeanUtil.listCopyTo(list, AMedicalRecordDTO.class);
+            return RespDTO.onSuc("操作成功!");
+        } else {
+            return RespDTO.onError("未接收到数据!");
+        }
+    }
+
+    public boolean hisDataDeal(HisDataDealVO hisDataDealVO) throws Exception {
+        QueryWrapper<MedicalRecord> medicalRecordQe = new QueryWrapper<>();
+        medicalRecordQe.eq("hospital_id", hisDataDealVO.getHospitalId());
+        medicalRecordQe.eq("mode_id", hisDataDealVO.getModeId());
+        medicalRecordQe.eq("is_deleted", IsDeleteEnum.N.getKey());
+        medicalRecordQe.orderByDesc("rec_date","rec_id");
+        if (hisDataDealVO.getRecIdList().size() > 0) {
+            medicalRecordQe.in("rec_id", hisDataDealVO.getRecIdList());
+        }
+        List<MedicalRecord> medicalRecordList = medicalRecordService.list(medicalRecordQe);
+            medicalRecordList.forEach(medicalRecord -> {
+                        QueryWrapper<MedicalRecordContent> medicalRecordContentQe = new QueryWrapper<>();
+                        medicalRecordContentQe.eq("hospital_id", hisDataDealVO.getHospitalId());
+                        medicalRecordContentQe.eq("rec_id", medicalRecord.getRecId());
+                        List<MedicalRecordContent> medicalRecordContentList = aMedicalRecordContentFacade.list(medicalRecordContentQe);
+
+                        if (ListUtil.isEmpty(medicalRecordContentList)) {
+                            return;
+                        }
+
+                        if (encryptFlag) {
+                            try {
+                                EncrypDES encrypDES = new EncrypDES();
+                                for (MedicalRecordContent mrj : medicalRecordContentList) {
+                                    mrj.setXmlText(encrypDES.decryptor(mrj.getXmlText()));
+                                }
+                            } catch (Exception e) {
+                                return;
+                            }
+                        }
+
+                        List<AMedicalRecordContentVO> contents = BeanUtil.listCopyTo(medicalRecordContentList, AMedicalRecordContentVO.class);
+                        AMedicalRecordVO aMedicalRecordVO = new AMedicalRecordVO();
+                        BeanUtil.copyProperties(medicalRecord, aMedicalRecordVO);
+                        aMedicalRecordVO.setContents(contents);
+                        List<AMedicalRecordVO> records = Lists.newArrayList();
+                        records.add(aMedicalRecordVO);
+                        AMrContentVO aMrContentVO = new AMrContentVO();
+                        aMrContentVO.setRecords(records);
+                        splicingParam(aMrContentVO);
+                    }
+            );
+        return true;
+    }
+
+
+    /**
+     * 特殊公共方法处理数据
+     *
+     * @param
+     */
+    public void specialDataWithKey(Boolean encryptFlag, List<RecordContentDTO> recordContentDTOS
+    ) {
+
+        if (encryptFlag) {
+            try {
+                EncrypDES encrypDES = new EncrypDES();
+                for (RecordContentDTO mrj : recordContentDTOS) {
+                    mrj.setXmlText(encrypDES.decryptor(mrj.getXmlText()));
+                }
+            } catch (Exception e) {
+                log.error(e.getMessage(), e);
+            }
+        }
+
+    }
+
+
+    /**
+     * 入参结构拼接-仅支持接口对接的方式
+     *
+     * @param aMrContentVO
+     */
+    public void splicingParam(AMrContentVO aMrContentVO) {
+
+            try {
+                QueryVo queryVo = new QueryVo();
+                List<MedrecVo> medreclist = Lists.newArrayList();
+
+                List<AColumnContentVO> content = Lists.newArrayList();
+                aMrContentVO.getRecords().stream().forEach(s -> {
+                    queryVo.setHospitalId(s.getHospitalId().toString());
+                    queryVo.setCid(basHospitalInfoFacade.getHosCode(s.getHospitalId()));
+                    Long modeId ;
+                    if (null == s.getModeId()) {
+                        modeId = initModeId(s.getHospitalId(), s.getRecTypeId());
+                    }else {
+                        modeId = s.getModeId();
+                    }
+                    s.getContents().stream().forEach(item -> {
+                        //拼接入参用于结构化解析
+                        AColumnContentVO aColumnContentVO = new AColumnContentVO();
+                        aColumnContentVO.setModeId(modeId);
+                        aColumnContentVO.setStandModelName(ModeIdEnum.getName(Integer.parseInt(modeId.toString())));
+                        aColumnContentVO.setRecId(s.getRecId());
+                        aColumnContentVO.setRecTypeId(s.getRecTypeId());
+                        aColumnContentVO.setRecTitle(s.getRecTitle());
+                        aColumnContentVO.setXmlText(item.getXmlText());
+                        aColumnContentVO.setBehospitalCode(s.getBehospitalCode());
+
+                        content.add(aColumnContentVO);
+                    });
+                    Map<String, Object> map = new HashMap<String, Object>();
+                    List<Map<String, Object>> returnData = new ArrayList<>();
+                    String keyNname = ModeIdEnum.getName(Integer.parseInt(modeId.toString()));
+                    Map<String, List<Map<String, Object>>> returnMap = new HashMap<>();
+                    for (AColumnContentVO aColumnContentVO : content) {
+                        try {
+                            Map<String, Object> objectMap = MapUtil.objectToMap(aColumnContentVO);
+                            returnData.add(objectMap);
+                            returnMap.put(keyNname, returnData);
+                        } catch (Exception e) {
+                            e.printStackTrace();
+                        }
+                    }
+
+                    map.put("content", returnData);
+                    MedrecVo medrecVo = new MedrecVo();
+                    medrecVo.setTitle(keyNname);
+                    medrecVo.setContent(map);
+                    medreclist.add(medrecVo);
+                });
+                queryVo.setMedrec(medreclist);
+
+                columnFacade.analyseRec(queryVo);
+            } catch (Exception e) {
+                log.error(e.getMessage(), e);
+                aMedAbnormalInfoFacade.saveAbnormalInfo("参数拼接", "", JSON.toJSONString(aMrContentVO), "", e.getMessage());
+            }
+        }
+
+
+    /**
+     * 运行质控-通过接口更新病历记录
+     *
+     * @param aMrContentVO
+     * @return
+     */
+    public RespDTO<Map<String, Object>> executeMrRecordIng(AMrContentVO aMrContentVO) {
+        if (aMrContentVO.getRecords() != null && aMrContentVO.getRecords().size() > 0) {
+            //循环验证数据有效性
+            for (AMedicalRecordVO aMedicalRecordVO : aMrContentVO.getRecords()) {
+                if ("".equals(aMedicalRecordVO.getRecId())) {
+                    return RespDTO.onError("请输入文书序号!");
+                } else if (aMedicalRecordVO.getHospitalId() == null) {
+                    return RespDTO.onError("请输入医院编码!");
+                } else if ("".equals(aMedicalRecordVO.getBehospitalCode())) {
+                    return RespDTO.onError("请输入病人住院编码!");
+                } else if ("".equals(aMedicalRecordVO.getRecTypeId())) {
+                    return RespDTO.onError("请输入病历类别编号!");
+                } else if ("".equals(aMedicalRecordVO.getRecTitle())) {
+                    return RespDTO.onError("请输入病历标题!");
+                } else if (aMedicalRecordVO.getContents() == null || aMedicalRecordVO.getContents().size() == 0) {
+                    return RespDTO.onError("请输入文书详情!");
+                }
+            }
+            //更新文书信息
+            executeMrRecord(aMrContentVO.getRecords());
+
+            aMrContentVO.getRecords().stream().forEach(s -> {
+                //更新文书详情
+                aMedicalRecordContentFacade.executeMrRecordContent(s.getContents());
+            });
+
+            //数据解析,评分规则等还未完整时不解析
+            if(xmlAnalyseFlag){
+                splicingParam(aMrContentVO);
+            }
+            //评分后返回结构体
+            return mrIng(aMrContentVO);
+
+        } else {
+            return RespDTO.onError("未接收到数据!");
+        }
+    }
+
+    /**
+     * 评分后返回结构体
+     *
+     * @param aMrContentVO
+     * @return
+     */
+    private RespDTO<Map<String, Object>> mrIng(AMrContentVO aMrContentVO) {
+        String behospitalCode = aMrContentVO.getRecords().get(0).getBehospitalCode();
+        Long hospitalId = aMrContentVO.getRecords().get(0).getHospitalId();
+        MedicalRecord medicalRecord = new MedicalRecord();
+        BeanUtil.copyProperties(aMrContentVO.getRecords().get(0), medicalRecord);
+        Long modeId = initModeId(medicalRecord.getHospitalId(),medicalRecord.getRecTypeId());
+        if (aMrContentVO.getDockModeType().equals("0")) {
+            Map<String, Object> map = new HashMap<String, Object>();
+            List<AMedicalRecordDTO> medicalRecordDTOList = BeanUtil.listCopyTo(aMrContentVO.getRecords(), AMedicalRecordDTO.class);
+            map.put("records", medicalRecordDTOList);
+            return RespDTO.onSuc("操作成功!");
+        } else if (aMrContentVO.getDockModeType().equals("1")) {
+            if (modeId == 0 || modeId == null) {
+                return RespDTO.onError("无对应的文书类型");
+            }
+            //页面模式
+            String url = readProperties.getProcessQcUrl() + "?behospitalCode=" + behospitalCode + "&hospitalId=" + hospitalId + "&modeId=" + modeId;
+            Map<String, Object> map = new HashMap<String, Object>();
+            map.put("url", url);
+            return RespDTO.onSuc(map);
+        } else if (aMrContentVO.getDockModeType().equals("2")) {
+            AnalyzeRunVO analyzeRunVO = new AnalyzeRunVO();
+            analyzeRunVO.setBehospitalCode(behospitalCode);
+            analyzeRunVO.setHospitalId(hospitalId);
+            analyzeRunVO.setModeId(modeId);
+            AnalyzeRunDTO analyzeRunDTO = behospitalInfoFacade.analyzeRun(analyzeRunVO);
+            Map<String, Object> map = new HashMap<String, Object>();
+            if (analyzeRunDTO.getMsgDTOList().size() > 0) {
+                map.put("analyze", analyzeRunDTO.getMsgDTOList());
+            }
+            //接口引擎模式
+            return RespDTO.onSuc(map);
+        } else {
+            if (modeId == 0 || modeId == null) {
+                return RespDTO.onError("无对应的文书类型");
+            }
+            //页面模式
+            String url = readProperties.getProcessQcUrl() + "?behospitalCode=" + behospitalCode + "&hospitalId=" + hospitalId + "&modeId=" + modeId;
+
+            AnalyzeRunVO analyzeRunVO = new AnalyzeRunVO();
+            analyzeRunVO.setBehospitalCode(behospitalCode);
+            analyzeRunVO.setHospitalId(hospitalId);
+            analyzeRunVO.setModeId(modeId);
+            AnalyzeRunDTO analyzeRunDTO = behospitalInfoFacade.analyzeRun(analyzeRunVO);
+            Map<String, Object> map = new HashMap<String, Object>();
+            if (analyzeRunDTO.getMsgDTOList().size() > 0) {
+                map.put("url", url);
+                map.put("analyze", analyzeRunDTO.getMsgDTOList());
+            }
+            return RespDTO.onSuc(map);
+        }
+    }
+
+    public void execute(List<MedicalRecord> medicalRecordList) {
+        try {
+            List<MedicalRecord> addE = Lists.newLinkedList();
+            List<MedicalRecord> updateE = Lists.newLinkedList();
+            List<BehospitalInfo> behospitalInfoList = Lists.newLinkedList();
+            List<ModelHospital> modelHospitalList = Lists.newLinkedList();
+            if (medicalRecordList != null && medicalRecordList.size() > 0) {
+                medicalRecordList.stream().forEach(s -> {
+                    //初始化mode_id
+                    Long modeId = initModeId(s.getHospitalId(),s.getRecTypeId());
+                    if (modeId == Long.valueOf("0")) {
+                        //未匹配到模板的进行记录，后续可跟进
+                        ModelHospital modelHospital = new ModelHospital();
+                        modelHospital.setHospitalId(s.getHospitalId());
+                        modelHospital.setHospitalModelName(s.getRecTitle());
+                        modelHospital.setRemark(s.getRecTypeId());
+                        modelHospitalList.add(modelHospital);
+                    } else if (modeId == Long.valueOf("1")) {
+                        //入院记录保存时，同步调整住院病人的质控类型，即qc_type_id
+                        BehospitalInfo behospitalInfo = behospitalInfoFacade.getOne(new QueryWrapper<BehospitalInfo>()
+                                .eq("behospital_code", s.getBehospitalCode())
+                                .eq("hospital_id", s.getHospitalId()), false);
+                        if (behospitalInfo != null) {
+                            //如果病人住院信息存在，更新对应的qc_type_id
+                            Long qcTypeId = initQcTypeId(behospitalInfo);
+                            behospitalInfo.setQcTypeId(qcTypeId);
+                            behospitalInfoList.add(behospitalInfo);
+                        }
+                    }
+                    s.setModeId(modeId);
+                    //新增或修改
+                    MedicalRecord mRecord = this.getOne(new QueryWrapper<MedicalRecord>()
+                            .eq("rec_id", s.getRecId())
+                            .eq("hospital_id", s.getHospitalId())
+                            .eq("behospital_code", s.getBehospitalCode()), false);
+                    if (mRecord != null) {
+                        s.setGmtModified(new Date());
+                        s.setIsDeleted(IsDeleteEnum.N.getKey());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                });
+            }
+            if (addE.size() > 0) {
+                medicalRecordService.saveBatch(addE);
+            }
+            if (updateE.size() > 0) {
+                medicalRecordService.updateBatchByKey(updateE);
+            }
+            if (modelHospitalList.size() > 0) {
+                modelHospitalFacade.saveBatch(modelHospitalList);
+            }
+            if (behospitalInfoList.size() > 0) {
+                behospitalInfoFacade.updateBatchByKey(behospitalInfoList);
+            }
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("文书信息", "", JSON.toJSONString(medicalRecordList), "", e.getMessage());
+        }
+
+    }
+
+    /**
+     * 初始化质控类型ID
+     *
+     * @param s
+     * @return
+     */
+    private Long initQcTypeId(BehospitalInfo s) {
+        Long qcTypeId = Long.valueOf("0");
+        //根据科室查找对应质控类型
+        QcType qcTypeList = qcTypeFacade.getOne(new QueryWrapper<QcType>()
+                .eq("beh_dept_id", s.getBehDeptId())
+                .eq("hospital_id", s.getHospitalId())
+                .eq("default_module", 0)
+                .eq("sex",s.getSex())
+                .eq("is_deleted", IsDeleteEnum.N));
+        if(qcTypeList == null){
+            //无质控类型时，新增后初始化
+            QcType qcType = qcTypeFacade.getOne(new QueryWrapper<QcType>()
+                    .eq("default_module", 1)
+                    .eq("hospital_id", s.getHospitalId())
+                    .eq("sex",s.getSex())
+                    .eq("is_deleted", IsDeleteEnum.N));
+            if(qcType!=null){
+                qcTypeId = qcType.getId();
+            }
+        }else {
+            qcTypeId = qcTypeList.getId();
+        }
+        return qcTypeId;
+    }
+
+    /**
+     * 初始化模型ID
+     *
+     * @param hospitalId
+     * @param recTypeId
+     * @return
+     */
+    private Long initModeId(Long hospitalId, String recTypeId) {
+        Long modeId = Long.valueOf("0");
+        QueryWrapper<ModelHospital> wrapper = new QueryWrapper<>();
+        wrapper.eq("hospital_id", hospitalId);
+        //wrapper.eq("hospital_model_name", recTitle);
+        wrapper.eq("remark", recTypeId);
+        ModelHospital mode = modelHospitalFacade.getOne(wrapper, false);
+        if (mode != null) {
+            modeId = mode.getStandModelId();
+        } else {
+            modeId = Long.valueOf("0");
+        }
+        return modeId;
+    }
+
+    public RespDTO deleteFlag(ADeleteFlagVO aDeleteFlagVO) {
+        try {
+            //验证数据是否存在
+            if (StringUtil.isEmpty(aDeleteFlagVO.getRecId())) {
+                return RespDTO.onError("请输入文书序号!");
+            } else if (aDeleteFlagVO.getHospitalId() == null) {
+                return RespDTO.onError("请输入医院编码!");
+            } else if (StringUtil.isEmpty(aDeleteFlagVO.getBehospitalCode())) {
+                return RespDTO.onError("请输入病人住院编码!");
+            } else {
+                UpdateWrapper<MedicalRecord> updateWrapper = new UpdateWrapper<>();
+                updateWrapper.eq("rec_id", aDeleteFlagVO.getRecId())
+                        .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                        .eq("behospital_code", aDeleteFlagVO.getBehospitalCode())
+                        .eq("is_deleted", IsDeleteEnum.N)
+                        .set("is_deleted", IsDeleteEnum.Y)
+                        .set("gmt_modified", DateUtil.now());
+
+                Boolean flag = update(new MedicalRecord(), updateWrapper);
+                if (flag) {
+                    UpdateWrapper<MedicalRecordContent> updateWrapperContent = new UpdateWrapper<>();
+                    updateWrapperContent.eq("rec_id", aDeleteFlagVO.getRecId())
+                            .eq("hospital_id", aDeleteFlagVO.getHospitalId())
+                            .eq("is_deleted", IsDeleteEnum.N)
+                            .set("is_deleted", IsDeleteEnum.Y)
+                            .set("gmt_modified", DateUtil.now());
+
+                    Boolean flagContent = aMedicalRecordContentFacade.update(new MedicalRecordContent(), updateWrapperContent);
+                    //aMedAbnormalInfoFacade.saveAbnormalInfo("文书内容-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flagContent)),"操作成功!");
+                }
+                //aMedAbnormalInfoFacade.saveAbnormalInfo("文书信息-删除",JSON.toJSONString(aDeleteFlagVO),JSON.toJSONString(RespDTO.onSuc(flag)),"操作成功!");
+                return RespDTO.onSuc(flag);
+            }
+        } catch (Exception e) {
+            aMedAbnormalInfoFacade.saveAbnormalInfo("文书-删除", "", JSON.toJSONString(aDeleteFlagVO), "", e.getMessage());
+            return RespDTO.onError(e.getMessage());
+        }
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrAdmissionNoteFacade.java

@@ -0,0 +1,231 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrAdmissionNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrAdmissionNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrAdmissionNoteVO;
+import com.diagbot.vo.str.StrAdmissionNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrAdmissionNoteFacade extends StrAdmissionNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strAdmissionNoteServiceImpl")
+    private StrAdmissionNoteServiceImpl strAdmissionNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh() {
+        List<ColumnZhAndChDTO> list = this.baseMapper.getColumnZhAndCh();
+        list.forEach(s -> {
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap = EntityUtil.makeMapWithKeyValue(list, "ch", "en");
+        Boolean flag = columnFacade.createColumn(columnMap, "strAdmissionNote");
+
+        //Map<String, String> map=columnFacade.getColumn("strAdmissionNote");
+        if (!flag) {
+            return;
+        }
+    }
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrAdmissionNote strAdmissionNote = new StrAdmissionNote();
+        strAdmissionNote.setRecId(strContentVO.getRecId());
+        strAdmissionNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strAdmissionNote.setHospitalId(strContentVO.getHospitalId());
+        strAdmissionNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strAdmissionNote)) {
+            strAdmissionNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strAdmissionNote);
+        } else {
+            strAdmissionNote.setGmtModified(new Date());//记录修改时间
+            this.update(strAdmissionNote, new QueryWrapper<StrAdmissionNote>()
+                    .eq("rec_id", strAdmissionNote.getRecId())
+                    .eq("hospital_id", strAdmissionNote.getHospitalId())
+                    .eq("behospital_code", strAdmissionNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap, Map<String, Object> entityMap, Long hospitalId) throws Exception {
+        StrAdmissionNote strAdmissionNote = new StrAdmissionNote();
+        AStrAdmissionNoteVO strAdmissionNoteVO = (AStrAdmissionNoteVO) MapUtil.mapToObject(entityMap, AStrAdmissionNoteVO.class);
+        BeanUtils.copyProperties(strAdmissionNoteVO, strAdmissionNote);
+        strAdmissionNote.setHospitalId(hospitalId);//医院编码
+
+        strAdmissionNote.setAuditDate(DateUtil.parseDateTime(strAdmissionNoteVO.getAuditDate()));//审核时间
+        strAdmissionNote.setRecDate(DateUtil.parseDateTime(strAdmissionNoteVO.getRecDate()));//记录时间
+        strAdmissionNote.setBehospitalDate(DateUtil.parseDateTime(strAdmissionNoteVO.getBehospitalDate()));//入院日期
+        strAdmissionNote.setBirthday(DateUtil.parseDate(strAdmissionNoteVO.getBirthday()));//出生日期
+        strAdmissionNote.setRecordDate(DateUtil.parseDateTime(strAdmissionNoteVO.getRecordDate()));//病历日期
+
+        strAdmissionNote.setWholeData(columnMap);
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strAdmissionNote)) {
+            strAdmissionNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strAdmissionNote);
+        } else {
+            strAdmissionNote.setGmtModified(new Date());//记录修改时间
+            this.update(strAdmissionNote, new QueryWrapper<StrAdmissionNote>()
+                    .eq("rec_id", strAdmissionNote.getRecId())
+                    .eq("hospital_id", strAdmissionNote.getHospitalId())
+                    .eq("behospital_code", strAdmissionNote.getBehospitalCode()));
+        }
+    }
+
+    public Boolean isExist(StrAdmissionNote strAdmissionNote) {
+        Boolean flag = true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrAdmissionNote>()
+                .eq("rec_id", strAdmissionNote.getRecId())
+                .eq("hospital_id", strAdmissionNote.getHospitalId())
+                .eq("behospital_code", strAdmissionNote.getBehospitalCode()));
+        if (count > 0) {
+            flag = false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:入院记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrAdmissionNoteVO> list) {
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrAdmissionNoteVO strAdmissionNoteVO:list) {
+                    if("".equals(strAdmissionNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strAdmissionNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strAdmissionNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrAdmissionNote> strAdmissionNoteList=initData(list);
+                execute(strAdmissionNoteList);
+
+                if(logSwitch){
+                    strAdmissionNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-入院记录-正常", s.getRecId(), JSON.toJSONString(list), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-入院记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+
+    }
+
+    /**
+     * @Description:入库前，初始化数据库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    private List<StrAdmissionNote> initData(List<StrAdmissionNoteVO> list) throws Exception{
+        List<StrAdmissionNote> strAdmissionNoteList=Lists.newArrayList();
+        for (StrAdmissionNoteVO s:list) {
+            StrAdmissionNote t=new StrAdmissionNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getBirthday())){
+                t.setBirthday(DateUtil.parseDate(s.getBirthday()));//出生日期
+            }
+            if(StringUtil.isNotEmpty(s.getBehospitalDate())){
+                t.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));//入院日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.BEHOSPITAL_INFO.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            t.setWholeData(JSON.toJSONString(wholeMap));
+            strAdmissionNoteList.add(t);
+        }
+        return strAdmissionNoteList;
+    }
+
+    public void execute(List<StrAdmissionNote> list) throws Exception{
+        List<StrAdmissionNote> addE = Lists.newLinkedList();
+        List<StrAdmissionNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.forEach(s -> {
+                StrAdmissionNote strAdmissionNote = this.getOne(new QueryWrapper<StrAdmissionNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strAdmissionNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strAdmissionNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrBloodResultFacade.java

@@ -0,0 +1,230 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrBloodResult;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrBloodResultServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrBloodResultVO;
+import com.diagbot.vo.str.StrBloodResultVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:输血后效果评价-业务类
+ * @Author:liuqq
+ * @time: ${DATE} ${TIME}
+ **/
+@Component
+public class StrBloodResultFacade extends StrBloodResultServiceImpl {
+
+    @Autowired
+    @Qualifier("strBloodResultServiceImpl")
+    private StrBloodResultServiceImpl strBloodResultService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strBloodResult");
+        if(!flag){
+            return;
+        }
+        //Map<String, String> map=columnFacade.getColumn("strBloodResult");
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrBloodResult strBloodResult=new StrBloodResult();
+        strBloodResult.setRecId(strContentVO.getRecId());
+        strBloodResult.setBehospitalCode(strContentVO.getBehospitalCode());
+        strBloodResult.setHospitalId(strContentVO.getHospitalId());
+        strBloodResult.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strBloodResult)) {
+            strBloodResult.setGmtCreate(new Date());//记录创建时间
+            this.save(strBloodResult);
+        } else {
+            strBloodResult.setGmtModified(new Date());//记录修改时间
+            this.update(strBloodResult, new QueryWrapper<StrBloodResult>()
+                    .eq("rec_id", strBloodResult.getRecId())
+                    .eq("hospital_id", strBloodResult.getHospitalId())
+                    .eq("behospital_code", strBloodResult.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrBloodResult strBloodResult=new StrBloodResult();
+        try {
+            AStrBloodResultVO strBloodResultVO=(AStrBloodResultVO) MapUtil.mapToObject(entityMap, AStrBloodResultVO.class);
+            BeanUtils.copyProperties(strBloodResultVO,strBloodResult);
+            strBloodResult.setHospitalId(hospitalId);//医院编码
+            strBloodResult.setAuditDate(DateUtil.parseDateTime(strBloodResultVO.getAuditDate()));//审核时间
+            strBloodResult.setRecDate(DateUtil.parseDateTime(strBloodResultVO.getRecDate()));//记录时间
+            strBloodResult.setRecordDate(DateUtil.parseDateTime(strBloodResultVO.getRecordDate()));//病历日期
+
+            strBloodResult.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strBloodResult)){
+                strBloodResult.setGmtCreate(new Date());//记录创建时间
+                this.save(strBloodResult);
+            }else{
+                strBloodResult.setGmtModified(new Date());//记录修改时间
+                this.update(strBloodResult,new QueryWrapper<StrBloodResult>()
+                        .eq("rec_id", strBloodResult.getRecId())
+                        .eq("hospital_id", strBloodResult.getHospitalId())
+                        .eq("behospital_code", strBloodResult.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("输血效果评价",strBloodResult.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    /**
+     * @Description: 是否存在
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public Boolean isExist(StrBloodResult strBloodResult){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrBloodResult>()
+                .eq("rec_id", strBloodResult.getRecId())
+                .eq("hospital_id", strBloodResult.getHospitalId())
+                .eq("behospital_code", strBloodResult.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:输血后效果评价-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrBloodResultVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrBloodResultVO strBloodResultVO:list) {
+                    if("".equals(strBloodResultVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strBloodResultVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strBloodResultVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrBloodResult> strBloodResultList= initData(list);
+                execute(strBloodResultList);
+
+                if(logSwitch){
+                    strBloodResultList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-输血后效果评价-正常", s.getRecId(), JSON.toJSONString(list), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-输血后效果评价-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrBloodResult> initData(List<StrBloodResultVO> list) throws Exception{
+        List<StrBloodResult> tList=Lists.newArrayList();
+        for (StrBloodResultVO s:list) {
+            StrBloodResult t=new StrBloodResult();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.BLOOD_RESULT.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrBloodResult> list) throws Exception{
+        List<StrBloodResult> addE = Lists.newLinkedList();
+        List<StrBloodResult> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrBloodResult strBloodResult = this.getOne(new QueryWrapper<StrBloodResult>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strBloodResult != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strBloodResultService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrBloodTransfusionFacade.java

@@ -0,0 +1,241 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrBloodTransfusion;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrBloodTransfusionServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrBloodTransfusionVO;
+import com.diagbot.vo.str.StrBloodTransfusionVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:输血/血制品病程记录-业务类
+ * @Author:liuqq
+ * @time: ${DATE} ${TIME}
+ **/
+@Component
+public class StrBloodTransfusionFacade extends StrBloodTransfusionServiceImpl {
+
+    @Autowired
+    @Qualifier("strBloodTransfusionServiceImpl")
+    private StrBloodTransfusionServiceImpl strBloodTransfusionService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strBloodTransfusion");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrBloodTransfusion strBloodTransfusion=new StrBloodTransfusion();
+        strBloodTransfusion.setRecId(strContentVO.getRecId());
+        strBloodTransfusion.setBehospitalCode(strContentVO.getBehospitalCode());
+        strBloodTransfusion.setHospitalId(strContentVO.getHospitalId());
+        strBloodTransfusion.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strBloodTransfusion)) {
+            strBloodTransfusion.setGmtCreate(new Date());//记录创建时间
+            this.save(strBloodTransfusion);
+        } else {
+            strBloodTransfusion.setGmtModified(new Date());//记录修改时间
+            this.update(strBloodTransfusion, new QueryWrapper<StrBloodTransfusion>()
+                    .eq("rec_id", strBloodTransfusion.getRecId())
+                    .eq("hospital_id", strBloodTransfusion.getHospitalId())
+                    .eq("behospital_code", strBloodTransfusion.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrBloodTransfusion strBloodTransfusion=new StrBloodTransfusion();
+        try {
+            AStrBloodTransfusionVO strBloodTransfusionVO=(AStrBloodTransfusionVO) MapUtil.mapToObject(entityMap, AStrBloodTransfusionVO.class);
+            BeanUtils.copyProperties(strBloodTransfusionVO,strBloodTransfusion);
+            strBloodTransfusion.setHospitalId(hospitalId);//医院编码
+            strBloodTransfusion.setStartTime(DateUtil.parseDateTime(strBloodTransfusionVO.getStartTime()));
+            strBloodTransfusion.setEndTime(DateUtil.parseDateTime(strBloodTransfusionVO.getEndTime()));
+            strBloodTransfusion.setAuditDate(DateUtil.parseDateTime(strBloodTransfusionVO.getAuditDate()));//审核时间
+            strBloodTransfusion.setRecDate(DateUtil.parseDateTime(strBloodTransfusionVO.getRecDate()));//记录时间
+            strBloodTransfusion.setRecordDate(DateUtil.parseDateTime(strBloodTransfusionVO.getRecordDate()));//病历日期
+
+            strBloodTransfusion.setWholeData(columnMap);
+
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strBloodTransfusion)){
+                strBloodTransfusion.setGmtCreate(new Date());//记录创建时间
+                this.save(strBloodTransfusion);
+            }else{
+                strBloodTransfusion.setGmtModified(new Date());//记录修改时间
+                this.update(strBloodTransfusion,new QueryWrapper<StrBloodTransfusion>()
+                        .eq("rec_id", strBloodTransfusion.getRecId())
+                        .eq("hospital_id", strBloodTransfusion.getHospitalId())
+                        .eq("behospital_code", strBloodTransfusion.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("输血记录", strBloodTransfusion.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrBloodTransfusion strBloodTransfusion){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrBloodTransfusion>()
+                .eq("rec_id", strBloodTransfusion.getRecId())
+                .eq("hospital_id", strBloodTransfusion.getHospitalId())
+                .eq("behospital_code", strBloodTransfusion.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:输血/血制品病程记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrBloodTransfusionVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrBloodTransfusionVO strBloodTransfusionVO:list) {
+                    if("".equals(strBloodTransfusionVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strBloodTransfusionVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strBloodTransfusionVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrBloodTransfusion> strBloodTransfusionList= initData(list);
+                execute(strBloodTransfusionList);
+
+                if(logSwitch){
+                    strBloodTransfusionList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-输血/血制品病程记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-输血/血制品病程记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrBloodTransfusion> initData(List<StrBloodTransfusionVO> list) throws Exception{
+        List<StrBloodTransfusion> tList=Lists.newArrayList();
+        for (StrBloodTransfusionVO s:list) {
+            StrBloodTransfusion t=new StrBloodTransfusion();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getStartTime())){
+                t.setStartTime(DateUtil.parseDateTime(s.getStartTime()));//开始日期
+            }
+            if(StringUtil.isNotEmpty(s.getEndTime())){
+                t.setEndTime(DateUtil.parseDateTime(s.getEndTime()));//结束日期
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.BLOOD_TRANSFUSION.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrBloodTransfusion> list){
+        try {
+            List<StrBloodTransfusion> addE = Lists.newLinkedList();
+            List<StrBloodTransfusion> updateE = Lists.newLinkedList();
+            if (list != null && list.size() > 0) {
+                list.stream().forEach(s -> {
+                    StrBloodTransfusion strBloodTransfusion = this.getOne(new QueryWrapper<StrBloodTransfusion>()
+                            .eq("is_deleted", IsDeleteEnum.N.getKey())
+                            .eq("rec_id", s.getRecId())
+                            .eq("hospital_id", s.getHospitalId())
+                            .eq("behospital_code",s.getBehospitalCode()), false);
+                    if (strBloodTransfusion != null) {
+                        s.setGmtModified(new Date());
+                        updateE.add(s);
+                    } else {
+                        s.setGmtCreate(new Date());
+                        addE.add(s);
+                    }
+                });
+            }
+            if(addE.size()>0){
+                strBloodTransfusionService.saveBatch(addE);
+            }
+            if(updateE.size()>0){
+                this.baseMapper.updateBatchByKey(updateE);
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-入院记录","", JSON.toJSONString(list),"",e.getMessage());
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrConsultationApplyFacade.java

@@ -0,0 +1,235 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrConsultationApply;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrConsultationApplyServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrConsultationApplyVO;
+import com.diagbot.vo.str.StrConsultationApplyVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrConsultationApplyFacade extends StrConsultationApplyServiceImpl {
+
+    @Autowired
+    @Qualifier("strConsultationApplyServiceImpl")
+    private StrConsultationApplyServiceImpl strConsultationApplyService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strConsultationApply");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrConsultationApply strConsultationApply=new StrConsultationApply();
+        strConsultationApply.setRecId(strContentVO.getRecId());
+        strConsultationApply.setBehospitalCode(strContentVO.getBehospitalCode());
+        strConsultationApply.setHospitalId(strContentVO.getHospitalId());
+        strConsultationApply.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strConsultationApply)) {
+            strConsultationApply.setGmtCreate(new Date());//记录创建时间
+            this.save(strConsultationApply);
+        } else {
+            strConsultationApply.setGmtModified(new Date());//记录修改时间
+            this.update(strConsultationApply, new QueryWrapper<StrConsultationApply>()
+                    .eq("rec_id", strConsultationApply.getRecId())
+                    .eq("hospital_id", strConsultationApply.getHospitalId())
+                    .eq("behospital_code", strConsultationApply.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrConsultationApply strConsultationApply=new StrConsultationApply();
+        try {
+            AStrConsultationApplyVO strConsultationApplyVO=(AStrConsultationApplyVO) MapUtil.mapToObject(entityMap, AStrConsultationApplyVO.class);
+            BeanUtils.copyProperties(strConsultationApplyVO,strConsultationApply);
+            strConsultationApply.setHospitalId(hospitalId);//医院编码
+
+            strConsultationApply.setAuditDate(DateUtil.parseDateTime(strConsultationApplyVO.getAuditDate()));//审核时间
+            strConsultationApply.setRecDate(DateUtil.parseDateTime(strConsultationApplyVO.getRecDate()));//记录时间
+            strConsultationApply.setBehospitalDate(DateUtil.parseDateTime(strConsultationApplyVO.getBehospitalDate()));//入院日期
+            strConsultationApply.setRecordDate(DateUtil.parseDateTime(strConsultationApplyVO.getRecordDate()));//病历日期
+            strConsultationApply.setApplyDate(DateUtil.parseDateTime(strConsultationApplyVO.getApplyDate()));//申请日期
+            strConsultationApply.setConsultationDate(DateUtil.parseDateTime(strConsultationApplyVO.getConsultationDate()));//会诊时间
+            strConsultationApply.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strConsultationApply)){
+                strConsultationApply.setGmtCreate(new Date());//记录创建时间
+                this.save(strConsultationApply);
+            }else{
+                strConsultationApply.setGmtModified(new Date());//记录修改时间
+                this.update(strConsultationApply,new QueryWrapper<StrConsultationApply>()
+                        .eq("rec_id", strConsultationApply.getRecId())
+                        .eq("hospital_id", strConsultationApply.getHospitalId())
+                        .eq("behospital_code", strConsultationApply.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("会诊申请单",strConsultationApply.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrConsultationApply strConsultationApply){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrConsultationApply>()
+                .eq("rec_id", strConsultationApply.getRecId())
+                .eq("hospital_id", strConsultationApply.getHospitalId())
+                .eq("behospital_code", strConsultationApply.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:会诊申请单-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrConsultationApplyVO> list){
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrConsultationApplyVO strConsultationApplyVO:list) {
+                    if("".equals(strConsultationApplyVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strConsultationApplyVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strConsultationApplyVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrConsultationApply> strConsultationApplyList= initData(list);
+                execute(strConsultationApplyList);
+
+                if(logSwitch){
+                    strConsultationApplyList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊申请单-正常", s.getRecId(), JSON.toJSONString(list), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊申请单-异常", s.getRecId(), JSON.toJSONString(s), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrConsultationApply> initData(List<StrConsultationApplyVO> list) throws Exception{
+        List<StrConsultationApply> tList=Lists.newArrayList();
+        for (StrConsultationApplyVO s:list) {
+            StrConsultationApply t=new StrConsultationApply();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getBehospitalDate())){
+                t.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));//入院日期
+            }
+            if(StringUtil.isNotEmpty(s.getApplyDate())){
+                t.setApplyDate(DateUtil.parseDateTime(s.getApplyDate()));//申请日期
+            }
+            if(StringUtil.isNotEmpty(s.getConsultationDate())){
+                t.setConsultationDate(DateUtil.parseDateTime(s.getConsultationDate()));//会诊时间
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.CONSULTATION_APPLY.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrConsultationApply> list) throws Exception{
+        List<StrConsultationApply> addE = Lists.newLinkedList();
+        List<StrConsultationApply> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrConsultationApply strConsultationApply = this.getOne(new QueryWrapper<StrConsultationApply>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strConsultationApply != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strConsultationApplyService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrConsultationNoteFacade.java

@@ -0,0 +1,236 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrConsultationNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrConsultationNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrConsultationNoteVO;
+import com.diagbot.vo.str.StrConsultationNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrConsultationNoteFacade extends StrConsultationNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strConsultationNoteServiceImpl")
+    private StrConsultationNoteServiceImpl strConsultationNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap=EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strConsultationNote");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrConsultationNote strConsultationNote=new StrConsultationNote();
+        strConsultationNote.setRecId(strContentVO.getRecId());
+        strConsultationNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strConsultationNote.setHospitalId(strContentVO.getHospitalId());
+        strConsultationNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strConsultationNote)) {
+            strConsultationNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strConsultationNote);
+        } else {
+            strConsultationNote.setGmtModified(new Date());//记录修改时间
+            this.update(strConsultationNote, new QueryWrapper<StrConsultationNote>()
+                    .eq("rec_id", strConsultationNote.getRecId())
+                    .eq("hospital_id", strConsultationNote.getHospitalId())
+                    .eq("behospital_code", strConsultationNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrConsultationNote strConsultationNote=new StrConsultationNote();
+        try {
+            AStrConsultationNoteVO strConsultationNoteVO=(AStrConsultationNoteVO) MapUtil.mapToObject(entityMap, AStrConsultationNoteVO.class);
+            BeanUtils.copyProperties(strConsultationNoteVO,strConsultationNote);
+            strConsultationNote.setHospitalId(hospitalId);//医院编码
+
+            strConsultationNote.setAuditDate(DateUtil.parseDateTime(strConsultationNoteVO.getAuditDate()));//审核时间
+            strConsultationNote.setRecDate(DateUtil.parseDateTime(strConsultationNoteVO.getRecDate()));//记录时间
+            strConsultationNote.setBehospitalDate(DateUtil.parseDateTime(strConsultationNoteVO.getBehospitalDate()));//入院日期
+            strConsultationNote.setApplyDate(DateUtil.parseDate(strConsultationNoteVO.getApplyDate()));//申请日期
+            strConsultationNote.setRecordDate(DateUtil.parseDateTime(strConsultationNoteVO.getRecordDate()));//病历日期
+            strConsultationNote.setConsultationDate(DateUtil.parseDateTime(strConsultationNoteVO.getConsultationDate()));//会诊时间
+
+            strConsultationNote.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strConsultationNote)){
+                strConsultationNote.setGmtCreate(new Date());//记录创建时间
+                this.save(strConsultationNote);
+            }else{
+                strConsultationNote.setGmtModified(new Date());//记录修改时间
+                this.update(strConsultationNote,new QueryWrapper<StrConsultationNote>()
+                        .eq("rec_id", strConsultationNote.getRecId())
+                        .eq("hospital_id", strConsultationNote.getHospitalId())
+                        .eq("behospital_code", strConsultationNote.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("会诊单（申请和结果）",strConsultationNote.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrConsultationNote strConsultationNote){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrConsultationNote>()
+                .eq("rec_id", strConsultationNote.getRecId())
+                .eq("hospital_id", strConsultationNote.getHospitalId())
+                .eq("behospital_code", strConsultationNote.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:会诊单（申请和结果）-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrConsultationNoteVO> list){
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrConsultationNoteVO strConsultationNoteVO:list) {
+                    if("".equals(strConsultationNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strConsultationNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strConsultationNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrConsultationNote> strConsultationNoteList= initData(list);
+                execute(strConsultationNoteList);
+
+                if(logSwitch){
+                    strConsultationNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊单（申请和结果）-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+            list.forEach(s->{
+            aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊单（申请和结果）-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+            });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrConsultationNote> initData(List<StrConsultationNoteVO> list) throws Exception{
+        List<StrConsultationNote> tList=Lists.newArrayList();
+        for (StrConsultationNoteVO s:list) {
+            StrConsultationNote t=new StrConsultationNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getBehospitalDate())){
+                t.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));//入院日期
+            }
+            if(StringUtil.isNotEmpty(s.getApplyDate())){
+                t.setApplyDate(DateUtil.parseDateTime(s.getApplyDate()));//申请日期
+            }
+            if(StringUtil.isNotEmpty(s.getConsultationDate())){
+                t.setConsultationDate(DateUtil.parseDateTime(s.getConsultationDate()));//会诊时间
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.CONSULTATION_NOTE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrConsultationNote> list) throws Exception{
+        List<StrConsultationNote> addE = Lists.newLinkedList();
+        List<StrConsultationNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrConsultationNote strConsultationNote = this.getOne(new QueryWrapper<StrConsultationNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strConsultationNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strConsultationNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrConsultationRecordFacade.java

@@ -0,0 +1,235 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrConsultationRecord;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrConsultationRecordServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.AStrConsultationRecordVO;
+import com.diagbot.vo.str.StrConsultationRecordVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrConsultationRecordFacade extends StrConsultationRecordServiceImpl {
+
+    @Autowired
+    @Qualifier("strConsultationRecordServiceImpl")
+    private StrConsultationRecordServiceImpl strConsultationRecordService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strConsultationRecord");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationRecord");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrConsultationRecord strConsultationRecord=new StrConsultationRecord();
+        strConsultationRecord.setRecId(strContentVO.getRecId());
+        strConsultationRecord.setBehospitalCode(strContentVO.getBehospitalCode());
+        strConsultationRecord.setHospitalId(strContentVO.getHospitalId());
+        strConsultationRecord.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strConsultationRecord)) {
+            strConsultationRecord.setGmtCreate(new Date());//记录创建时间
+            this.save(strConsultationRecord);
+        } else {
+            strConsultationRecord.setGmtModified(new Date());//记录修改时间
+            this.update(strConsultationRecord, new QueryWrapper<StrConsultationRecord>()
+                    .eq("rec_id", strConsultationRecord.getRecId())
+                    .eq("hospital_id", strConsultationRecord.getHospitalId())
+                    .eq("behospital_code", strConsultationRecord.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrConsultationRecord strConsultationRecord=new StrConsultationRecord();
+        try {
+            AStrConsultationRecordVO AStrConsultationRecordVO=(AStrConsultationRecordVO) MapUtil.mapToObject(entityMap, AStrConsultationRecordVO.class);
+            BeanUtils.copyProperties(AStrConsultationRecordVO,strConsultationRecord);
+            strConsultationRecord.setHospitalId(hospitalId);//医院编码
+
+            strConsultationRecord.setRecordDate(DateUtil.parseDateTime(AStrConsultationRecordVO.getRecordDate()));//病历日期recordDate
+            strConsultationRecord.setBehospitalDate(DateUtil.parseDateTime(AStrConsultationRecordVO.getBehospitalDate()));//入院日期behospital_date
+            strConsultationRecord.setApplyDate(DateUtil.parseDateTime(AStrConsultationRecordVO.getApplyDate()));//申请日期apply_date
+            strConsultationRecord.setConsultationDate(DateUtil.parseDate(AStrConsultationRecordVO.getConsultationArriveDate()));//会诊时间consultation_date
+            strConsultationRecord.setRecDate(DateUtil.parseDateTime(AStrConsultationRecordVO.getRecDate()));//记录时间rec_date
+            strConsultationRecord.setAuditDate(DateUtil.parseDateTime(AStrConsultationRecordVO.getAuditDate()));//审核时间audit_date
+
+            strConsultationRecord.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strConsultationRecord)){
+                strConsultationRecord.setGmtCreate(new Date());//记录创建时间
+                this.save(strConsultationRecord);
+            }else{
+                strConsultationRecord.setGmtModified(new Date());//记录修改时间
+                this.update(strConsultationRecord,new QueryWrapper<StrConsultationRecord>()
+                        .eq("rec_id", strConsultationRecord.getRecId())
+                        .eq("hospital_id", strConsultationRecord.getHospitalId())
+                        .eq("behospital_code", strConsultationRecord.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("会诊记录）",strConsultationRecord.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrConsultationRecord strConsultationRecord){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrConsultationRecord>()
+                .eq("rec_id", strConsultationRecord.getRecId())
+                .eq("hospital_id", strConsultationRecord.getHospitalId())
+                .eq("behospital_code", strConsultationRecord.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:会诊记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrConsultationRecordVO> list){
+        try {
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrConsultationRecordVO strConsultationRecordVO:list) {
+                    if("".equals(strConsultationRecordVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strConsultationRecordVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strConsultationRecordVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrConsultationRecord> strConsultationRecordList= initData(list);
+                execute(strConsultationRecordList);
+
+                if(logSwitch){
+                    strConsultationRecordList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrConsultationRecord> initData(List<StrConsultationRecordVO> list) throws Exception{
+        List<StrConsultationRecord> tList=Lists.newArrayList();
+        for (StrConsultationRecordVO s:list) {
+            StrConsultationRecord t=new StrConsultationRecord();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getBehospitalDate())){
+                t.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));//入院日期
+            }
+            if(StringUtil.isNotEmpty(s.getApplyDate())){
+                t.setApplyDate(DateUtil.parseDateTime(s.getApplyDate()));//申请日期
+            }
+            if(StringUtil.isNotEmpty(s.getConsultationDate())){
+                t.setConsultationDate(DateUtil.parseDateTime(s.getConsultationDate()));//会诊时间
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.CONSULTATION_RECORD.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrConsultationRecord> list){
+        List<StrConsultationRecord> addE = Lists.newLinkedList();
+        List<StrConsultationRecord> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrConsultationRecord strConsultationRecord = this.getOne(new QueryWrapper<StrConsultationRecord>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strConsultationRecord != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strConsultationRecordService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrConsultationResultFacade.java

@@ -0,0 +1,240 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrConsultationResult;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrConsultationResultServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrConsultationResultVO;
+import com.diagbot.vo.str.StrConsultationResultVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:会诊结果单-业务类
+ * @Author:liuqq
+ * @time: ${DATE} ${TIME}
+ **/
+@Component
+public class StrConsultationResultFacade extends StrConsultationResultServiceImpl {
+
+    @Autowired
+    @Qualifier("strConsultationResultServiceImpl")
+    private StrConsultationResultServiceImpl strConsultationResultService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strConsultationResult");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrConsultationResult strConsultationResult=new StrConsultationResult();
+        strConsultationResult.setRecId(strContentVO.getRecId());
+        strConsultationResult.setBehospitalCode(strContentVO.getBehospitalCode());
+        strConsultationResult.setHospitalId(strContentVO.getHospitalId());
+        strConsultationResult.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strConsultationResult)) {
+            strConsultationResult.setGmtCreate(new Date());//记录创建时间
+            this.save(strConsultationResult);
+        } else {
+            strConsultationResult.setGmtModified(new Date());//记录修改时间
+            this.update(strConsultationResult, new QueryWrapper<StrConsultationResult>()
+                    .eq("rec_id", strConsultationResult.getRecId())
+                    .eq("hospital_id", strConsultationResult.getHospitalId())
+                    .eq("behospital_code", strConsultationResult.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrConsultationResult strConsultationResult=new StrConsultationResult();
+        try {
+            AStrConsultationResultVO strConsultationResultVO=(AStrConsultationResultVO) MapUtil.mapToObject(entityMap, AStrConsultationResultVO.class);
+            BeanUtils.copyProperties(strConsultationResultVO,strConsultationResult);
+            strConsultationResult.setHospitalId(hospitalId);//医院编码
+
+            strConsultationResult.setAuditDate(DateUtil.parseDateTime(strConsultationResultVO.getAuditDate()));//审核时间
+            strConsultationResult.setRecDate(DateUtil.parseDateTime(strConsultationResultVO.getRecDate()));//记录时间
+            strConsultationResult.setBehospitalDate(DateUtil.parseDateTime(strConsultationResultVO.getBehospitalDate()));//入院日期
+            strConsultationResult.setApplyDate(DateUtil.parseDate(strConsultationResultVO.getApplyDate()));//申请时间
+            strConsultationResult.setRecordDate(DateUtil.parseDateTime(strConsultationResultVO.getRecordDate()));//病历日期
+            strConsultationResult.setConsultationArriveDate(DateUtil.parseDateTime(strConsultationResultVO.getConsultationArriveDate()));//会诊到达时间
+
+            strConsultationResult.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strConsultationResult)){
+                strConsultationResult.setGmtCreate(new Date());//记录创建时间
+                this.save(strConsultationResult);
+            }else{
+                strConsultationResult.setGmtModified(new Date());//记录修改时间
+                this.update(strConsultationResult,new QueryWrapper<StrConsultationResult>()
+                        .eq("rec_id", strConsultationResult.getRecId())
+                        .eq("hospital_id", strConsultationResult.getHospitalId())
+                        .eq("behospital_code", strConsultationResult.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("会诊结果单",strConsultationResult.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrConsultationResult strConsultationResult){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrConsultationResult>()
+                .eq("rec_id", strConsultationResult.getRecId())
+                .eq("hospital_id", strConsultationResult.getHospitalId())
+                .eq("behospital_code", strConsultationResult.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:会诊结果单-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrConsultationResultVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrConsultationResultVO strConsultationResultVO:list) {
+                    if("".equals(strConsultationResultVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strConsultationResultVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strConsultationResultVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrConsultationResult> strConsultationResultList= initData(list);
+                execute(strConsultationResultList);
+
+                if(logSwitch){
+                    strConsultationResultList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊结果单-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-会诊结果单-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrConsultationResult> initData(List<StrConsultationResultVO> list) throws Exception{
+        List<StrConsultationResult> tList=Lists.newArrayList();
+        for (StrConsultationResultVO s:list) {
+            StrConsultationResult t=new StrConsultationResult();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getBehospitalDate())){
+                t.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));//入院日期
+            }
+            if(StringUtil.isNotEmpty(s.getApplyDate())){
+                t.setApplyDate(DateUtil.parseDateTime(s.getApplyDate()));//申请日期
+            }
+            if(StringUtil.isNotEmpty(s.getConsultationArriveDate())){
+                t.setConsultationArriveDate(DateUtil.parseDateTime(s.getConsultationArriveDate()));//会诊到达时间
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.CONSULTATION_RESULT.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrConsultationResult> list){
+        List<StrConsultationResult> addE = Lists.newLinkedList();
+        List<StrConsultationResult> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrConsultationResult strConsultationResult = this.getOne(new QueryWrapper<StrConsultationResult>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strConsultationResult != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strConsultationResultService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrContentFacade.java

@@ -0,0 +1,111 @@
+package com.lantone.data.facade.dataStr;
+
+/**
+ * @Description:文书核心业务处理类
+ * @Author:liuqq
+ * @time: ${DATE} ${TIME}
+ **/
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.ModelHospital;
+import com.diagbot.entity.StrTotalInfo;
+import com.diagbot.enums.ModeIdEnum;
+import com.diagbot.facade.ModelHospitalFacade;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.vo.str.StrContentVO;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+
+@Component
+public class StrContentFacade {
+
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private ModelHospitalFacade modelHospitalFacade;
+    @Autowired
+    private com.diagbot.facade.str.StrTotalInfoFacade strTotalInfoFacade;
+
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    @Value("${xml_analyse.enable}")
+    private boolean xmlAnalyse;
+
+    public RespDTO execDealData(StrContentVO strContentVO){
+        try{
+            if("".equals(strContentVO.getModelId())){
+                return RespDTO.onError("请输入模板类型ID!");
+            }else if("".equals(strContentVO.getRecId())) {
+                return RespDTO.onError("请输入记录编号!");
+            }else if(strContentVO.getHospitalId()==null){
+                return RespDTO.onError("请输入医院编码!");
+            }else if("".equals(strContentVO.getBehospitalCode())){
+                return RespDTO.onError("请输入病人住院编码!");
+            }else{
+                //根据医院模板类型ID+名称，初始化modelId,用于区分存到哪张表
+                Long modelId=initModeId(strContentVO);
+                if(modelId!=0L){
+                    //是否进行xml、html、json解析为标准结构化
+                    if(xmlAnalyse){
+                        //解析时，调用解析接口
+                        columnFacade.analyseWholeData(strContentVO);
+                    }else{
+                        //不解析时，只存储入库
+                        columnFacade.addWholeData(strContentVO);
+                    }
+                }else{
+                    //无对应的modelId时，存入对应表中，方便后面追述
+                    StrTotalInfo strTotalInfo=new StrTotalInfo();
+                    BeanUtils.copyProperties(strContentVO,strTotalInfo);
+                    strTotalInfo.setGmtCreate(new Date());
+                    strTotalInfoFacade.save(strTotalInfo);
+                }
+
+                if(logSwitch){
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-文书-正常", strContentVO.getRecId(), JSON.toJSONString(strContentVO), "", ModeIdEnum.getName(Integer.parseInt(strContentVO.getModelId())));
+                }
+                return RespDTO.onSuc("操作正常！");
+            }
+        }catch (Exception e){
+            aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-文书-异常", ModeIdEnum.getName(Integer.parseInt(strContentVO.getModelId())), JSON.toJSONString(strContentVO), "", e.getMessage());
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    /**
+     * 初始化模型ID,根据医院模板类型ID及名称，具体逻辑已项目为主
+     * @param strContentVO
+     * @return
+     */
+    private Long initModeId(StrContentVO strContentVO) {
+        Long modelId=0L;
+        try{
+            QueryWrapper<ModelHospital> wrapper = new QueryWrapper<>();
+            wrapper.eq("hospital_id", strContentVO.getHospitalId())
+                    .eq("hospital_model_name", strContentVO.getModelName())
+                    .eq("remark", strContentVO.getModelId());
+            ModelHospital mode = modelHospitalFacade.getOne(wrapper, false);
+            if (mode != null) {
+                modelId = mode.getStandModelId();
+            } else {
+                modelId=0L;
+            }
+        }catch (Exception e){
+            modelId=0L;
+            e.printStackTrace();
+        }
+
+        return modelId;
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrCrisisNoteFacade.java

@@ -0,0 +1,227 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrCrisisNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrCrisisNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrCrisisNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrCrisisNoteVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrCrisisNoteFacade extends StrCrisisNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strCrisisNoteServiceImpl")
+    private StrCrisisNoteServiceImpl strCrisisNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strCrisisNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrCrisisNote strCrisisNote=new StrCrisisNote();
+        strCrisisNote.setRecId(strContentVO.getRecId());
+        strCrisisNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strCrisisNote.setHospitalId(strContentVO.getHospitalId());
+        strCrisisNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strCrisisNote)) {
+            strCrisisNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strCrisisNote);
+        } else {
+            strCrisisNote.setGmtModified(new Date());//记录修改时间
+            this.update(strCrisisNote, new QueryWrapper<StrCrisisNote>()
+                    .eq("rec_id", strCrisisNote.getRecId())
+                    .eq("hospital_id", strCrisisNote.getHospitalId())
+                    .eq("behospital_code", strCrisisNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrCrisisNote strCrisisNote=new StrCrisisNote();
+        try {
+            AStrCrisisNoteVO strCrisisNoteVO=(AStrCrisisNoteVO) MapUtil.mapToObject(entityMap, AStrCrisisNoteVO.class);
+            BeanUtils.copyProperties(strCrisisNoteVO,strCrisisNote);
+            strCrisisNote.setHospitalId(hospitalId);//医院编码
+
+            strCrisisNote.setAuditDate(DateUtil.parseDateTime(strCrisisNoteVO.getAuditDate()));//审核时间
+            strCrisisNote.setRecDate(DateUtil.parseDateTime(strCrisisNoteVO.getRecDate()));//记录时间
+            strCrisisNote.setRecieveDate(DateUtil.parseDateTime(strCrisisNoteVO.getRecieveDate()));//开始时间
+            strCrisisNote.setAuditDate(DateUtil.parseDate(strCrisisNoteVO.getAuditDate()));//结束时间
+            strCrisisNote.setRecordDate(DateUtil.parseDateTime(strCrisisNoteVO.getRecordDate()));//病历日期
+
+            strCrisisNote.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strCrisisNote)){
+                strCrisisNote.setGmtCreate(new Date());//记录创建时间
+                this.save(strCrisisNote);
+            }else{
+                strCrisisNote.setGmtModified(new Date());//记录修改时间
+                this.update(strCrisisNote,new QueryWrapper<StrCrisisNote>()
+                        .eq("rec_id", strCrisisNote.getRecId())
+                        .eq("hospital_id", strCrisisNote.getHospitalId())
+                        .eq("behospital_code", strCrisisNote.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("危急值记录",strCrisisNote.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrCrisisNote strCrisisNote){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrCrisisNote>()
+                .eq("rec_id", strCrisisNote.getRecId())
+                .eq("hospital_id", strCrisisNote.getHospitalId())
+                .eq("behospital_code", strCrisisNote.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:危急值记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrCrisisNoteVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrCrisisNoteVO strCrisisNoteVO:list) {
+                    if("".equals(strCrisisNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strCrisisNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strCrisisNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrCrisisNote> strCrisisNoteList= initData(list);
+                execute(strCrisisNoteList);
+
+                if(logSwitch){
+                    strCrisisNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-危急值记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-危急值记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrCrisisNote> initData(List<StrCrisisNoteVO> list) throws Exception{
+        List<StrCrisisNote> tList=Lists.newArrayList();
+        for (StrCrisisNoteVO s:list) {
+            StrCrisisNote t=new StrCrisisNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecieveDate())){
+                t.setRecieveDate(DateUtil.parseDateTime(s.getRecieveDate()));//接收日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.CRISIS_NOTE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrCrisisNote> list){
+        List<StrCrisisNote> addE = Lists.newLinkedList();
+        List<StrCrisisNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrCrisisNote strCrisisNote = this.getOne(new QueryWrapper<StrCrisisNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strCrisisNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strCrisisNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrDeathDiscussionFacade.java

@@ -0,0 +1,230 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrDeathDiscussion;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrDeathDiscussionServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrDeathDiscussionVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrDeathDiscussionVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrDeathDiscussionFacade extends StrDeathDiscussionServiceImpl {
+    @Autowired
+    @Qualifier("strDeathDiscussionServiceImpl")
+    private StrDeathDiscussionServiceImpl strDeathDiscussionService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strDeathDiscussion");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrDeathDiscussion strDeathDiscussion=new StrDeathDiscussion();
+        strDeathDiscussion.setRecId(strContentVO.getRecId());
+        strDeathDiscussion.setBehospitalCode(strContentVO.getBehospitalCode());
+        strDeathDiscussion.setHospitalId(strContentVO.getHospitalId());
+        strDeathDiscussion.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strDeathDiscussion)) {
+            strDeathDiscussion.setGmtCreate(new Date());//记录创建时间
+            this.save(strDeathDiscussion);
+        } else {
+            strDeathDiscussion.setGmtModified(new Date());//记录修改时间
+            this.update(strDeathDiscussion, new QueryWrapper<StrDeathDiscussion>()
+                    .eq("rec_id", strDeathDiscussion.getRecId())
+                    .eq("hospital_id", strDeathDiscussion.getHospitalId())
+                    .eq("behospital_code", strDeathDiscussion.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrDeathDiscussion strDeathDiscussion=new StrDeathDiscussion();
+        try {
+            AStrDeathDiscussionVO strDeathDiscussionVO=(AStrDeathDiscussionVO) MapUtil.mapToObject(entityMap, AStrDeathDiscussionVO.class);
+            BeanUtils.copyProperties(strDeathDiscussionVO,strDeathDiscussion);
+            strDeathDiscussion.setHospitalId(hospitalId);//医院编码
+
+            strDeathDiscussion.setAuditDate(DateUtil.parseDateTime(strDeathDiscussionVO.getAuditDate()));//审核时间
+            strDeathDiscussion.setRecDate(DateUtil.parseDateTime(strDeathDiscussionVO.getRecDate()));//记录时间
+            strDeathDiscussion.setDeathDate(DateUtil.parseDateTime(strDeathDiscussionVO.getDeathDate()));//死亡时间
+            strDeathDiscussion.setDiscussDate(DateUtil.parseDate(strDeathDiscussionVO.getDiscussDate()));//讨论时间
+            strDeathDiscussion.setRecordDate(DateUtil.parseDateTime(strDeathDiscussionVO.getRecordDate()));//病历日期
+
+            strDeathDiscussion.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strDeathDiscussion)){
+                strDeathDiscussion.setGmtCreate(new Date());//记录创建时间
+                this.save(strDeathDiscussion);
+            }else{
+                strDeathDiscussion.setGmtModified(new Date());//记录修改时间
+                this.update(strDeathDiscussion,new QueryWrapper<StrDeathDiscussion>()
+                        .eq("rec_id", strDeathDiscussion.getRecId())
+                        .eq("hospital_id", strDeathDiscussion.getHospitalId())
+                        .eq("behospital_code", strDeathDiscussion.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("死亡病例讨论记录",strDeathDiscussion.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrDeathDiscussion strDeathDiscussion){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrDeathDiscussion>()
+                .eq("rec_id", strDeathDiscussion.getRecId())
+                .eq("hospital_id", strDeathDiscussion.getHospitalId())
+                .eq("behospital_code", strDeathDiscussion.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:死亡病例讨论记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrDeathDiscussionVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrDeathDiscussionVO strDeathDiscussionVO:list) {
+                    if("".equals(strDeathDiscussionVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strDeathDiscussionVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strDeathDiscussionVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrDeathDiscussion> strDeathDiscussionList= Lists.newArrayList();
+                execute(strDeathDiscussionList);
+
+                if(logSwitch){
+                    strDeathDiscussionList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-死亡病例讨论记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-死亡病例讨论记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrDeathDiscussion> initData(List<StrDeathDiscussionVO> list) throws Exception{
+        List<StrDeathDiscussion> tList=Lists.newArrayList();
+        for (StrDeathDiscussionVO s:list) {
+            StrDeathDiscussion t=new StrDeathDiscussion();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getDeathDate())){
+                t.setDeathDate(DateUtil.parseDateTime(s.getDeathDate()));//死亡日期
+            }
+            if(StringUtil.isNotEmpty(s.getDiscussDate())){
+                t.setDiscussDate(DateUtil.parseDateTime(s.getDiscussDate()));//讨论时间
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.DEATH_DISCUSSION.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrDeathDiscussion> list){
+        List<StrDeathDiscussion> addE = Lists.newLinkedList();
+        List<StrDeathDiscussion> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrDeathDiscussion strDeathDiscussion = this.getOne(new QueryWrapper<StrDeathDiscussion>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strDeathDiscussion != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strDeathDiscussionService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrDeathNoteFacade.java

@@ -0,0 +1,228 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrDeathNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrDeathNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrDeathNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrDeathNoteVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrDeathNoteFacade extends StrDeathNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strDeathNoteServiceImpl")
+    private StrDeathNoteServiceImpl strDeathNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strDeathNote");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrDeathNote strDeathNote=new StrDeathNote();
+        strDeathNote.setRecId(strContentVO.getRecId());
+        strDeathNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strDeathNote.setHospitalId(strContentVO.getHospitalId());
+        strDeathNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strDeathNote)) {
+            strDeathNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strDeathNote);
+        } else {
+            strDeathNote.setGmtModified(new Date());//记录修改时间
+            this.update(strDeathNote, new QueryWrapper<StrDeathNote>()
+                    .eq("rec_id", strDeathNote.getRecId())
+                    .eq("hospital_id", strDeathNote.getHospitalId())
+                    .eq("behospital_code", strDeathNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrDeathNote strDeathNote=new StrDeathNote();
+        try {
+            AStrDeathNoteVO strDeathNoteVO=(AStrDeathNoteVO) MapUtil.mapToObject(entityMap, AStrDeathNoteVO.class);
+            BeanUtils.copyProperties(strDeathNoteVO,strDeathNote);
+            strDeathNote.setHospitalId(hospitalId);//医院编码
+
+            strDeathNote.setAuditDate(DateUtil.parseDateTime(strDeathNoteVO.getAuditDate()));//审核时间
+            strDeathNote.setRecDate(DateUtil.parseDateTime(strDeathNoteVO.getRecDate()));//记录时间
+            strDeathNote.setBehospitalDate(DateUtil.parseDateTime(strDeathNoteVO.getBehospitalDate()));//入院日期
+            strDeathNote.setDeathDate(DateUtil.parseDate(strDeathNoteVO.getDeathDate()));//死亡日期
+            strDeathNote.setRecordDate(DateUtil.parseDateTime(strDeathNoteVO.getRecordDate()));//病历日期
+
+            strDeathNote.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strDeathNote)){
+                strDeathNote.setGmtCreate(new Date());//记录创建时间
+                this.save(strDeathNote);
+            }else{
+                strDeathNote.setGmtModified(new Date());//记录修改时间
+                this.update(strDeathNote,new QueryWrapper<StrDeathNote>()
+                        .eq("rec_id", strDeathNote.getRecId())
+                        .eq("hospital_id", strDeathNote.getHospitalId())
+                        .eq("behospital_code", strDeathNote.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("死亡记录", strDeathNote.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrDeathNote strDeathNote){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrDeathNote>()
+                .eq("rec_id", strDeathNote.getRecId())
+                .eq("hospital_id", strDeathNote.getHospitalId())
+                .eq("behospital_code", strDeathNote.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:死亡记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrDeathNoteVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrDeathNoteVO strDeathNoteVO:list) {
+                    if("".equals(strDeathNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strDeathNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strDeathNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrDeathNote> strDeathNoteList= initData(list);
+                execute(strDeathNoteList);
+
+                if(logSwitch){
+                    strDeathNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-死亡记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-死亡记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrDeathNote> initData(List<StrDeathNoteVO> list) throws Exception{
+        List<StrDeathNote> tList=Lists.newArrayList();
+        for (StrDeathNoteVO s:list) {
+            StrDeathNote t=new StrDeathNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getDeathDate())){
+                t.setDeathDate(DateUtil.parseDateTime(s.getDeathDate()));//死亡日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.DEATH_NOTE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrDeathNote> list){
+        List<StrDeathNote> addE = Lists.newLinkedList();
+        List<StrDeathNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrDeathNote strDeathNote = this.getOne(new QueryWrapper<StrDeathNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strDeathNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strDeathNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrDifficultCaseFacade.java

@@ -0,0 +1,226 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrDifficultCase;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrDifficultCaseServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrDifficultCaseVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrDifficultCaseVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrDifficultCaseFacade extends StrDifficultCaseServiceImpl{
+
+    @Autowired
+    @Qualifier("strDifficultCaseServiceImpl")
+    private StrDifficultCaseServiceImpl strDifficultCaseService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strDifficultCase");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrDifficultCase medDifficult=new StrDifficultCase();
+        medDifficult.setRecId(strContentVO.getRecId());
+        medDifficult.setBehospitalCode(strContentVO.getBehospitalCode());
+        medDifficult.setHospitalId(strContentVO.getHospitalId());
+        medDifficult.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(medDifficult)) {
+            medDifficult.setGmtCreate(new Date());//记录创建时间
+            this.save(medDifficult);
+        } else {
+            medDifficult.setGmtModified(new Date());//记录修改时间
+            this.update(medDifficult, new QueryWrapper<StrDifficultCase>()
+                    .eq("rec_id", medDifficult.getRecId())
+                    .eq("hospital_id", medDifficult.getHospitalId())
+                    .eq("behospital_code", medDifficult.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrDifficultCase medDifficult=new StrDifficultCase();
+        try {
+            AStrDifficultCaseVO medDifficultVO=(AStrDifficultCaseVO) MapUtil.mapToObject(entityMap, AStrDifficultCaseVO.class);
+            BeanUtils.copyProperties(medDifficultVO,medDifficult);
+            medDifficult.setHospitalId(hospitalId);//医院编码
+            medDifficult.setRecDate(DateUtil.parseDateTime(medDifficultVO.getRecDate()));
+            medDifficult.setAuditDate(DateUtil.parseDateTime(medDifficultVO.getAuditDate()));
+            medDifficult.setDiscussDate(DateUtil.parseDateTime(medDifficultVO.getDiscussDate()));
+            medDifficult.setRecordDate(DateUtil.parseDateTime(medDifficultVO.getRecordDate()));//病历日期
+
+            medDifficult.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(medDifficult)){
+                medDifficult.setGmtCreate(new Date());//记录创建时间
+                this.save(medDifficult);
+            }else{
+                medDifficult.setGmtModified(new Date());//记录修改时间
+                this.update(medDifficult,new QueryWrapper<StrDifficultCase>()
+                        .eq("rec_id", medDifficult.getRecId())
+                        .eq("hospital_id", medDifficult.getHospitalId())
+                        .eq("behospital_code", medDifficult.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("疑难病例讨论记录",medDifficult.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrDifficultCase medDifficult){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrDifficultCase>()
+                .eq("rec_id", medDifficult.getRecId())
+                .eq("hospital_id", medDifficult.getHospitalId())
+                .eq("behospital_code", medDifficult.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:疑难病例讨论记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrDifficultCaseVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrDifficultCaseVO strDifficultCaseVO:list) {
+                    if("".equals(strDifficultCaseVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strDifficultCaseVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strDifficultCaseVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrDifficultCase> strDifficultCaseList= initData(list);
+                execute(strDifficultCaseList);
+
+                if(logSwitch){
+                    strDifficultCaseList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-疑难病例讨论记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-疑难病例讨论记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrDifficultCase> initData(List<StrDifficultCaseVO> list) throws Exception{
+        List<StrDifficultCase> tList=Lists.newArrayList();
+        for (StrDifficultCaseVO s:list) {
+            StrDifficultCase t=new StrDifficultCase();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getDiscussDate())){
+                t.setDiscussDate(DateUtil.parseDateTime(s.getDiscussDate()));//讨论日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.DIFFICULT_CASE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrDifficultCase> list){
+        List<StrDifficultCase> addE = Lists.newLinkedList();
+        List<StrDifficultCase> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrDifficultCase strDifficultCase = this.getOne(new QueryWrapper<StrDifficultCase>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strDifficultCase != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strDifficultCaseService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrFirstRecordFacade.java

@@ -0,0 +1,223 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrFirstRecord;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrFirstRecordServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrFirstRecordVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrFirstRecordVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrFirstRecordFacade extends StrFirstRecordServiceImpl {
+
+    @Autowired
+    @Qualifier("strFirstRecordServiceImpl")
+    private StrFirstRecordServiceImpl strFirstRecordService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strFirstRecord");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrFirstRecord medDifficult=new StrFirstRecord();
+        medDifficult.setRecId(strContentVO.getRecId());
+        medDifficult.setBehospitalCode(strContentVO.getBehospitalCode());
+        medDifficult.setHospitalId(strContentVO.getHospitalId());
+        medDifficult.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(medDifficult)) {
+            medDifficult.setGmtCreate(new Date());//记录创建时间
+            this.save(medDifficult);
+        } else {
+            medDifficult.setGmtModified(new Date());//记录修改时间
+            this.update(medDifficult, new QueryWrapper<StrFirstRecord>()
+                    .eq("rec_id", medDifficult.getRecId())
+                    .eq("hospital_id", medDifficult.getHospitalId())
+                    .eq("behospital_code", medDifficult.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrFirstRecord strFirstRecord=new StrFirstRecord();
+        try {
+            AStrFirstRecordVO strFirstRecordVO=(AStrFirstRecordVO) MapUtil.mapToObject(entityMap, AStrFirstRecordVO.class);
+            BeanUtils.copyProperties(strFirstRecordVO,strFirstRecord);
+            strFirstRecord.setHospitalId(hospitalId);//医院编码
+
+            strFirstRecord.setAuditDate(DateUtil.parseDateTime(strFirstRecordVO.getAuditDate()));//审核时间
+            strFirstRecord.setRecDate(DateUtil.parseDateTime(strFirstRecordVO.getRecDate()));//记录时间
+            strFirstRecord.setRecordDate(DateUtil.parseDateTime(strFirstRecordVO.getRecordDate()));//病历日期
+
+            strFirstRecord.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strFirstRecord)){
+                strFirstRecord.setGmtCreate(new Date());//记录创建时间
+                this.save(strFirstRecord);
+            }else{
+                strFirstRecord.setGmtModified(new Date());//记录修改时间
+                this.update(strFirstRecord,new QueryWrapper<StrFirstRecord>()
+                        .eq("rec_id", strFirstRecord.getRecId())
+                        .eq("hospital_id", strFirstRecord.getHospitalId())
+                        .eq("behospital_code", strFirstRecord.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("首次病程录", strFirstRecord.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrFirstRecord strFirstRecord){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrFirstRecord>()
+                .eq("rec_id", strFirstRecord.getRecId())
+                .eq("hospital_id", strFirstRecord.getHospitalId())
+                .eq("behospital_code", strFirstRecord.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:首次病程录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrFirstRecordVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrFirstRecordVO strFirstRecordVO:list) {
+                    if("".equals(strFirstRecordVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strFirstRecordVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strFirstRecordVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrFirstRecord> strFirstRecordList= initData(list);
+                execute(strFirstRecordList);
+
+                if(logSwitch){
+                    strFirstRecordList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-首次病程录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-首次病程录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrFirstRecord> initData(List<StrFirstRecordVO> list) throws Exception{
+        List<StrFirstRecord> tList=Lists.newArrayList();
+        for (StrFirstRecordVO s:list) {
+            StrFirstRecord t=new StrFirstRecord();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.FIRST_RECORD.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrFirstRecord> list){
+        List<StrFirstRecord> addE = Lists.newLinkedList();
+        List<StrFirstRecord> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrFirstRecord strFirstRecord = this.getOne(new QueryWrapper<StrFirstRecord>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strFirstRecord != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strFirstRecordService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrIllCriticallyFacade.java

@@ -0,0 +1,222 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrIllCritically;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrIllCriticallyServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrIllCriticallyVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrIllCriticallyVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrIllCriticallyFacade extends StrIllCriticallyServiceImpl {
+
+    @Autowired
+    @Qualifier("strIllCriticallyServiceImpl")
+    private StrIllCriticallyServiceImpl strIllCriticallyService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strIllCritically");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrIllCritically strIllCritically=new StrIllCritically();
+        strIllCritically.setRecId(strContentVO.getRecId());
+        strIllCritically.setBehospitalCode(strContentVO.getBehospitalCode());
+        strIllCritically.setHospitalId(strContentVO.getHospitalId());
+        strIllCritically.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strIllCritically)) {
+            strIllCritically.setGmtCreate(new Date());//记录创建时间
+            this.save(strIllCritically);
+        } else {
+            strIllCritically.setGmtModified(new Date());//记录修改时间
+            this.update(strIllCritically, new QueryWrapper<StrIllCritically>()
+                    .eq("rec_id", strIllCritically.getRecId())
+                    .eq("hospital_id", strIllCritically.getHospitalId())
+                    .eq("behospital_code", strIllCritically.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrIllCritically strIllCritically=new StrIllCritically();
+        try {
+            AStrIllCriticallyVO strIllCriticallyVO=(AStrIllCriticallyVO) MapUtil.mapToObject(entityMap, AStrIllCriticallyVO.class);
+            BeanUtils.copyProperties(strIllCriticallyVO,strIllCritically);
+            strIllCritically.setHospitalId(hospitalId);//医院编码
+            strIllCritically.setPatientSignDate(DateUtil.parseDateTime(strIllCriticallyVO.getPatientSignDate()));
+            strIllCritically.setDoctorSignDate(DateUtil.parseDateTime(strIllCriticallyVO.getDoctorSignDate()));//审核时间
+            strIllCritically.setRecordDate(DateUtil.parseDateTime(strIllCriticallyVO.getRecordDate()));//病历日期
+
+            strIllCritically.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strIllCritically)){
+                strIllCritically.setGmtCreate(new Date());//记录创建时间
+                this.save(strIllCritically);
+            }else{
+                strIllCritically.setGmtModified(new Date());//记录修改时间
+                this.update(strIllCritically,new QueryWrapper<StrIllCritically>()
+                        .eq("rec_id", strIllCritically.getRecId())
+                        .eq("hospital_id", strIllCritically.getHospitalId())
+                        .eq("behospital_code", strIllCritically.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病危通知单",strIllCritically.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrIllCritically strIllCritically){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrIllCritically>()
+                .eq("rec_id", strIllCritically.getRecId())
+                .eq("hospital_id", strIllCritically.getHospitalId())
+                .eq("behospital_code", strIllCritically.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:病危通知单-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrIllCriticallyVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrIllCriticallyVO strIllCriticallyVO:list) {
+                    if("".equals(strIllCriticallyVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strIllCriticallyVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strIllCriticallyVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrIllCritically> strIllCriticallyList= initData(list);
+                execute(strIllCriticallyList);
+
+                if(logSwitch){
+                    strIllCriticallyList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-病危通知单-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-病危通知单-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrIllCritically> initData(List<StrIllCriticallyVO> list) throws Exception{
+        List<StrIllCritically> tList=Lists.newArrayList();
+        for (StrIllCriticallyVO s:list) {
+            StrIllCritically t=new StrIllCritically();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getPatientSignDate())){
+                t.setPatientSignDate(DateUtil.parseDateTime(s.getPatientSignDate()));//病人签名日期
+            }
+            if(StringUtil.isNotEmpty(s.getDoctorSignDate())){
+                t.setDoctorSignDate(DateUtil.parseDateTime(s.getDoctorSignDate()));//医生签名日期
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.ILL_CRITICALLY.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrIllCritically> list){
+        List<StrIllCritically> addE = Lists.newLinkedList();
+        List<StrIllCritically> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrIllCritically strIllCritically = this.getOne(new QueryWrapper<StrIllCritically>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strIllCritically != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strIllCriticallyService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrIllSeriouslFacade.java

@@ -0,0 +1,222 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrIllSeriousl;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrIllSeriouslServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrIllSeriouslVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrIllSeriouslVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrIllSeriouslFacade extends StrIllSeriouslServiceImpl {
+
+    @Autowired
+    @Qualifier("strIllSeriouslServiceImpl")
+    private StrIllSeriouslServiceImpl strIllSeriouslService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strIllSeriousl");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrIllSeriousl strIllSeriousl=new StrIllSeriousl();
+        strIllSeriousl.setRecId(strContentVO.getRecId());
+        strIllSeriousl.setBehospitalCode(strContentVO.getBehospitalCode());
+        strIllSeriousl.setHospitalId(strContentVO.getHospitalId());
+        strIllSeriousl.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strIllSeriousl)) {
+            strIllSeriousl.setGmtCreate(new Date());//记录创建时间
+            this.save(strIllSeriousl);
+        } else {
+            strIllSeriousl.setGmtModified(new Date());//记录修改时间
+            this.update(strIllSeriousl, new QueryWrapper<StrIllSeriousl>()
+                    .eq("rec_id", strIllSeriousl.getRecId())
+                    .eq("hospital_id", strIllSeriousl.getHospitalId())
+                    .eq("behospital_code", strIllSeriousl.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrIllSeriousl strIllSeriousl=new StrIllSeriousl();
+        try {
+            AStrIllSeriouslVO strIllSeriouslVO=(AStrIllSeriouslVO) MapUtil.mapToObject(entityMap, AStrIllSeriouslVO.class);
+            BeanUtils.copyProperties(strIllSeriouslVO,strIllSeriousl);
+            strIllSeriousl.setHospitalId(hospitalId);//医院编码
+            strIllSeriousl.setPatientSignDate(DateUtil.parseDateTime(strIllSeriouslVO.getPatientSignDate()));
+            strIllSeriousl.setDoctorSignDate(DateUtil.parseDateTime(strIllSeriouslVO.getDoctorSignDate()));//审核时间
+            strIllSeriousl.setRecordDate(DateUtil.parseDateTime(strIllSeriouslVO.getRecordDate()));//病历日期
+
+            strIllSeriousl.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strIllSeriousl)){
+                strIllSeriousl.setGmtCreate(new Date());//记录创建时间
+                this.save(strIllSeriousl);
+            }else{
+                strIllSeriousl.setGmtModified(new Date());//记录修改时间
+                this.update(strIllSeriousl,new QueryWrapper<StrIllSeriousl>()
+                        .eq("rec_id", strIllSeriousl.getRecId())
+                        .eq("hospital_id", strIllSeriousl.getHospitalId())
+                        .eq("behospital_code", strIllSeriousl.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病重通知单", strIllSeriousl.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrIllSeriousl strIllSeriousl){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrIllSeriousl>()
+                .eq("rec_id", strIllSeriousl.getRecId())
+                .eq("hospital_id", strIllSeriousl.getHospitalId())
+                .eq("behospital_code", strIllSeriousl.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:病重通知单-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrIllSeriouslVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrIllSeriouslVO strIllSeriouslVO:list) {
+                    if("".equals(strIllSeriouslVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strIllSeriouslVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strIllSeriouslVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrIllSeriousl> strIllSeriouslList= initData(list);
+                execute(strIllSeriouslList);
+
+                if(logSwitch){
+                    strIllSeriouslList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-病重通知单-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-病重通知单-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrIllSeriousl> initData(List<StrIllSeriouslVO> list) throws Exception{
+        List<StrIllSeriousl> tList=Lists.newArrayList();
+        for (StrIllSeriouslVO s:list) {
+            StrIllSeriousl t=new StrIllSeriousl();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getPatientSignDate())){
+                t.setPatientSignDate(DateUtil.parseDateTime(s.getPatientSignDate()));//病人签名日期
+            }
+            if(StringUtil.isNotEmpty(s.getDoctorSignDate())){
+                t.setDoctorSignDate(DateUtil.parseDateTime(s.getDoctorSignDate()));//医生签名日期
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.ILL_SERIOUSL.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrIllSeriousl> list){
+        List<StrIllSeriousl> addE = Lists.newLinkedList();
+        List<StrIllSeriousl> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrIllSeriousl strIllSeriousl = this.getOne(new QueryWrapper<StrIllSeriousl>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strIllSeriousl != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strIllSeriouslService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrInformedConsentFacade.java

@@ -0,0 +1,197 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrInformedConsent;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrInformedConsentServiceImpl;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrInformedConsentVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrInformedConsentFacade extends StrInformedConsentServiceImpl {
+
+    @Autowired
+    @Qualifier("strInformedConsentServiceImpl")
+    private StrInformedConsentServiceImpl strInformedConsentService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strInformedConsent");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrInformedConsent strInformedConsent=new StrInformedConsent();
+        strInformedConsent.setRecId(strContentVO.getRecId());
+        strInformedConsent.setBehospitalCode(strContentVO.getBehospitalCode());
+        strInformedConsent.setHospitalId(strContentVO.getHospitalId());
+        //strInformedConsent.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strInformedConsent)) {
+            strInformedConsent.setGmtCreate(new Date());//记录创建时间
+            this.save(strInformedConsent);
+        } else {
+            strInformedConsent.setGmtModified(new Date());//记录修改时间
+            this.update(strInformedConsent, new QueryWrapper<StrInformedConsent>()
+                    .eq("rec_id", strInformedConsent.getRecId())
+                    .eq("hospital_id", strInformedConsent.getHospitalId())
+                    .eq("behospital_code", strInformedConsent.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrInformedConsent strInformedConsent=new StrInformedConsent();
+        try {
+            StrInformedConsentVO strInformedConsentVO=(StrInformedConsentVO) MapUtil.mapToObject(entityMap, StrInformedConsentVO.class);
+            BeanUtils.copyProperties(strInformedConsentVO,strInformedConsent);
+            strInformedConsent.setHospitalId(hospitalId);//医院编码
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strInformedConsent)){
+                strInformedConsent.setGmtCreate(new Date());//记录创建时间
+                this.save(strInformedConsent);
+            }else{
+                strInformedConsent.setGmtModified(new Date());//记录修改时间
+                this.update(strInformedConsent,new QueryWrapper<StrInformedConsent>()
+                        .eq("rec_id", strInformedConsent.getRecId())
+                        .eq("hospital_id", strInformedConsent.getHospitalId())
+                        .eq("behospital_code", strInformedConsent.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病重通知单", strInformedConsent.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrInformedConsent strInformedConsent){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrInformedConsent>()
+                .eq("rec_id", strInformedConsent.getRecId())
+                .eq("hospital_id", strInformedConsent.getHospitalId())
+                .eq("behospital_code", strInformedConsent.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:知情同意书-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrInformedConsentVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrInformedConsentVO strInformedConsentVO:list) {
+                    if("".equals(strInformedConsentVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strInformedConsentVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strInformedConsentVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrInformedConsent> strInformedConsentList= initData(list);
+                execute(strInformedConsentList);
+
+                if(logSwitch){
+                    strInformedConsentList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-知情同意书-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-知情同意书-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrInformedConsent> initData(List<StrInformedConsentVO> list) throws Exception{
+        List<StrInformedConsent> tList= Lists.newArrayList();
+        for (StrInformedConsentVO s:list) {
+            StrInformedConsent t=new StrInformedConsent();
+            BeanUtils.copyProperties(s,t);
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrInformedConsent> list){
+        List<StrInformedConsent> addE = Lists.newLinkedList();
+        List<StrInformedConsent> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrInformedConsent strInformedConsent = this.getOne(new QueryWrapper<StrInformedConsent>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strInformedConsent != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strInformedConsentService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrLeaveHospitalFacade.java

@@ -0,0 +1,231 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrLeaveHospital;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrLeaveHospitalServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrLeaveHospitalVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrLeaveHospitalVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrLeaveHospitalFacade extends StrLeaveHospitalServiceImpl {
+
+    @Autowired
+    @Qualifier("strLeaveHospitalServiceImpl")
+    private StrLeaveHospitalServiceImpl strLeaveHospitalService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strLeaveHospital");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrLeaveHospital strLeaveHospital=new StrLeaveHospital();
+        strLeaveHospital.setRecId(strContentVO.getRecId());
+        strLeaveHospital.setBehospitalCode(strContentVO.getBehospitalCode());
+        strLeaveHospital.setHospitalId(strContentVO.getHospitalId());
+        strLeaveHospital.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strLeaveHospital)) {
+            strLeaveHospital.setGmtCreate(new Date());//记录创建时间
+            this.save(strLeaveHospital);
+        } else {
+            strLeaveHospital.setGmtModified(new Date());//记录修改时间
+            this.update(strLeaveHospital, new QueryWrapper<StrLeaveHospital>()
+                    .eq("rec_id", strLeaveHospital.getRecId())
+                    .eq("hospital_id", strLeaveHospital.getHospitalId())
+                    .eq("behospital_code", strLeaveHospital.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrLeaveHospital strLeaveHospital=new StrLeaveHospital();
+        try {
+            AStrLeaveHospitalVO strLeaveHospitalVO=(AStrLeaveHospitalVO) MapUtil.mapToObject(entityMap, AStrLeaveHospitalVO.class);
+            BeanUtils.copyProperties(strLeaveHospitalVO,strLeaveHospital);
+            strLeaveHospital.setHospitalId(hospitalId);//医院编码
+
+            strLeaveHospital.setAuditDate(DateUtil.parseDateTime(strLeaveHospitalVO.getAuditDate()));//审核时间
+            strLeaveHospital.setRecDate(DateUtil.parseDateTime(strLeaveHospitalVO.getRecDate()));//记录时间
+            strLeaveHospital.setBehospitalDate(DateUtil.parseDateTime(strLeaveHospitalVO.getBehospitalDate()));//入院日期
+            strLeaveHospital.setLeaveHospitalDate(DateUtil.parseDateTime(strLeaveHospitalVO.getLeaveHospitalDate()));//出院时间
+            strLeaveHospital.setRecordDate(DateUtil.parseDateTime(strLeaveHospitalVO.getRecordDate()));//病历日期
+
+            strLeaveHospital.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strLeaveHospital)){
+                strLeaveHospital.setGmtCreate(new Date());//记录创建时间
+                this.save(strLeaveHospital);
+            }else{
+                strLeaveHospital.setGmtModified(new Date());//记录修改时间
+                this.update(strLeaveHospital,new QueryWrapper<StrLeaveHospital>()
+                        .eq("rec_id", strLeaveHospital.getRecId())
+                        .eq("hospital_id", strLeaveHospital.getHospitalId())
+                        .eq("behospital_code", strLeaveHospital.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("出院小结",strLeaveHospital.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrLeaveHospital strLeaveHospital){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrLeaveHospital>()
+                .eq("rec_id", strLeaveHospital.getRecId())
+                .eq("hospital_id", strLeaveHospital.getHospitalId())
+                .eq("behospital_code", strLeaveHospital.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:出院小结-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrLeaveHospitalVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrLeaveHospitalVO strLeaveHospitalVO:list) {
+                    if("".equals(strLeaveHospitalVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strLeaveHospitalVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strLeaveHospitalVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrLeaveHospital> strLeaveHospitalList= initData(list);
+                execute(strLeaveHospitalList);
+
+                if(logSwitch){
+                    strLeaveHospitalList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-出院小结-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-出院小结-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrLeaveHospital> initData(List<StrLeaveHospitalVO> list) throws Exception{
+        List<StrLeaveHospital> tList=Lists.newArrayList();
+        for (StrLeaveHospitalVO s:list) {
+            StrLeaveHospital t=new StrLeaveHospital();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getBehospitalDate())){
+                t.setBehospitalDate(DateUtil.parseDateTime(s.getBehospitalDate()));//入院日期
+            }
+            if(StringUtil.isNotEmpty(s.getLeaveHospitalDate())){
+                t.setLeaveHospitalDate(DateUtil.parseDateTime(s.getLeaveHospitalDate()));//出院日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.LEAVE_HOSPITAL.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrLeaveHospital> list){
+        List<StrLeaveHospital> addE = Lists.newLinkedList();
+        List<StrLeaveHospital> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrLeaveHospital strLeaveHospital = this.getOne(new QueryWrapper<StrLeaveHospital>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strLeaveHospital != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strLeaveHospitalService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrOperativeFirstRecordFacade.java

@@ -0,0 +1,234 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrOperativeFirstRecord;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrOperativeFirstRecordServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrOperativeFirstRecordVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrOperativeFirstRecordVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrOperativeFirstRecordFacade extends StrOperativeFirstRecordServiceImpl {
+
+    @Autowired
+    @Qualifier("strOperativeFirstRecordServiceImpl")
+    private StrOperativeFirstRecordServiceImpl strOperativeFirstRecordService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strOperativeFirstRecord");
+
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrOperativeFirstRecord strOperativeFirstRecord=new StrOperativeFirstRecord();
+        strOperativeFirstRecord.setRecId(strContentVO.getRecId());
+        strOperativeFirstRecord.setBehospitalCode(strContentVO.getBehospitalCode());
+        strOperativeFirstRecord.setHospitalId(strContentVO.getHospitalId());
+        strOperativeFirstRecord.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strOperativeFirstRecord)) {
+            strOperativeFirstRecord.setGmtCreate(new Date());//记录创建时间
+            this.save(strOperativeFirstRecord);
+        } else {
+            strOperativeFirstRecord.setGmtModified(new Date());//记录修改时间
+            this.update(strOperativeFirstRecord, new QueryWrapper<StrOperativeFirstRecord>()
+                    .eq("rec_id", strOperativeFirstRecord.getRecId())
+                    .eq("hospital_id", strOperativeFirstRecord.getHospitalId())
+                    .eq("behospital_code", strOperativeFirstRecord.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrOperativeFirstRecord strOperativeFirstRecord=new StrOperativeFirstRecord();
+        try {
+            AStrOperativeFirstRecordVO strOperativeFirstRecordVO=(AStrOperativeFirstRecordVO) MapUtil.mapToObject(entityMap, AStrOperativeFirstRecordVO.class);
+            BeanUtils.copyProperties(strOperativeFirstRecordVO,strOperativeFirstRecord);
+            strOperativeFirstRecord.setHospitalId(hospitalId);//医院编码
+
+            strOperativeFirstRecord.setAuditDate(DateUtil.parseDateTime(strOperativeFirstRecordVO.getAuditDate()));//审核时间
+            strOperativeFirstRecord.setRecDate(DateUtil.parseDateTime(strOperativeFirstRecordVO.getRecDate()));//记录时间
+            strOperativeFirstRecord.setOperationDate(DateUtil.parseDateTime(strOperativeFirstRecordVO.getOperationDate()));//手术日期
+            strOperativeFirstRecord.setStartTime(DateUtil.parseDate(strOperativeFirstRecordVO.getStartTime()));//开始时间
+            strOperativeFirstRecord.setEndTime(DateUtil.parseDate(strOperativeFirstRecordVO.getEndTime()));//结束时间
+            strOperativeFirstRecord.setRecordDate(DateUtil.parseDateTime(strOperativeFirstRecordVO.getRecordDate()));//病历日期
+
+            strOperativeFirstRecord.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strOperativeFirstRecord)){
+                strOperativeFirstRecord.setGmtCreate(new Date());//记录创建时间
+                this.save(strOperativeFirstRecord);
+            }else{
+                strOperativeFirstRecord.setGmtModified(new Date());//记录修改时间
+                this.update(strOperativeFirstRecord,new QueryWrapper<StrOperativeFirstRecord>()
+                        .eq("rec_id", strOperativeFirstRecord.getRecId())
+                        .eq("hospital_id", strOperativeFirstRecord.getHospitalId())
+                        .eq("behospital_code", strOperativeFirstRecord.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("术后首程",strOperativeFirstRecord.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrOperativeFirstRecord strOperativeFirstRecord){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrOperativeFirstRecord>()
+                .eq("rec_id", strOperativeFirstRecord.getRecId())
+                .eq("hospital_id", strOperativeFirstRecord.getHospitalId())
+                .eq("behospital_code", strOperativeFirstRecord.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:术后首程-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrOperativeFirstRecordVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrOperativeFirstRecordVO strOperativeFirstRecordVO:list) {
+                    if("".equals(strOperativeFirstRecordVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strOperativeFirstRecordVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strOperativeFirstRecordVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrOperativeFirstRecord> strOperativeFirstRecordList= initData(list);
+                execute(strOperativeFirstRecordList);
+
+                if(logSwitch){
+                    strOperativeFirstRecordList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-术后首程-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-术后首程-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrOperativeFirstRecord> initData(List<StrOperativeFirstRecordVO> list) throws Exception{
+        List<StrOperativeFirstRecord> tList=Lists.newArrayList();
+        for (StrOperativeFirstRecordVO s:list) {
+            StrOperativeFirstRecord t=new StrOperativeFirstRecord();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            if(StringUtil.isNotEmpty(s.getOperationDate())){
+                t.setOperationDate(DateUtil.parseDateTime(s.getOperationDate()));//手术日期
+            }
+            if(StringUtil.isNotEmpty(s.getStartTime())){
+                t.setEndTime(DateUtil.parseDateTime(s.getStartTime()));//开始时间
+            }
+            if(StringUtil.isNotEmpty(s.getEndTime())){
+                t.setEndTime(DateUtil.parseDateTime(s.getEndTime()));//结束时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.OPERATIVE_FIRST_RECORD.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrOperativeFirstRecord> list){
+        List<StrOperativeFirstRecord> addE = Lists.newLinkedList();
+        List<StrOperativeFirstRecord> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrOperativeFirstRecord strOperativeFirstRecord = this.getOne(new QueryWrapper<StrOperativeFirstRecord>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strOperativeFirstRecord != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strOperativeFirstRecordService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrOperativeNoteFacade.java

@@ -0,0 +1,235 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrOperativeNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrOperativeNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrOperativeNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrOperativeNoteVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrOperativeNoteFacade extends StrOperativeNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strOperativeNoteServiceImpl")
+    private StrOperativeNoteServiceImpl strOperativeNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strOperativeNote");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrOperativeNote strOperativeNote=new StrOperativeNote();
+        strOperativeNote.setRecId(strContentVO.getRecId());
+        strOperativeNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strOperativeNote.setHospitalId(strContentVO.getHospitalId());
+        strOperativeNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strOperativeNote)) {
+            strOperativeNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strOperativeNote);
+        } else {
+            strOperativeNote.setGmtModified(new Date());//记录修改时间
+            this.update(strOperativeNote, new QueryWrapper<StrOperativeNote>()
+                    .eq("rec_id", strOperativeNote.getRecId())
+                    .eq("hospital_id", strOperativeNote.getHospitalId())
+                    .eq("behospital_code", strOperativeNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrOperativeNote strOperativeNote=new StrOperativeNote();
+        try {
+            AStrOperativeNoteVO strOperativeNoteVO=(AStrOperativeNoteVO) MapUtil.mapToObject(entityMap, AStrOperativeNoteVO.class);
+            BeanUtils.copyProperties(strOperativeNoteVO,strOperativeNote);
+            strOperativeNote.setHospitalId(hospitalId);//医院编码
+
+            strOperativeNote.setAuditDate(DateUtil.parseDateTime(strOperativeNoteVO.getAuditDate()));//审核时间
+            strOperativeNote.setRecDate(DateUtil.parseDateTime(strOperativeNoteVO.getRecDate()));//记录时间
+            strOperativeNote.setOperationDate(DateUtil.parseDateTime(strOperativeNoteVO.getOperationDate()));//手术日期
+            strOperativeNote.setStartTime(DateUtil.parseDate(strOperativeNoteVO.getStartTime()));//开始时间
+            strOperativeNote.setEndTime(DateUtil.parseDate(strOperativeNoteVO.getEndTime()));//结束时间
+            strOperativeNote.setRecordDate(DateUtil.parseDateTime(strOperativeNoteVO.getRecordDate()));//病历日期
+
+            strOperativeNote.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strOperativeNote)){
+                strOperativeNote.setGmtCreate(new Date());//记录创建时间
+                this.save(strOperativeNote);
+            }else{
+                strOperativeNote.setGmtModified(new Date());//记录修改时间
+                this.update(strOperativeNote,new QueryWrapper<StrOperativeNote>()
+                        .eq("rec_id", strOperativeNote.getRecId())
+                        .eq("hospital_id", strOperativeNote.getHospitalId())
+                        .eq("behospital_code", strOperativeNote.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("手术记录", strOperativeNote.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrOperativeNote strOperativeNote){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrOperativeNote>()
+                .eq("rec_id", strOperativeNote.getRecId())
+                .eq("hospital_id", strOperativeNote.getHospitalId())
+                .eq("behospital_code", strOperativeNote.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:手术记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrOperativeNoteVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrOperativeNoteVO strOperativeNoteVO:list) {
+                    if("".equals(strOperativeNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strOperativeNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strOperativeNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrOperativeNote> strOperativeNoteList= initData(list);
+                execute(strOperativeNoteList);
+
+                if(logSwitch){
+                    strOperativeNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-手术记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-手术记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrOperativeNote> initData(List<StrOperativeNoteVO> list) throws Exception{
+        List<StrOperativeNote> tList=Lists.newArrayList();
+        for (StrOperativeNoteVO s:list) {
+            StrOperativeNote t=new StrOperativeNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getOperationDate())){
+                t.setOperationDate(DateUtil.parseDateTime(s.getOperationDate()));//手术日期
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            if(StringUtil.isNotEmpty(s.getStartTime())){
+                t.setEndTime(DateUtil.parseDateTime(s.getStartTime()));//开始时间
+            }
+            if(StringUtil.isNotEmpty(s.getEndTime())){
+                t.setEndTime(DateUtil.parseDateTime(s.getEndTime()));//结束时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.OPERATIVE_NOTE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrOperativeNote> list){
+        List<StrOperativeNote> addE = Lists.newLinkedList();
+        List<StrOperativeNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrOperativeNote strOperativeNote = this.getOne(new QueryWrapper<StrOperativeNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strOperativeNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strOperativeNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrPeriodConclusionFacade.java

@@ -0,0 +1,224 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrPeriodConclusion;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrPeriodConclusionServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrPeriodConclusionVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrPeriodConclusionVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrPeriodConclusionFacade extends StrPeriodConclusionServiceImpl {
+
+    @Autowired
+    @Qualifier("strPeriodConclusionServiceImpl")
+    private StrPeriodConclusionServiceImpl strPeriodConclusionService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strPeriodConclusion");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrPeriodConclusion strPeriodConclusion=new StrPeriodConclusion();
+        strPeriodConclusion.setRecId(strContentVO.getRecId());
+        strPeriodConclusion.setBehospitalCode(strContentVO.getBehospitalCode());
+        strPeriodConclusion.setHospitalId(strContentVO.getHospitalId());
+        strPeriodConclusion.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strPeriodConclusion)) {
+            strPeriodConclusion.setGmtCreate(new Date());//记录创建时间
+            this.save(strPeriodConclusion);
+        } else {
+            strPeriodConclusion.setGmtModified(new Date());//记录修改时间
+            this.update(strPeriodConclusion, new QueryWrapper<StrPeriodConclusion>()
+                    .eq("rec_id", strPeriodConclusion.getRecId())
+                    .eq("hospital_id", strPeriodConclusion.getHospitalId())
+                    .eq("behospital_code", strPeriodConclusion.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrPeriodConclusion strPeriodConclusion=new StrPeriodConclusion();
+        try {
+            AStrPeriodConclusionVO strPeriodConclusionVO=(AStrPeriodConclusionVO) MapUtil.mapToObject(entityMap, AStrPeriodConclusionVO.class);
+            BeanUtils.copyProperties(strPeriodConclusionVO,strPeriodConclusion);
+            strPeriodConclusion.setHospitalId(hospitalId);//医院编码
+
+            strPeriodConclusion.setAuditDate(DateUtil.parseDateTime(strPeriodConclusionVO.getAuditDate()));//审核时间
+            strPeriodConclusion.setRecDate(DateUtil.parseDateTime(strPeriodConclusionVO.getRecDate()));//记录时间
+            strPeriodConclusion.setRecordDate(DateUtil.parseDateTime(strPeriodConclusionVO.getRecordDate()));//病历日期
+
+            strPeriodConclusion.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strPeriodConclusion)){
+                strPeriodConclusion.setGmtCreate(new Date());//记录创建时间
+                this.save(strPeriodConclusion);
+            }else{
+                strPeriodConclusion.setGmtModified(new Date());//记录修改时间
+                this.update(strPeriodConclusion,new QueryWrapper<StrPeriodConclusion>()
+                        .eq("rec_id", strPeriodConclusion.getRecId())
+                        .eq("hospital_id", strPeriodConclusion.getHospitalId())
+                        .eq("behospital_code", strPeriodConclusion.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("阶段小结",strPeriodConclusion.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrPeriodConclusion strPeriodConclusion){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrPeriodConclusion>()
+                .eq("rec_id", strPeriodConclusion.getRecId())
+                .eq("hospital_id", strPeriodConclusion.getHospitalId())
+                .eq("behospital_code", strPeriodConclusion.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:阶段小结-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrPeriodConclusionVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrPeriodConclusionVO strPeriodConclusionVO:list) {
+                    if("".equals(strPeriodConclusionVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strPeriodConclusionVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strPeriodConclusionVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrPeriodConclusion> strPeriodConclusionList= initData(list);
+                execute(strPeriodConclusionList);
+
+                if(logSwitch){
+                    strPeriodConclusionList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-阶段小结-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-阶段小结-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrPeriodConclusion> initData(List<StrPeriodConclusionVO> list) throws Exception{
+        List<StrPeriodConclusion> tList=Lists.newArrayList();
+        for (StrPeriodConclusionVO s:list) {
+            StrPeriodConclusion t=new StrPeriodConclusion();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.PERIOD_CONCLUSION.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrPeriodConclusion> list){
+        List<StrPeriodConclusion> addE = Lists.newLinkedList();
+        List<StrPeriodConclusion> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrPeriodConclusion strPeriodConclusion = this.getOne(new QueryWrapper<StrPeriodConclusion>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strPeriodConclusion != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strPeriodConclusionService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrPreoperativeDiscussionFacade.java

@@ -0,0 +1,227 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrPreoperativeDiscussion;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrPreoperativeDiscussionServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrPreoperativeDiscussionVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrPreoperativeDiscussionVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrPreoperativeDiscussionFacade extends StrPreoperativeDiscussionServiceImpl {
+
+    @Autowired
+    @Qualifier("strPreoperativeDiscussionServiceImpl")
+    private StrPreoperativeDiscussionServiceImpl strPreoperativeDiscussionService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strPreoperativeDiscussion");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrPreoperativeDiscussion strPreoperativeDiscussion=new StrPreoperativeDiscussion();
+        strPreoperativeDiscussion.setRecId(strContentVO.getRecId());
+        strPreoperativeDiscussion.setBehospitalCode(strContentVO.getBehospitalCode());
+        strPreoperativeDiscussion.setHospitalId(strContentVO.getHospitalId());
+        strPreoperativeDiscussion.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strPreoperativeDiscussion)) {
+            strPreoperativeDiscussion.setGmtCreate(new Date());//记录创建时间
+            this.save(strPreoperativeDiscussion);
+        } else {
+            strPreoperativeDiscussion.setGmtModified(new Date());//记录修改时间
+            this.update(strPreoperativeDiscussion, new QueryWrapper<StrPreoperativeDiscussion>()
+                    .eq("rec_id", strPreoperativeDiscussion.getRecId())
+                    .eq("hospital_id", strPreoperativeDiscussion.getHospitalId())
+                    .eq("behospital_code", strPreoperativeDiscussion.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrPreoperativeDiscussion strPreoperativeDiscussion=new StrPreoperativeDiscussion();
+        try {
+            AStrPreoperativeDiscussionVO strPreoperativeDiscussionVO=(AStrPreoperativeDiscussionVO) MapUtil.mapToObject(entityMap, AStrPreoperativeDiscussionVO.class);
+            BeanUtils.copyProperties(strPreoperativeDiscussionVO,strPreoperativeDiscussion);
+            strPreoperativeDiscussion.setHospitalId(hospitalId);//医院编码
+
+            strPreoperativeDiscussion.setAuditDate(DateUtil.parseDateTime(strPreoperativeDiscussionVO.getAuditDate()));//审核时间
+            strPreoperativeDiscussion.setRecDate(DateUtil.parseDateTime(strPreoperativeDiscussionVO.getRecDate()));//记录时间
+            strPreoperativeDiscussion.setDiscussTime(DateUtil.parseDateTime(strPreoperativeDiscussionVO.getDiscussTime()));//讨论时间
+            strPreoperativeDiscussion.setRecordDate(DateUtil.parseDateTime(strPreoperativeDiscussionVO.getRecordDate()));//病历日期
+
+            strPreoperativeDiscussion.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strPreoperativeDiscussion)){
+                strPreoperativeDiscussion.setGmtCreate(new Date());//记录创建时间
+                this.save(strPreoperativeDiscussion);
+            }else{
+                strPreoperativeDiscussion.setGmtModified(new Date());//记录修改时间
+                this.update(strPreoperativeDiscussion,new QueryWrapper<StrPreoperativeDiscussion>()
+                        .eq("rec_id", strPreoperativeDiscussion.getRecId())
+                        .eq("hospital_id", strPreoperativeDiscussion.getHospitalId())
+                        .eq("behospital_code", strPreoperativeDiscussion.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("术前讨论小结",strPreoperativeDiscussion.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrPreoperativeDiscussion strPreoperativeDiscussion){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrPreoperativeDiscussion>()
+                .eq("rec_id", strPreoperativeDiscussion.getRecId())
+                .eq("hospital_id", strPreoperativeDiscussion.getHospitalId())
+                .eq("behospital_code", strPreoperativeDiscussion.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:术前讨论小结-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrPreoperativeDiscussionVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrPreoperativeDiscussionVO strPreoperativeDiscussionVO:list) {
+                    if("".equals(strPreoperativeDiscussionVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strPreoperativeDiscussionVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strPreoperativeDiscussionVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrPreoperativeDiscussion> strPreoperativeDiscussionList= initData(list);
+                execute(strPreoperativeDiscussionList);
+
+                if(logSwitch){
+                    strPreoperativeDiscussionList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-术前讨论小结-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-术前讨论小结-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrPreoperativeDiscussion> initData(List<StrPreoperativeDiscussionVO> list) throws Exception{
+        List<StrPreoperativeDiscussion> tList=Lists.newArrayList();
+        for (StrPreoperativeDiscussionVO s:list) {
+            StrPreoperativeDiscussion t=new StrPreoperativeDiscussion();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            if(StringUtil.isNotEmpty(s.getDiscussTime())){
+                t.setDiscussTime(DateUtil.parseDateTime(s.getDiscussTime()));//讨论时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.PREOPERATIVE_DISCUSSION.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrPreoperativeDiscussion> list){
+        List<StrPreoperativeDiscussion> addE = Lists.newLinkedList();
+        List<StrPreoperativeDiscussion> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrPreoperativeDiscussion strPreoperativeDiscussion = this.getOne(new QueryWrapper<StrPreoperativeDiscussion>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strPreoperativeDiscussion != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strPreoperativeDiscussionService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrRescueNoteFacade.java

@@ -0,0 +1,231 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrRescueNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrRescueNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrRescueNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrRescueNoteVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrRescueNoteFacade extends StrRescueNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strRescueNoteServiceImpl")
+    private StrRescueNoteServiceImpl strRescueNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strRescueNote");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrRescueNote strRescueNote=new StrRescueNote();
+        strRescueNote.setRecId(strContentVO.getRecId());
+        strRescueNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strRescueNote.setHospitalId(strContentVO.getHospitalId());
+        strRescueNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strRescueNote)) {
+            strRescueNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strRescueNote);
+        } else {
+            strRescueNote.setGmtModified(new Date());//记录修改时间
+            this.update(strRescueNote, new QueryWrapper<StrRescueNote>()
+                    .eq("rec_id", strRescueNote.getRecId())
+                    .eq("hospital_id", strRescueNote.getHospitalId())
+                    .eq("behospital_code", strRescueNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrRescueNote strRescueNote=new StrRescueNote();
+        try {
+            AStrRescueNoteVO strRescueNoteVO=(AStrRescueNoteVO) MapUtil.mapToObject(entityMap, AStrRescueNoteVO.class);
+            BeanUtils.copyProperties(strRescueNoteVO,strRescueNote);
+            strRescueNote.setHospitalId(hospitalId);//医院编码
+
+            strRescueNote.setAuditDate(DateUtil.parseDateTime(strRescueNoteVO.getAuditDate()));//审核时间
+            strRescueNote.setRecDate(DateUtil.parseDateTime(strRescueNoteVO.getRecDate()));//记录时间
+            strRescueNote.setStartTime(DateUtil.parseDateTime(strRescueNoteVO.getStartTime()));//开始时间
+            strRescueNote.setEndTime(DateUtil.parseDate(strRescueNoteVO.getEndTime()));//结束时间
+            strRescueNote.setRecordDate(DateUtil.parseDateTime(strRescueNoteVO.getRecordDate()));//病历日期
+
+            strRescueNote.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strRescueNote)){
+                strRescueNote.setGmtCreate(new Date());//记录创建时间
+                this.save(strRescueNote);
+            }else{
+                strRescueNote.setGmtModified(new Date());//记录修改时间
+                this.update(strRescueNote,new QueryWrapper<StrRescueNote>()
+                        .eq("rec_id", strRescueNote.getRecId())
+                        .eq("hospital_id", strRescueNote.getHospitalId())
+                        .eq("behospital_code", strRescueNote.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("抢救记录", strRescueNote.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrRescueNote strRescueNote){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrRescueNote>()
+                .eq("rec_id", strRescueNote.getRecId())
+                .eq("hospital_id", strRescueNote.getHospitalId())
+                .eq("behospital_code", strRescueNote.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:抢救记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrRescueNoteVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrRescueNoteVO strRescueNoteVO:list) {
+                    if("".equals(strRescueNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strRescueNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strRescueNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrRescueNote> strRescueNoteList= initData(list);
+                execute(strRescueNoteList);
+
+                if(logSwitch){
+                    strRescueNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-抢救记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-抢救记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrRescueNote> initData(List<StrRescueNoteVO> list) throws Exception{
+        List<StrRescueNote> tList=Lists.newArrayList();
+        for (StrRescueNoteVO s:list) {
+            StrRescueNote t=new StrRescueNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            if(StringUtil.isNotEmpty(s.getStartTime())){
+                t.setEndTime(DateUtil.parseDateTime(s.getStartTime()));//开始时间
+            }
+            if(StringUtil.isNotEmpty(s.getEndTime())){
+                t.setEndTime(DateUtil.parseDateTime(s.getEndTime()));//结束时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.RESCUE_NOTE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrRescueNote> list){
+        List<StrRescueNote> addE = Lists.newLinkedList();
+        List<StrRescueNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrRescueNote strRescueNote = this.getOne(new QueryWrapper<StrRescueNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strRescueNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strRescueNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrTalkInformFacade.java

@@ -0,0 +1,198 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrTalkInform;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrTalkInformServiceImpl;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrTalkInformVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrTalkInformFacade extends StrTalkInformServiceImpl {
+    @Autowired
+    @Qualifier("strTalkInformServiceImpl")
+    private StrTalkInformServiceImpl strTalkInformService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strTalkInform");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrTalkInform strTalkInform=new StrTalkInform();
+        strTalkInform.setRecId(strContentVO.getRecId());
+        strTalkInform.setBehospitalCode(strContentVO.getBehospitalCode());
+        strTalkInform.setHospitalId(strContentVO.getHospitalId());
+        //strTalkInform.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strTalkInform)) {
+            strTalkInform.setGmtCreate(new Date());//记录创建时间
+            this.save(strTalkInform);
+        } else {
+            strTalkInform.setGmtModified(new Date());//记录修改时间
+            this.update(strTalkInform, new QueryWrapper<StrTalkInform>()
+                    .eq("rec_id", strTalkInform.getRecId())
+                    .eq("hospital_id", strTalkInform.getHospitalId())
+                    .eq("behospital_code", strTalkInform.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrTalkInform strTalkInform=new StrTalkInform();
+        try {
+            StrTalkInformVO strTalkInformVO=(StrTalkInformVO) MapUtil.mapToObject(entityMap, StrTalkInformVO.class);
+            BeanUtils.copyProperties(strTalkInformVO,strTalkInform);
+            strTalkInform.setHospitalId(hospitalId);//医院编码
+
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strTalkInform)){
+                strTalkInform.setGmtCreate(new Date());//记录创建时间
+                this.save(strTalkInform);
+            }else{
+                strTalkInform.setGmtModified(new Date());//记录修改时间
+                this.update(strTalkInform,new QueryWrapper<StrTalkInform>()
+                        .eq("rec_id", strTalkInform.getRecId())
+                        .eq("hospital_id", strTalkInform.getHospitalId())
+                        .eq("behospital_code", strTalkInform.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("病重通知单", strTalkInform.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrTalkInform strTalkInform){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrTalkInform>()
+                .eq("rec_id", strTalkInform.getRecId())
+                .eq("hospital_id", strTalkInform.getHospitalId())
+                .eq("behospital_code", strTalkInform.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:告知书记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrTalkInformVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrTalkInformVO strTalkInformVO:list) {
+                    if("".equals(strTalkInformVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strTalkInformVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strTalkInformVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrTalkInform> strTalkInformList= initData(list);
+                execute(strTalkInformList);
+
+                if(logSwitch){
+                    strTalkInformList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-告知书记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-告知书记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrTalkInform> initData(List<StrTalkInformVO> list) throws Exception{
+        List<StrTalkInform> tList= Lists.newArrayList();
+        for (StrTalkInformVO s:list) {
+            StrTalkInform t=new StrTalkInform();
+            BeanUtils.copyProperties(s,t);
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrTalkInform> list){
+        List<StrTalkInform> addE = Lists.newLinkedList();
+        List<StrTalkInform> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrTalkInform strTalkInform = this.getOne(new QueryWrapper<StrTalkInform>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strTalkInform != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strTalkInformService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrTotalInfoFacade.java

@@ -0,0 +1,7 @@
+package com.lantone.data.facade.dataStr;
+
+import org.springframework.stereotype.Component;
+
+@Component
+public class StrTotalInfoFacade extends StrTotalInfoServiceImpl {
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrTransferInNoteFacade.java

@@ -0,0 +1,227 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrTransferInNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrTransferInNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrTransferInNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrTransferInNoteVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrTransferInNoteFacade extends StrTransferInNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strTransferInNoteServiceImpl")
+    private StrTransferInNoteServiceImpl strTransferInNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strTransferInNote");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrTransferInNote strTransferInNote=new StrTransferInNote();
+        strTransferInNote.setRecId(strContentVO.getRecId());
+        strTransferInNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strTransferInNote.setHospitalId(strContentVO.getHospitalId());
+        strTransferInNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strTransferInNote)) {
+            strTransferInNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strTransferInNote);
+        } else {
+            strTransferInNote.setGmtModified(new Date());//记录修改时间
+            this.update(strTransferInNote, new QueryWrapper<StrTransferInNote>()
+                    .eq("rec_id", strTransferInNote.getRecId())
+                    .eq("hospital_id", strTransferInNote.getHospitalId())
+                    .eq("behospital_code", strTransferInNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrTransferInNote strTransferInNote=new StrTransferInNote();
+        try {
+            AStrTransferInNoteVO strTransferInNoteVO=(AStrTransferInNoteVO) MapUtil.mapToObject(entityMap, AStrTransferInNoteVO.class);
+            BeanUtils.copyProperties(strTransferInNoteVO,strTransferInNote);
+            strTransferInNote.setHospitalId(hospitalId);//医院编码
+            strTransferInNote.setTransferInDate(DateUtil.parseDateTime(strTransferInNoteVO.getTransferInDate()));
+            strTransferInNote.setAuditDate(DateUtil.parseDateTime(strTransferInNoteVO.getAuditDate()));//审核时间
+            strTransferInNote.setRecDate(DateUtil.parseDateTime(strTransferInNoteVO.getRecDate()));//记录时间
+            strTransferInNote.setRecordDate(DateUtil.parseDateTime(strTransferInNoteVO.getRecordDate()));//病历日期
+
+            strTransferInNote.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strTransferInNote)){
+                strTransferInNote.setGmtCreate(new Date());//记录创建时间
+                this.save(strTransferInNote);
+            }else{
+                strTransferInNote.setGmtModified(new Date());//记录修改时间
+                this.update(strTransferInNote,new QueryWrapper<StrTransferInNote>()
+                        .eq("rec_id", strTransferInNote.getRecId())
+                        .eq("hospital_id", strTransferInNote.getHospitalId())
+                        .eq("behospital_code", strTransferInNote.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("转入记录",strTransferInNote.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrTransferInNote strTransferInNote){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrTransferInNote>()
+                .eq("rec_id", strTransferInNote.getRecId())
+                .eq("hospital_id", strTransferInNote.getHospitalId())
+                .eq("behospital_code", strTransferInNote.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:转入记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrTransferInNoteVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrTransferInNoteVO strTransferInNoteVO:list) {
+                    if("".equals(strTransferInNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strTransferInNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strTransferInNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrTransferInNote> strTransferInNoteList= initData(list);
+                execute(strTransferInNoteList);
+
+                if(logSwitch){
+                    strTransferInNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-转入记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-转入记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrTransferInNote> initData(List<StrTransferInNoteVO> list) throws Exception{
+        List<StrTransferInNote> tList=Lists.newArrayList();
+        for (StrTransferInNoteVO s:list) {
+            StrTransferInNote t=new StrTransferInNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getTransferInDate())){
+                t.setTransferInDate(DateUtil.parseDateTime(s.getTransferInDate()));//转入日期
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.TRANSFER_IN_NOTE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrTransferInNote> list){
+        List<StrTransferInNote> addE = Lists.newLinkedList();
+        List<StrTransferInNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrTransferInNote strTransferInNote = this.getOne(new QueryWrapper<StrTransferInNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strTransferInNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strTransferInNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrTransferOutNoteFacade.java

@@ -0,0 +1,224 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrTransferOutNote;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrTransferOutNoteServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrTransferOutNoteVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrTransferOutNoteVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrTransferOutNoteFacade extends StrTransferOutNoteServiceImpl {
+
+    @Autowired
+    @Qualifier("strTransferOutNoteServiceImpl")
+    private StrTransferOutNoteServiceImpl strTransferOutNoteService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strTransferOutNote");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrTransferOutNote strTransferOutNote=new StrTransferOutNote();
+        strTransferOutNote.setRecId(strContentVO.getRecId());
+        strTransferOutNote.setBehospitalCode(strContentVO.getBehospitalCode());
+        strTransferOutNote.setHospitalId(strContentVO.getHospitalId());
+        strTransferOutNote.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strTransferOutNote)) {
+            strTransferOutNote.setGmtCreate(new Date());//记录创建时间
+            this.save(strTransferOutNote);
+        } else {
+            strTransferOutNote.setGmtModified(new Date());//记录修改时间
+            this.update(strTransferOutNote, new QueryWrapper<StrTransferOutNote>()
+                    .eq("rec_id", strTransferOutNote.getRecId())
+                    .eq("hospital_id", strTransferOutNote.getHospitalId())
+                    .eq("behospital_code", strTransferOutNote.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrTransferOutNote strTransferOutNote=new StrTransferOutNote();
+        try {
+            AStrTransferOutNoteVO strTransferOutNoteVO=(AStrTransferOutNoteVO) MapUtil.mapToObject(entityMap, AStrTransferOutNoteVO.class);
+            BeanUtils.copyProperties(strTransferOutNoteVO,strTransferOutNote);
+            strTransferOutNote.setHospitalId(hospitalId);//医院编码
+            strTransferOutNote.setTransferInDate(DateUtil.parseDateTime(strTransferOutNoteVO.getTransferInDate()));
+            strTransferOutNote.setAuditDate(DateUtil.parseDateTime(strTransferOutNoteVO.getAuditDate()));//审核时间
+            strTransferOutNote.setRecDate(DateUtil.parseDateTime(strTransferOutNoteVO.getRecDate()));//记录时间
+            strTransferOutNote.setRecordDate(DateUtil.parseDateTime(strTransferOutNoteVO.getRecordDate()));//病历日期
+
+            strTransferOutNote.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strTransferOutNote)){
+                strTransferOutNote.setGmtCreate(new Date());//记录创建时间
+                this.save(strTransferOutNote);
+            }else{
+                strTransferOutNote.setGmtModified(new Date());//记录修改时间
+                this.update(strTransferOutNote,new QueryWrapper<StrTransferOutNote>()
+                        .eq("rec_id", strTransferOutNote.getRecId())
+                        .eq("hospital_id", strTransferOutNote.getHospitalId())
+                        .eq("behospital_code", strTransferOutNote.getBehospitalCode()));
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("转出记录",strTransferOutNote.getRecId(), JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrTransferOutNote strTransferOutNote){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrTransferOutNote>()
+                .eq("rec_id", strTransferOutNote.getRecId())
+                .eq("hospital_id", strTransferOutNote.getHospitalId())
+                .eq("behospital_code", strTransferOutNote.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:转出记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrTransferOutNoteVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrTransferOutNoteVO strTransferOutNoteVO:list) {
+                    if("".equals(strTransferOutNoteVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strTransferOutNoteVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strTransferOutNoteVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrTransferOutNote> strTransferOutNoteList= initData(list);
+                execute(strTransferOutNoteList);
+                if(logSwitch){
+                    strTransferOutNoteList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-转出记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-转出记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrTransferOutNote> initData(List<StrTransferOutNoteVO> list) throws Exception{
+        List<StrTransferOutNote> tList=Lists.newArrayList();
+        for (StrTransferOutNoteVO s:list) {
+            StrTransferOutNote t=new StrTransferOutNote();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getTransferInDate())){
+                t.setTransferInDate(DateUtil.parseDateTime(s.getTransferInDate()));//转入日期
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.TRANSFER_OUT_NOTE.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            //t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrTransferOutNote> list){
+        List<StrTransferOutNote> addE = Lists.newLinkedList();
+        List<StrTransferOutNote> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrTransferOutNote strTransferOutNote = this.getOne(new QueryWrapper<StrTransferOutNote>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strTransferOutNote != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strTransferOutNoteService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/dataStr/StrWardRecordFacade.java

@@ -0,0 +1,227 @@
+package com.lantone.data.facade.dataStr;
+
+import com.alibaba.fastjson.JSON;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrWardRecord;
+import com.diagbot.enums.CacheKeyEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.facade.data.AMedAbnormalInfoFacade;
+import com.diagbot.facade.data.ColumnFacade;
+import com.diagbot.service.impl.StrWardRecordServiceImpl;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.MapUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.AStrWardRecordVO;
+import com.diagbot.vo.str.StrContentVO;
+import com.diagbot.vo.str.StrWardRecordVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Component
+public class StrWardRecordFacade extends StrWardRecordServiceImpl {
+
+    @Autowired
+    @Qualifier("strWardRecordServiceImpl")
+    private StrWardRecordServiceImpl strWardRecordService;
+    @Autowired
+    private ColumnFacade columnFacade;
+    @Autowired
+    private AMedAbnormalInfoFacade aMedAbnormalInfoFacade;
+    @Value("${log_switch.enable}")
+    private boolean logSwitch;
+
+    public void getColumnZhAndCh(){
+        List<ColumnZhAndChDTO> list=this.baseMapper.getColumnZhAndCh();
+        list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");
+        Boolean flag=columnFacade.createColumn(columnMap,"strWardRecord");
+
+        //Map<String, String> map=columnFacade.getColumn("strConsultationNote");
+        if(!flag){
+            return;
+        }
+    }
+
+    /**
+     * @Description:不解析时入库
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(StrContentVO strContentVO){
+        StrWardRecord strWardRecord=new StrWardRecord();
+        strWardRecord.setRecId(strContentVO.getRecId());
+        strWardRecord.setBehospitalCode(strContentVO.getBehospitalCode());
+        strWardRecord.setHospitalId(strContentVO.getHospitalId());
+        strWardRecord.setWholeData(strContentVO.getWholeData());
+        //判断数据库中是否存在，不存在insert
+        if (isExist(strWardRecord)) {
+            strWardRecord.setGmtCreate(new Date());//记录创建时间
+            this.save(strWardRecord);
+        } else {
+            strWardRecord.setGmtModified(new Date());//记录修改时间
+            this.update(strWardRecord, new QueryWrapper<StrWardRecord>()
+                    .eq("rec_id", strWardRecord.getRecId())
+                    .eq("hospital_id", strWardRecord.getHospitalId())
+                    .eq("behospital_code", strWardRecord.getBehospitalCode()));
+        }
+    }
+
+    /**
+     * @Description:解析后存储数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void dealData(String columnMap,Map<String, Object> entityMap,Long hospitalId){
+        StrWardRecord strWardRecord=new StrWardRecord();
+        try {
+            AStrWardRecordVO strWardRecordVO=(AStrWardRecordVO) MapUtil.mapToObject(entityMap, AStrWardRecordVO.class);
+            BeanUtils.copyProperties(strWardRecordVO,strWardRecord);
+            strWardRecord.setHospitalId(hospitalId);//医院编码
+
+            strWardRecord.setAuditDate(DateUtil.parseDateTime(strWardRecordVO.getAuditDate()));//审核时间
+            strWardRecord.setRecDate(DateUtil.parseDateTime(strWardRecordVO.getRecDate()));//记录时间
+            strWardRecord.setWardDate(DateUtil.parseDateTime(strWardRecordVO.getWardDate()));//查房日期
+            strWardRecord.setRecordDate(DateUtil.parseDateTime(strWardRecordVO.getRecordDate()));//病历日期
+
+            strWardRecord.setWholeData(columnMap);
+            //判断数据库中是否存在，不存在insert
+            if(isExist(strWardRecord)){
+                strWardRecord.setGmtCreate(new Date());//记录创建时间
+                this.save(strWardRecord);
+            }else{
+                strWardRecord.setGmtModified(new Date());//记录修改时间
+                this.update(strWardRecord,new QueryWrapper<StrWardRecord>()
+                        .eq("rec_id", strWardRecord.getRecId())
+                        .eq("hospital_id", strWardRecord.getHospitalId())
+                        .eq("behospital_code", strWardRecord.getBehospitalCode()));
+            }
+
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            aMedAbnormalInfoFacade.saveAbnormalInfo("查房记录", strWardRecord.getRecId(),JSON.toJSONString(entityMap),"",e.getMessage());
+        }
+
+    }
+
+    public Boolean isExist(StrWardRecord strWardRecord){
+        Boolean flag=true;
+        int count = this.baseMapper.selectCount(new QueryWrapper<StrWardRecord>()
+                .eq("rec_id", strWardRecord.getRecId())
+                .eq("hospital_id", strWardRecord.getHospitalId())
+                .eq("behospital_code", strWardRecord.getBehospitalCode()));
+        if(count>0){
+            flag=false;
+        }
+        return flag;
+    }
+
+    /**
+     * @Description:查房记录-结构化-独立入口
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public RespDTO execDealData(List<StrWardRecordVO> list){
+        try{
+            if(list!=null && list.size()>0){
+                //循环验证数据有效性
+                for (StrWardRecordVO strWardRecordVO:list) {
+                    if("".equals(strWardRecordVO.getRecId())) {
+                        return RespDTO.onError("请输入记录编号!");
+                    }else if(strWardRecordVO.getHospitalId()==null){
+                        return RespDTO.onError("请输入医院编码!");
+                    }else if("".equals(strWardRecordVO.getBehospitalCode())){
+                        return RespDTO.onError("请输入病人住院编码!");
+                    }
+                }
+                //初始、格式化数据
+                List<StrWardRecord> strWardRecordList= initData(list);
+                execute(strWardRecordList);
+
+                if(logSwitch){
+                    strWardRecordList.forEach(s->{
+                        aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-查房记录-正常", s.getRecId(), JSON.toJSONString(s), "", "");
+                    });
+                }
+                return RespDTO.onSuc("操作正常！");
+            }else{
+                return RespDTO.onError("未接收到数据!");
+            }
+        }catch (Exception e){
+            log.error(e.getMessage(),e);
+            if(list!=null && list.size()>0) {
+                list.forEach(s->{
+                    aMedAbnormalInfoFacade.saveAbnormalInfo("结构化-查房记录-异常", s.getRecId(), JSON.toJSONString(list), "", e.getMessage());
+                });
+            }
+            return RespDTO.onError("数据处理异常，详情查看日志表");
+        }
+    }
+
+    private List<StrWardRecord> initData(List<StrWardRecordVO> list) throws Exception{
+        List<StrWardRecord> tList=Lists.newArrayList();
+        for (StrWardRecordVO s:list) {
+            StrWardRecord t=new StrWardRecord();
+            BeanUtils.copyProperties(s,t);
+            if(StringUtil.isNotEmpty(s.getRecordDate())){
+                t.setRecordDate(DateUtil.parseDateTime(s.getRecordDate()));//病历日期
+            }
+            if(StringUtil.isNotEmpty(s.getRecDate())){
+                t.setRecDate(DateUtil.parseDateTime(s.getRecDate()));//记录时间
+            }
+            if(StringUtil.isNotEmpty(s.getWardDate())){
+                t.setWardDate(DateUtil.parseDateTime(s.getWardDate()));//查房日期
+            }
+            if(StringUtil.isNotEmpty(s.getAuditDate())){
+                t.setAuditDate(DateUtil.parseDateTime(s.getAuditDate()));//审核时间
+            }
+            Map<String, String> columnMap=columnFacade.getColumn(CacheKeyEnum.WARD_RECORD.getName());
+            Map<String, Object> entityMap=MapUtil.objectToMap(s);
+            Map<String, Object> wholeMap=MapUtil.objcetKeyConvert(columnMap,entityMap);
+            t.setWholeData(JSON.toJSONString(wholeMap));
+            tList.add(t);
+        }
+        return tList;
+    }
+
+    public void execute(List<StrWardRecord> list){
+        List<StrWardRecord> addE = Lists.newLinkedList();
+        List<StrWardRecord> updateE = Lists.newLinkedList();
+        if (list != null && list.size() > 0) {
+            list.stream().forEach(s -> {
+                StrWardRecord strWardRecord = this.getOne(new QueryWrapper<StrWardRecord>()
+                        .eq("is_deleted", IsDeleteEnum.N.getKey())
+                        .eq("rec_id", s.getRecId())
+                        .eq("hospital_id", s.getHospitalId())
+                        .eq("behospital_code",s.getBehospitalCode()), false);
+                if (strWardRecord != null) {
+                    s.setGmtModified(new Date());
+                    updateE.add(s);
+                } else {
+                    s.setGmtCreate(new Date());
+                    addE.add(s);
+                }
+            });
+        }
+        if(addE.size()>0){
+            strWardRecordService.saveBatch(addE);
+        }
+        if(updateE.size()>0){
+            this.baseMapper.updateBatchByKey(updateE);
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/his/HisBehospitalInfoFacade.java

@@ -0,0 +1,71 @@
+package com.lantone.data.facade.his;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.his.HisBehospitalInfo;
+import com.diagbot.service.impl.his.HisBehospitalInfoServiceImpl;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.diagbot.vo.data.HisDataImportVO;
+import com.google.common.collect.Lists;
+import io.github.lvyahui8.spring.facade.DataFacade;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Component
+@Slf4j
+public class HisBehospitalInfoFacade extends HisBehospitalInfoServiceImpl {
+
+    public List<HisBehospitalInfo> getHisBeHospitalInfoData(List<ABehospitalInfoVO> aBehospitalInfoVO) {
+        List<HisBehospitalInfo> list = Lists.newLinkedList();
+        aBehospitalInfoVO.stream().forEach(s -> {
+            HisBehospitalInfo hisBehospitalInfo = this.baseMapper.selectOne(new QueryWrapper<HisBehospitalInfo>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (hisBehospitalInfo != null) {
+                list.add(hisBehospitalInfo);
+            }
+        });
+        return list;
+    }
+
+    /*
+     * @Description:拉取指定病历号，或指定出院时间段内的病历号的所有病历号用户导入历史数据
+     * @Author:liuqq
+     * @time: ${DATE} ${TIME}
+     **/
+    public void getPatientRecord(HisDataImportVO hisDataImportVO){
+        try {
+            QueryWrapper queryWrapper=new QueryWrapper<HisBehospitalInfo>();
+            if(hisDataImportVO.getHospitalId()!=null && hisDataImportVO.getHospitalId()!=0L){
+                queryWrapper.eq("hospital_id", hisDataImportVO.getHospitalId());
+            }
+            if(StringUtil.isNotEmpty(hisDataImportVO.getBehospitalCode())){
+                queryWrapper.eq("behospital_code", hisDataImportVO.getBehospitalCode());
+            }
+            if(StringUtil.isNotEmpty(hisDataImportVO.getStartDate()) && StringUtil.isNotEmpty(hisDataImportVO.getEndDate())){
+                queryWrapper.gt("LEAVE_HOSPITAL_DATE",hisDataImportVO.getStartDate());
+                queryWrapper.lt("LEAVE_HOSPITAL_DATE",hisDataImportVO.getEndDate());
+            }
+            List<HisBehospitalInfo> list=this.baseMapper.selectList(queryWrapper);
+            if(list.size()>0){
+                List<ABehospitalInfoVO> aList=Lists.newLinkedList();
+                list.stream().forEach(s->{
+                    ABehospitalInfoVO aBehospitalInfoVO=new ABehospitalInfoVO();
+                    aBehospitalInfoVO.setBehospitalCode(s.getBehospitalCode());
+                    aList.add(aBehospitalInfoVO);
+                });
+                Map<String, Object> invokeParams = new HashMap<>();
+                invokeParams.put("aBehospitalInfoVO", list);
+                DataFacade.get("dataSupplement", invokeParams, RespDTO.class);
+            }
+        } catch (Exception e) {
+            log.error("导入历史数据异常==========",e.getMessage());
+            e.printStackTrace();
+        }
+    }
+}

data-service/src/main/java/com/lantone/data/facade/his/HisDoctorAdviceFacade.java

@@ -0,0 +1,28 @@
+package com.lantone.data.facade.his;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.entity.his.HisDoctorAdvice;
+import com.diagbot.service.impl.his.HisDoctorAdviceServiceImpl;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class HisDoctorAdviceFacade extends HisDoctorAdviceServiceImpl {
+
+    public List<List<HisDoctorAdvice>> getHisDoctorAdviceData(List<ABehospitalInfoVO> aBehospitalInfoVO) {
+
+        List<List<HisDoctorAdvice>> list = Lists.newLinkedList();
+        aBehospitalInfoVO.stream().forEach(s -> {
+            List<HisDoctorAdvice> hisDoctorAdvice = this.baseMapper.selectList(new QueryWrapper<HisDoctorAdvice>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (hisDoctorAdvice != null && hisDoctorAdvice.size() > 0) {
+                list.add(hisDoctorAdvice);
+            }
+        });
+        return list;
+    }
+}

data-service/src/main/java/com/lantone/data/facade/his/HisHomeDiagnoseInfoFacade.java

@@ -0,0 +1,28 @@
+package com.lantone.data.facade.his;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.entity.his.HisHomeDiagnoseInfo;
+import com.diagbot.service.impl.his.HisHomeDiagnoseInfoServiceImpl;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class HisHomeDiagnoseInfoFacade extends HisHomeDiagnoseInfoServiceImpl {
+
+    public List<List<HisHomeDiagnoseInfo>> getHisHomeDiagnoseInfoData(List<ABehospitalInfoVO> aBehospitalInfoVO) {
+
+        List<List<HisHomeDiagnoseInfo>> list = Lists.newLinkedList();
+        aBehospitalInfoVO.stream().forEach(s -> {
+            List<HisHomeDiagnoseInfo> hisHomeDiagnoseInfo = this.baseMapper.selectList(new QueryWrapper<HisHomeDiagnoseInfo>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (hisHomeDiagnoseInfo != null && hisHomeDiagnoseInfo.size() > 0) {
+                list.add(hisHomeDiagnoseInfo);
+            }
+        });
+        return list;
+    }
+}

data-service/src/main/java/com/lantone/data/facade/his/HisHomeOperationInfoFacade.java

@@ -0,0 +1,28 @@
+package com.lantone.data.facade.his;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.entity.his.HisHomeOperationInfo;
+import com.diagbot.service.impl.his.HisHomeOperationInfoServiceImpl;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class HisHomeOperationInfoFacade extends HisHomeOperationInfoServiceImpl {
+
+    public List<List<HisHomeOperationInfo>> getHisHomeOperationInfoData(List<ABehospitalInfoVO> aBehospitalInfoVO) {
+
+        List<List<HisHomeOperationInfo>> list = Lists.newLinkedList();
+        aBehospitalInfoVO.stream().forEach(s -> {
+            List<HisHomeOperationInfo> hisHomeOperationInfo = this.baseMapper.selectList(new QueryWrapper<HisHomeOperationInfo>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (hisHomeOperationInfo != null && hisHomeOperationInfo.size() > 0) {
+                list.add(hisHomeOperationInfo);
+            }
+        });
+        return list;
+    }
+}

data-service/src/main/java/com/lantone/data/facade/his/HisHomePageFacade.java

@@ -0,0 +1,27 @@
+package com.lantone.data.facade.his;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.entity.his.HisHomePage;
+import com.diagbot.service.impl.his.HisHomePageServiceImpl;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class HisHomePageFacade extends HisHomePageServiceImpl {
+
+    public List<HisHomePage> getHomePageData(List<ABehospitalInfoVO> aBehospitalInfoVO) {
+        List<HisHomePage> list = Lists.newLinkedList();
+        aBehospitalInfoVO.stream().forEach(s -> {
+            HisHomePage hisHomePage = this.baseMapper.selectOne(new QueryWrapper<HisHomePage>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (hisHomePage != null) {
+                list.add(hisHomePage);
+            }
+        });
+        return list;
+    }
+}

data-service/src/main/java/com/lantone/data/facade/his/HisMedicalRecordContentFacade.java

@@ -0,0 +1,26 @@
+package com.lantone.data.facade.his;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.entity.his.HisMedicalRecordContent;
+import com.diagbot.service.impl.his.HisMedicalRecordContentServiceImpl;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class HisMedicalRecordContentFacade extends HisMedicalRecordContentServiceImpl {
+    public List<List<HisMedicalRecordContent>> getHisMedicalRecordContentData(List<ABehospitalInfoVO> aBehospitalInfoVO) {
+        List<List<HisMedicalRecordContent>> list = Lists.newLinkedList();
+        aBehospitalInfoVO.stream().forEach(s -> {
+            List<HisMedicalRecordContent> hisMedicalRecordContent = this.baseMapper.selectList(new QueryWrapper<HisMedicalRecordContent>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (hisMedicalRecordContent != null && hisMedicalRecordContent.size() > 0) {
+                list.add(hisMedicalRecordContent);
+            }
+        });
+        return list;
+    }
+}

data-service/src/main/java/com/lantone/data/facade/his/HisMedicalRecordFacade.java

@@ -0,0 +1,26 @@
+package com.lantone.data.facade.his;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.entity.his.HisMedicalRecord;
+import com.diagbot.service.impl.his.HisMedicalRecordServiceImpl;
+import com.diagbot.vo.data.ABehospitalInfoVO;
+import com.google.common.collect.Lists;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class HisMedicalRecordFacade extends HisMedicalRecordServiceImpl {
+    public List<List<HisMedicalRecord>> getHisMedicalRecordData(List<ABehospitalInfoVO> aBehospitalInfoVO) {
+        List<List<HisMedicalRecord>> list = Lists.newLinkedList();
+        aBehospitalInfoVO.stream().forEach(s -> {
+            List<HisMedicalRecord> hisMedicalRecord = this.baseMapper.selectList(new QueryWrapper<HisMedicalRecord>()
+                    .eq("behospital_code", s.getBehospitalCode())
+                    .eq("hospital_id", s.getHospitalId()));
+            if (hisMedicalRecord != null) {
+                list.add(hisMedicalRecord);
+            }
+        });
+        return list;
+    }
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrAdmissionNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrAdmissionNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 入院记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrAdmissionNoteMapper extends BaseMapper<StrAdmissionNote> {
+
+    void updateBatchByKey(List<StrAdmissionNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrBloodResultMapper.java

@@ -0,0 +1,21 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrBloodResult;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 输血效果评价 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrBloodResultMapper extends BaseMapper<StrBloodResult> {
+    void updateBatchByKey(List<StrBloodResult> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrBloodTransfusionMapper.java

@@ -0,0 +1,21 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrBloodTransfusion;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 输血记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrBloodTransfusionMapper extends BaseMapper<StrBloodTransfusion> {
+    void updateBatchByKey(List<StrBloodTransfusion> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrConsultationApplyMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrConsultationApply;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 会诊申请单 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrConsultationApplyMapper extends BaseMapper<StrConsultationApply> {
+
+    void updateBatchByKey(List<StrConsultationApply> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrConsultationNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrConsultationNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 会诊单（申请和结果） Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrConsultationNoteMapper extends BaseMapper<StrConsultationNote> {
+
+    void updateBatchByKey(List<StrConsultationNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrConsultationRecordMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrConsultationRecord;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 会诊记录 Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-11-13
+ */
+public interface StrConsultationRecordMapper extends BaseMapper<StrConsultationRecord> {
+
+    void updateBatchByKey(List<StrConsultationRecord> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrConsultationResultMapper.java

@@ -0,0 +1,13 @@
+package com.lantone.data.mapper.dataStr;
+
+/**
+ * <p>
+ * 会诊结果单 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrConsultationResultMapper{
+
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrCrisisNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrCrisisNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 危急值记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrCrisisNoteMapper extends BaseMapper<StrCrisisNote> {
+
+    void updateBatchByKey(List<StrCrisisNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrDeathDiscussionMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrDeathDiscussion;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 死亡病例讨论记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrDeathDiscussionMapper extends BaseMapper<StrDeathDiscussion> {
+    void updateBatchByKey(List<StrDeathDiscussion> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrDeathNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrDeathNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 死亡记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrDeathNoteMapper extends BaseMapper<StrDeathNote> {
+    void updateBatchByKey(List<StrDeathNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrDifficultCaseMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrDifficultCase;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 疑难病例讨论记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrDifficultCaseMapper extends BaseMapper<StrDifficultCase> {
+
+    void updateBatchByKey(List<StrDifficultCase> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrFirstRecordMapper.java

@@ -0,0 +1,21 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrFirstRecord;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 首次病程录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrFirstRecordMapper extends BaseMapper<StrFirstRecord> {
+    void updateBatchByKey(List<StrFirstRecord> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrIllCriticallyMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrIllCritically;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 病危通知单 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrIllCriticallyMapper extends BaseMapper<StrIllCritically> {
+    void updateBatchByKey(List<StrIllCritically> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrIllSeriouslMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrIllSeriousl;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 病重通知单 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrIllSeriouslMapper extends BaseMapper<StrIllSeriousl> {
+
+    void updateBatchByKey(List<StrIllSeriousl> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrInformedConsentMapper.java

@@ -0,0 +1,21 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrInformedConsent;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-01-04
+ */
+public interface StrInformedConsentMapper extends BaseMapper<StrInformedConsent> {
+    void updateBatchByKey(List<StrInformedConsent> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrLeaveHospitalMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrLeaveHospital;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 出院小结 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrLeaveHospitalMapper extends BaseMapper<StrLeaveHospital> {
+
+    void updateBatchByKey(List<StrLeaveHospital> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrOperativeFirstRecordMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrOperativeFirstRecord;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 术后首程 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrOperativeFirstRecordMapper extends BaseMapper<StrOperativeFirstRecord> {
+
+    void updateBatchByKey(List<StrOperativeFirstRecord> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrOperativeNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrOperativeNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 手术记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrOperativeNoteMapper extends BaseMapper<StrOperativeNote> {
+
+    void updateBatchByKey(List<StrOperativeNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrPeriodConclusionMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrPeriodConclusion;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 阶段小结 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrPeriodConclusionMapper extends BaseMapper<StrPeriodConclusion> {
+
+    void updateBatchByKey(List<StrPeriodConclusion> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrPreoperativeDiscussionMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrPreoperativeDiscussion;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 术前讨论小结 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrPreoperativeDiscussionMapper extends BaseMapper<StrPreoperativeDiscussion> {
+
+    void updateBatchByKey(List<StrPreoperativeDiscussion> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrRescueNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrRescueNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 抢救记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrRescueNoteMapper extends BaseMapper<StrRescueNote> {
+
+    void updateBatchByKey(List<StrRescueNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrTalkInformMapper.java

@@ -0,0 +1,23 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrTalkInform;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-01-04
+ */
+public interface StrTalkInformMapper extends BaseMapper<StrTalkInform> {
+
+    void updateBatchByKey(List<StrTalkInform> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrTotalInfoMapper.java

@@ -0,0 +1,16 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.entity.StrTotalInfo;
+
+/**
+ * <p>
+ * 结构化文书异常监察表 Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-03-12
+ */
+public interface StrTotalInfoMapper extends BaseMapper<StrTotalInfo> {
+
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrTransferInNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrTransferInNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 转入记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrTransferInNoteMapper extends BaseMapper<StrTransferInNote> {
+
+    void updateBatchByKey(List<StrTransferInNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrTransferOutNoteMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrTransferOutNote;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 转出记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrTransferOutNoteMapper extends BaseMapper<StrTransferOutNote> {
+
+    void updateBatchByKey(List<StrTransferOutNote> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+}

data-service/src/main/java/com/lantone/data/mapper/dataStr/StrWardRecordMapper.java

@@ -0,0 +1,22 @@
+package com.lantone.data.mapper.dataStr;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.data.ColumnZhAndChDTO;
+import com.diagbot.entity.StrWardRecord;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 查房记录 Mapper 接口
+ * </p>
+ *
+ * @author cy
+ * @since 2020-09-22
+ */
+public interface StrWardRecordMapper extends BaseMapper<StrWardRecord> {
+    void updateBatchByKey(List<StrWardRecord> list);
+
+    List<ColumnZhAndChDTO> getColumnZhAndCh();
+
+}

data-service/src/main/java/com/lantone/data/service/data/BasDeptInfoService.java

@@ -0,0 +1,32 @@
+package com.lantone.data.service.data;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.dto.BasDeptInfoDTO;
+import com.diagbot.dto.DeptBaseDTO;
+import com.diagbot.entity.BasDeptInfo;
+import com.diagbot.vo.BasDeptInfoVO;
+import com.diagbot.vo.FilterVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 医院科室信息 服务类
+ * </p>
+ *
+ * @author gaodm
+ * @since 2020-04-27
+ */
+public interface BasDeptInfoService extends IService<BasDeptInfo> {
+    List<BasDeptInfoDTO> getList(BasDeptInfoVO basDeptInfoVO);
+
+    List<BasDeptInfoDTO> getListUser(BasDeptInfoVO basDeptInfoVO);
+
+    /**
+     * 查询用户关联科室
+     *
+     * @param filterVO
+     * @return
+     */
+    List<DeptBaseDTO> getDeptByUser(FilterVO filterVO);
+}

data-service/src/main/java/com/lantone/data/service/data/BasDoctorInfoService.java

@@ -0,0 +1,16 @@
+package com.lantone.data.service.data;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.BasDoctorInfo;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author gaodm
+ * @since 2020-04-17
+ */
+public interface BasDoctorInfoService extends IService<BasDoctorInfo> {
+
+}

data-service/src/main/java/com/lantone/data/service/data/BasHospitalInfoService.java

@@ -0,0 +1,16 @@
+package com.lantone.data.service.data;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.BasHospitalInfo;
+
+/**
+ * <p>
+ * 医院信息表 服务类
+ * </p>
+ *
+ * @author gaodm
+ * @since 2020-04-12
+ */
+public interface BasHospitalInfoService extends IService<BasHospitalInfo> {
+
+}

data-service/src/main/java/com/lantone/data/service/data/BehospitalInfoService.java

@@ -0,0 +1,695 @@
+package com.lantone.data.service.data;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.dto.*;
+import com.diagbot.entity.BehospitalInfo;
+import com.diagbot.vo.*;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p>
+ * 住院病历信息 服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-04-13
+ */
+public interface BehospitalInfoService extends IService<BehospitalInfo> {
+
+    public IPage<BehospitalInfoDTO> getPage(BehospitalPageVO behospitalPageVO);
+
+    public List<MsgDTO> getMsg(AnalyzeVO analyzeVO);
+
+    public List<MsgDTO> getMsgByEntryCode(AnalyzeCodeVO analyzeCodeVO);
+
+    /**
+     * 各科室缺陷占比-全院-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<NumDTO> entryByDept(FilterVO filterVO);
+
+    /**
+     * 质控结果缺陷总数查询
+     *
+     * @param filterVO
+     * @return
+     */
+    public int getTotleResultNum(FilterVO filterVO);
+
+
+    public List<BehospitalInfo> getNoGrade(TaskVO taskVO);
+
+    IPage<BehospitalInfoDTO> getPageByDept(BehospitalPageVO behospitalPageVO);
+
+    IPage<BehospitalInfoDTO> getPageByPerson(BehospitalPageVO behospitalPageVO);
+
+    IPage<BehospitalInfoDTO> getPageByGroup(BehospitalPageVO behospitalPageVO);
+
+    /**
+     * 出院总人数统计-全院-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public int leaveHosCount(FilterVO filterVO);
+
+    /**
+     * 新生儿出院人数统计-全院-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public int newBornCount(FilterVO filterVO);
+
+    /**
+     * 死亡人数统计-全院-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public int deathCount(FilterVO filterVO);
+
+    /**
+     * 手术人数统计-全院-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public int operationCount(FilterVO filterVO);
+    /**
+     * 病案管理指标（内页）
+     *
+     * @param timeVo
+     * @return
+     */
+    public Map<String,Object> getBaseIndex( MedIndexFilterVO timeVo);
+
+    /**
+     * 病案管理规则质控参数查询
+     *
+     * @param filterVO
+     * @return
+     */
+    public Map<String,Object> getCountByEntry( FilterVO filterVO);
+
+    /**
+     * 病案管理规则质控病历参数查询
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<MedManageParamsDTO> getMedManageParams( FilterVO filterVO);
+
+
+
+
+    /**
+     * 出院总人数统计-科室-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<NumDTO> leaveHosCountByDept(FilterVO filterVO);
+
+    /**
+     * 病历质控报表-科室
+     *
+     * @param behospitalPageVO
+     * @return
+     */
+    public IPage<QualityControlDeptDTO> qualityControlByDept(BehospitalPageVO behospitalPageVO);
+
+    /**
+     * 入院总人数统计-科室-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<AdmissionCountDTO> admissionHosCountByDept(FilterVO filterVO);
+
+
+    /**
+     * 新生儿出院人数统计-科室-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<NumDTO> newBornCountByDept(FilterVO filterVO);
+
+    /**
+     * 死亡人数统计-科室-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<NumDTO> deathCountByDept(FilterVO filterVO);
+
+    /**
+     * 手术人数统计-科室-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<NumDTO> operationCountByDept(FilterVO filterVO);
+
+    /**
+     * 各科室缺陷占比排行（分页）
+     *
+     * @param filterPageVO
+     * @return
+     */
+    public IPage<NumDTO> resultStatisticsByDeptPage(@Param("filterPageVO") FilterPageVO filterPageVO);
+
+    /**
+     * 各科室缺陷占比（组合）
+     *
+     * @param filterOrderVO
+     * @return
+     */
+    public List<LevelStatisticsDTO> levelStatistics(FilterOrderVO filterOrderVO);
+
+    /**
+     * 病案首页合格率占比
+     *
+     * @param filterOrderVO
+     * @return
+     */
+    public List<HomePageNumDTO> homePageLevelStatistics(FilterOrderVO filterOrderVO);
+
+    /**
+     * 医师病案首页合格率占比 湘雅定制
+     *
+     * @param filterOrderXYPageVO
+     * @return
+     */
+    public IPage<HomePageNumXYDTO> homePageLevelStatisticsXY(FilterOrderXYPageVO filterOrderXYPageVO);
+
+
+
+    /**
+     * 病历质控报表-扣分项
+     *
+     * @param caseScoreVO
+     * @return
+     */
+    public List<QualityControlDTO> getQualityCase(CaseScoreVO caseScoreVO);
+
+    /**
+     * 病历质控报表-扣分
+     *
+     * @param caseScoreVO
+     * @return
+     */
+    public List<QualityControlDTO> getQualitySorce(CaseScoreVO caseScoreVO);
+
+    /**
+     * 病历质控报表
+     *
+     * @param caseScoreVO
+     * @return
+     */
+    public List<CaseScoreDTO> getQualityCaseSorce(CaseScoreVO caseScoreVO);
+
+    /**
+     * 病历质控报表-科室
+     *
+     * @param caseScoreVO
+     * @return
+     */
+    public List<CaseScoreDTO> getQualityCaseSorceByDept(CaseScoreVO caseScoreVO);
+
+
+
+
+    /**
+     * 病历质控报表
+     *
+     * @param behospitalPageVO
+     * @return
+     */
+    public IPage<QualityControlDTO> getQualityControl(BehospitalPageVO behospitalPageVO);
+
+    /**
+     * 病历质控报表-科室
+     *
+     * @param behospitalPageVO
+     * @return
+     */
+    public IPage<QualityControlDTO> getQualityControlExport(BehospitalPageVO behospitalPageVO);
+
+    /**
+     * 各科室缺陷占比（主任医生）
+     *
+     * @param filterOrderVO
+     * @return
+     */
+    public List<LevelStsByDeptDTO> levelStatisticsByDept( FilterOrderVO filterOrderVO);
+
+    /**
+     * 单条条目缺陷统计-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<AdmissionCountDTO> casesEntryStatisticsByDept(FilterVO filterVO);
+
+    /**
+     * 病案首页合格率占比（主任医生）
+     *
+     * @param filterOrderByDeptVO
+     * @return
+     */
+    public List<HomePageByDeptDTO> homePageLevelStatisticsByDept(FilterOrderByDeptVO filterOrderByDeptVO);
+
+
+    /**
+     * 缺陷明细-科室（分页）
+     *
+     * @param filterPageByDeptVO
+     * @return
+     */
+    public IPage<DeptNumDTO> resultStatisticsByDeptAndDoctorPage(@Param("filterPageByDeptVO") FilterPageByDeptVO filterPageByDeptVO);
+
+    /**
+     * 各科室缺陷占比（组合）-全院-根据内外科系统统计（关联上级科室）
+     *
+     * @param filterOrderVO
+     * @return
+     */
+    public List<LevelStatisticsTZDTO> levelStatisticsByDeptClass(FilterOrderVO filterOrderVO);
+
+    /**
+     * 各科室缺陷占比（组合）-全院-根据内外科系统统计（台州）
+     *
+     * @param filterOrderVO
+     * @return
+     */
+    public List<LevelStatisticsTZDTO> levelStatisticsByDeptClass_TZ(FilterOrderVO filterOrderVO);
+
+    List<ExportExcelDTO> exportExcel();
+
+    /**
+     * 质控评分导出到excel
+     *
+     * @param exportQcresultVO
+     * @return
+     */
+    public List<ExportExcelDTO> exportQcresult(ExportQcresultVO exportQcresultVO);
+
+    /**
+     * 个人质控评分导出到excel
+     *
+     * @param exportQcresultVO
+     * @return
+     */
+    public List<ExportExcelDTO> exportQcresultByPerson(ExportQcresultVO exportQcresultVO);
+
+
+    /**
+     * 科室质控评分导出到excel
+     *
+     * @param exportQcresultVO
+     * @return
+     */
+    public List<ExportExcelDTO> exportQcresultByDept(ExportQcresultVO exportQcresultVO);
+
+    /**
+     * 科室质控评分导出到excel
+     *
+     * @param exportQcresultVO
+     * @return
+     */
+    public List<ExportExcelDTO> exportQcresultByGroup(ExportQcresultVO exportQcresultVO);
+
+    /**
+     * 条目缺陷质控评分页（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> qcResultShortPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 条目缺陷质控评分页-科室（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> qcResultShortByDeptPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 关键条目缺陷占比统计
+     *
+     * @param entryStatisticsVO
+     * @return
+     */
+    public List<EntryStatisticsDTO> entryStatistics(EntryStatisticsVO entryStatisticsVO);
+
+    /**
+     * 关键条目缺陷占比统计-科室
+     *
+     * @param entryStatisticsVO
+     * @return
+     */
+    public List<EntryStasByDeptDTO> entryStatisticsByDept(EntryStatisticsVO entryStatisticsVO);
+
+
+
+
+    /**
+     * 非医嘱离院病人记录
+     *
+     * @param filterVO
+     * @return
+     */
+    public int nonAdviceCount(FilterVO filterVO);
+
+    /**
+     * 31天内再入院记录
+     *
+     * @param filterVO
+     * @return
+     */
+    public int get31DaysBehospitalCount(FilterVO filterVO);
+
+    /**
+     * 病案首页质控病历数统计-全院（首页）
+     *
+     * @param filterVO
+     * @return
+     */
+    public HomePageNumDTO homePageQcPercent(FilterVO filterVO);
+
+    /**
+     * 病案首页完整率统计-全院（首页）
+     *
+     * @param filterVO
+     * @return
+     */
+    public HomePageNumDTO hmEmptyEntryPercent(FilterVO filterVO);
+
+    /**
+     * 离院病人质控评分详情页
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> leaveHosMRPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 离院病人质控评分详情页-科室
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> leaveHosMRPageByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 改善率统计-全院（首页）
+     *
+     * @param filterVO
+     * @return
+     */
+    public HomePageImproveDTO homePageImproveCount(FilterVO filterVO);
+
+    /**
+     * 质控核查统计（内页）
+     *
+     * @param filterOrderVO
+     * @return
+     */
+    public List<HomePageImproveDTO> qcCheckStatistics(FilterOrderVO filterOrderVO);
+
+    /**
+     * 质控核查统计-科室（内页）
+     *
+     * @param filterOrderVO
+     * @return
+     */
+    public List<ImproveByDeptDTO> qcCheckStatisticsByDept(FilterOrderVO filterOrderVO);
+
+    /**
+     * 离院病人质控评分详情页导出到excel
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelDTO> leaveHosMRPageExport(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 离院病人质控评分详情-科室 页导出到excel
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelByDeptDTO> leaveHosMRPageExportByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+
+    /**
+     * 条目缺陷质控评分详情页导出到excel
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelDTO> qcResultShortPageExport(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 缺陷详情质控评分页导出-科室
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelByDeptDTO> qcResultShortByDeptPageExport(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 未整改病历统计
+     *
+     * @param filterUnModifyMRVO
+     * @return
+     */
+    public List<UnModifyMRDetailDTO> unModifyMRStatistics(FilterUnModifyMRVO filterUnModifyMRVO);
+
+    /**
+     * 未整改病历统计-科室
+     *
+     * @param filterUnModifyMRVO
+     * @return
+     */
+    public List<UnModifyMRDetailDTO> unModifyMRSByDept(FilterUnModifyMRVO filterUnModifyMRVO);
+
+    /**
+     * 病历稽查表
+     * @return
+     */
+    IPage<MedicalCheckDTO>  getMedicalCheck(FilterMedicalCheckVO filterVO,@Param("casesEntryIds")List<Long> casesEntryIds);
+
+    /**
+     * 病历稽查表
+     * @return
+     */
+    IPage<MedicalCheckDTO>  getMedicalChecks(FilterMedicalCheckVO filterVO,@Param("casesEntryIds")List<Long> casesEntryIds);
+
+    /**
+     * 病历稽查表导出
+     * @return
+     */
+    List<MedicalCheckExportDTO>  getMedicalCheckExport(FilterMedicalCheckVO filterVO);
+
+    /**
+     * 病历稽查表导出-科室
+     * @return
+     */
+    List<MedicalDeptDTO>  medicalCheckExportByDept(FilterMedicalCheckVO filterVO);
+
+
+
+    /**
+     * 未整改病历质控评分页（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> unModifyMRPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 未整改病历质控评分页-科室（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> unModifyMRByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 不合格数病历号（内页）
+     * @param qcResultPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> badLevelPage(@Param("qcResultPageVO") QcResultPageVO qcResultPageVO);
+
+    /**
+     * 未整改病历缺陷评分详情页导出
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelDTO> unModifyMRPageExport(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+
+    /**
+     * 未整改病历缺陷评分详情页导出-科室
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelByDeptDTO> unModifyExportByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+
+    /**
+     * 病案首页不合格/合格数病历详情页导出
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelDTO> badLevelPagePageExport(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+    /**
+     * 病案首页不合格/合格数病历详情页导出-科室
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelByDeptDTO> homePageOrLevelExportByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+
+
+    /**
+     * 31天再入院详情页
+     *
+     * @param reBeHosPageVO
+     * @return
+     */
+    public IPage<ReBeHosMergeDTO> reHos31DaysPage(@Param("reBeHosPageVO") ReBeHosPageVO reBeHosPageVO);
+
+    /**
+     * 31天再入院详情页
+     *
+     * @param reBeHosPageVO
+     * @return
+     */
+    public IPage<ReBeHosMergeDTO> reHos31DaysPageByDept(@Param("reBeHosPageVO") ReBeHosPageVO reBeHosPageVO);
+
+    /**
+     * 入院人数统计-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<NumDTO> beHosCount(FilterVO filterVO);
+
+    /**
+     * 单条条目缺陷统计-首页
+     *
+     * @param filterVO
+     * @return
+     */
+    public List<NumDTO> casesEntryStatisticsById(FilterVO filterVO);
+
+    /**
+     * 病案首页改善率质控评分页（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> hmImproveMRPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+    /**
+     * 病案首页改善率质控评分页-科室（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> hmImproveMRPageByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 病案首页改善率质控评分页导出
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelDTO> hmImproveMRPageExport(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 病案首页改善率质控评分页导出-科室
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelByDeptDTO> improveMRExportByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 质控核查质控评分页（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> qcCheckMRPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+
+    /**
+     * 质控核查质控评分页-科室（内页）
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public IPage<QcResultShortDTO> qcCheckMRPageByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 质控核查质控评分页导出
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelDTO> qcCheckMRPageExport(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+    /**
+     * 质控核查质控评分页-科室 导出
+     *
+     * @param qcResultShortPageVO
+     * @return
+     */
+    public List<ExportExcelByDeptDTO> qcCheckMRPageExportByDept(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO);
+
+
+    /**
+     * 手术费，抗菌药物，手术和病理费等含有人数
+     * @param filterVO
+     * @return
+     */
+    public List<Map<String, String>> selectOperationNum(@Param("filterVO")FilterVO filterVO);
+
+    /**
+     * 触发规则人数
+     * @param filterVO
+     * @return
+     */
+    public Map<String,Long> triggeringRules(@Param("filterVO")FilterVO filterVO);
+
+    /**
+     * 病案首页关联的出院病历
+     * @param filterVO
+     * @return
+     */
+    public List<Map<String,String>> getMedicalRecords(@Param("filterVO") FilterVO filterVO);
+
+    /**
+     * 首页恶性肿瘤人数
+     * @param filterVO
+     * @return
+     */
+    public List<Map<String,String>> malignancy(@Param("filterVO") FilterVO filterVO);
+
+}

data-service/src/main/java/com/lantone/data/service/data/ColumnService.java

@@ -0,0 +1,21 @@
+package com.lantone.data.service.data;
+
+import java.util.Map;
+
+public interface ColumnService {
+    /**
+     * 创建
+     *
+     * @param
+     * @return
+     */
+    Boolean createColumn(Map<String, String> columnMap, String tableResKey);
+
+    /**
+     * 获取用户jwt
+     *
+     * @param tableResKey redis的key
+     * @return jwt信息
+     */
+    Map<String, String> getColumn(String tableResKey);
+}

data-service/src/main/java/com/lantone/data/service/data/DoctorAdviceService.java

@@ -0,0 +1,30 @@
+package com.lantone.data.service.data;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.dto.DoctorAdviceDTO;
+import com.diagbot.entity.DoctorAdvice;
+import com.diagbot.vo.DoctorAdviceVO;
+import com.diagbot.vo.FilterVO;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p>
+ * 病人医嘱 服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-04-13
+ */
+public interface DoctorAdviceService extends IService<DoctorAdvice> {
+
+    IPage<DoctorAdviceDTO> getPage(DoctorAdviceVO doctorAdviceVO);
+
+
+
+    List<Map<String, String>> getDoctorAdviceNum(FilterVO filterVO);
+
+
+}

data-service/src/main/java/com/lantone/data/service/his/HisBehospitalInfoService.java

@@ -0,0 +1,9 @@
+package com.lantone.data.service.his;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.his.HisBehospitalInfo;
+
+public interface HisBehospitalInfoService extends IService<HisBehospitalInfo> {
+
+
+}

data-service/src/main/java/com/lantone/data/service/his/HisDoctorAdviceService.java

@@ -0,0 +1,7 @@
+package com.lantone.data.service.his;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.his.HisDoctorAdvice;
+
+public interface HisDoctorAdviceService extends IService<HisDoctorAdvice> {
+}

data-service/src/main/java/com/lantone/data/service/his/HisHomeDiagnoseInfoService.java

@@ -0,0 +1,16 @@
+package com.lantone.data.service.his;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.his.HisHomeDiagnoseInfo;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-04-13
+ */
+public interface HisHomeDiagnoseInfoService extends IService<HisHomeDiagnoseInfo> {
+
+}

data-service/src/main/java/com/lantone/data/service/his/HisHomeOperationInfoService.java

@@ -0,0 +1,16 @@
+package com.lantone.data.service.his;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.his.HisHomeOperationInfo;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-04-13
+ */
+public interface HisHomeOperationInfoService extends IService<HisHomeOperationInfo> {
+
+}

data-service/src/main/java/com/lantone/data/service/his/HisHomePageService.java

@@ -0,0 +1,16 @@
+package com.lantone.data.service.his;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.his.HisHomePage;
+
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-04-13
+ */
+public interface HisHomePageService extends IService<HisHomePage> {
+}

data-service/src/main/java/com/lantone/data/service/his/HisMedicalRecordService.java

@@ -0,0 +1,7 @@
+package com.lantone.data.service.his;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.entity.his.HisMedicalRecord;
+
+public interface HisMedicalRecordService extends IService<HisMedicalRecord> {
+}

data-service/src/main/java/com/lantone/data/service/impl/data/BasDeptInfoServiceImpl.java

@@ -0,0 +1,55 @@
+package com.lantone.data.service.impl.data;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.diagbot.dto.BasDeptInfoDTO;
+import com.diagbot.dto.DeptBaseDTO;
+import com.diagbot.entity.BasDeptInfo;
+import com.diagbot.mapper.BasDeptInfoMapper;
+import com.diagbot.service.BasDeptInfoService;
+import com.diagbot.vo.BasDeptInfoVO;
+import com.diagbot.vo.FilterVO;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 医院科室信息 服务实现类
+ * </p>
+ *
+ * @author gaodm
+ * @since 2020-04-27
+ */
+@Service
+public class BasDeptInfoServiceImpl extends ServiceImpl<BasDeptInfoMapper, BasDeptInfo> implements BasDeptInfoService {
+
+    @Override
+    public List<BasDeptInfoDTO> getList(BasDeptInfoVO basDeptInfoVO) {
+        return baseMapper.getList(basDeptInfoVO);
+    }
+
+    @Override
+    public List<BasDeptInfoDTO> getListUser(BasDeptInfoVO basDeptInfoVO) {
+        return baseMapper.getListUser(basDeptInfoVO);
+    }
+
+    /**
+     * 查询用户关联科室
+     *
+     * @param filterVO
+     * @return
+     */
+    @Override
+    public List<DeptBaseDTO> getDeptByUser(FilterVO filterVO) {
+        return baseMapper.getDeptByUser(filterVO);
+    }
+
+
+    /**
+     * 根据科室编码，医院编码，批量修改
+     * @param list
+     */
+    public void updateBatchByKey(List<BasDeptInfo> list){
+        this.baseMapper.updateBatchByKey(list);
+    }
+}

data-service/src/main/java/com/lantone/data/service/impl/data/BasDoctorInfoServiceImpl.java

@@ -0,0 +1,59 @@
+package com.lantone.data.service.impl.data;
+
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.diagbot.entity.BasDoctorInfo;
+import com.diagbot.mapper.BasDoctorInfoMapper;
+import com.diagbot.service.BasDoctorInfoService;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author gaodm
+ * @since 2020-04-17
+ */
+@Service
+public class BasDoctorInfoServiceImpl extends ServiceImpl<BasDoctorInfoMapper, BasDoctorInfo> implements BasDoctorInfoService {
+    /**
+     * 根据医生编码和医院编码，批量更新
+     * @param list
+     */
+    public void updateBatchByKey(List<BasDoctorInfo> list) throws Exception{
+        this.baseMapper.updateBatchByKey(list);
+    }
+
+    /**
+     * 根据医生编码和医院编码，批量更新
+     * @param list
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public boolean updateBatchByKey(List<BasDoctorInfo> list,int batchSize){
+        try{
+            int i=0;
+
+            for (BasDoctorInfo basDoctorInfo:list) {
+                if (i >= 1 && i % batchSize == 0) {
+                    /*this.baseMapper.updateBatchByKey(list.subList(0,i));*/
+                    UpdateWrapper<BasDoctorInfo> updateWrapper = new UpdateWrapper<>();
+                    updateWrapper
+                            .eq("doctor_id", basDoctorInfo.getDoctorId())
+                            .eq("hospital_id", basDoctorInfo.getHospitalId());
+                    this.saveOrUpdateBatch(list,100);
+                    i=0;
+                }
+                i++;
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+}

data-service/src/main/java/com/lantone/data/service/impl/data/BasHospitalInfoServiceImpl.java

@@ -0,0 +1,21 @@
+package com.lantone.data.service.impl.data;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.diagbot.entity.BasHospitalInfo;
+import com.diagbot.mapper.BasHospitalInfoMapper;
+import com.diagbot.service.BasHospitalInfoService;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ * 医院信息表 服务实现类
+ * </p>
+ *
+ * @author gaodm
+ * @since 2020-04-12
+ */
+@Service
+public class BasHospitalInfoServiceImpl extends ServiceImpl<BasHospitalInfoMapper, BasHospitalInfo> implements BasHospitalInfoService {
+
+
+}

data-service/src/main/java/com/lantone/data/service/impl/data/ColumnServiceImpl.java

@@ -0,0 +1,73 @@
+package com.lantone.data.service.impl.data;
+
+import com.diagbot.service.ColumnService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.dao.DataAccessException;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.core.RedisCallback;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.util.Map;
+
+@Slf4j
+@Service
+public class ColumnServiceImpl implements ColumnService {
+    @Autowired
+    @Qualifier("redisTemplateForTable")
+    RedisTemplate redisForTable;
+
+    private byte[] serializeKey(Object o) {
+        return redisForTable.getKeySerializer().serialize(o);
+    }
+
+    private byte[] serializeValue(Object o) {
+        return redisForTable.getValueSerializer().serialize(o);
+    }
+
+    private Object deserializeValue(byte[] b) {
+        return redisForTable.getValueSerializer().deserialize(b);
+    }
+
+    @Override
+    public Boolean createColumn(Map<String, String> columnMap, String tableResKey) {
+        final byte[] redis_key = serializeKey(tableResKey);
+        redisForTable.execute(new RedisCallback<Object>() {
+            @Override
+            public Object doInRedis(RedisConnection connection) throws DataAccessException {
+                //获取旧的
+                byte[] bytes = connection.get(redis_key);
+                //删除旧的
+                if (bytes != null) {
+                    connection.del(bytes);
+                }
+                //设置新的
+                connection.setNX(redis_key,serializeValue(columnMap));
+                return true;
+            }
+        });
+        return true;
+    }
+
+    @Override
+    public Map<String, String> getColumn(String tableResKey) {
+        final byte[] redis_key =serializeKey(tableResKey);
+        Map<String, String> columnMap=(Map<String, String>)redisForTable.execute(new RedisCallback<Map<String, String>>() {
+            @Override
+            public Map<String, String> doInRedis(RedisConnection connection) throws DataAccessException {
+                byte[] bytes = connection.get(redis_key);
+                if (bytes == null) {
+                    return null;
+                }
+                return (Map<String, String>) deserializeValue(bytes);
+            }
+        });
+        /*list.forEach(s->{
+            s.setEn(NamingStrategy.underlineToCamel(s.getEn()));
+        });
+        Map<String, String> columnMap= EntityUtil.makeMapWithKeyValue(list,"ch","en");*/
+        return columnMap;
+    }
+}

data-service/src/main/java/com/lantone/data/service/impl/data/DoctorAdviceServiceImpl.java

@@ -0,0 +1,68 @@
+package com.lantone.data.service.impl.data;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.diagbot.dto.DoctorAdviceDTO;
+import com.diagbot.entity.DoctorAdvice;
+import com.diagbot.mapper.DoctorAdviceMapper;
+import com.diagbot.service.DoctorAdviceService;
+import com.diagbot.vo.DoctorAdviceVO;
+import com.diagbot.vo.FilterVO;
+import org.springframework.stereotype.Service;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * <p>
+ * 病人医嘱 服务实现类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-04-13
+ */
+@Service
+public class DoctorAdviceServiceImpl extends ServiceImpl<DoctorAdviceMapper, DoctorAdvice> implements DoctorAdviceService {
+    /**
+     * 根据医嘱ID和医院编码-批量更新数据
+     *
+     * @param list
+     */
+    public void updateBatchByKey(List<DoctorAdvice> list) {
+        this.baseMapper.updateBatchByKey(list);
+    }
+
+
+
+    public IPage<DoctorAdviceDTO> getPage(DoctorAdviceVO doctorAdviceVO) {
+
+        List<String> infos = this.baseMapper.getInfo(doctorAdviceVO.getHospitalId(), doctorAdviceVO.getBehospitalCode());
+        Set<String> infoSet = new HashSet<>();
+        for (String s : infos) {
+            if (s.contains("医嘱：")) {
+                String[] split = s.split("_");
+                for (String info : split) {
+                    String[] targetInfos = info.split("：");
+                    for (String target : targetInfos) {
+                        if (!"医嘱".equals(target)) {
+                            infoSet.add(target);
+                        }
+                    }
+                }
+            }
+        }
+
+        IPage<DoctorAdviceDTO> page = this.baseMapper.getPage(doctorAdviceVO, infoSet);
+        return page;
+    }
+
+
+    /**
+     * 获取医嘱
+     */
+    public List<Map<String, String>> getDoctorAdviceNum(FilterVO filterVO){
+        return baseMapper.getDoctorAdviceNum(filterVO);
+    }
+}