Merge branch 'dev/mix20200403_tiaoyou' into dev/mix20200401_icss6.0

aipt-service/pom.xml

@@ -159,6 +159,17 @@
             <artifactId>spring-boot-data-aggregator-starter</artifactId>
         </dependency>
 
+        <!--redis设置-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <!-- 必须加上，jedis依赖此  -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+        </dependency>
+
     </dependencies>
 
     <build>

aipt-service/src/main/java/com/diagbot/aggregate/SearchItemAggregate.java

@@ -4,8 +4,8 @@ import com.diagbot.biz.push.entity.Item;
 import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.biz.push.entity.Pacs;
 import com.diagbot.biz.push.vo.SearchVO;
-import com.diagbot.config.CryptConfiguer;
 import com.diagbot.enums.ConceptTypeEnum;
+import com.diagbot.enums.SysTypeEnum;
 import com.diagbot.facade.TransferFacade;
 import com.diagbot.util.ListUtil;
 import com.google.common.collect.Lists;
@@ -78,7 +78,10 @@ public class SearchItemAggregate {
     @DataProvider("setLis")
     public List<Lis> setLis(@InvokeParameter("searchVO") SearchVO searchVO) {
         List<Lis> lis = searchVO.getLis();
-        lis = transferFacade.addLisUniqueName(lis, searchVO.getHosCode());
+        //数据引擎模式映射数据
+        if (searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            lis = transferFacade.addLisUniqueName(lis, searchVO.getHosCode());
+        }
         return lis;
     }
 
@@ -91,7 +94,10 @@ public class SearchItemAggregate {
     @DataProvider("setPacs")
     public List<Pacs> setPacs(@InvokeParameter("searchVO") SearchVO searchVO) {
         List<Pacs> pacs = searchVO.getPacs();
-        pacs = transferFacade.addPacsUniqueName(pacs, searchVO.getHosCode());
+        //数据引擎模式映射数据
+        if (searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            pacs = transferFacade.addPacsUniqueName(pacs, searchVO.getHosCode());
+        }
         return pacs;
     }
 
@@ -104,7 +110,10 @@ public class SearchItemAggregate {
     @DataProvider("setDiag")
     public List<Item> setDiag(@InvokeParameter("searchVO") SearchVO searchVO) {
         List<Item> diag = searchVO.getDiag();
-        diag = transferFacade.addItemUniqueName(diag, ConceptTypeEnum.Disease.getKey(), searchVO.getHosCode());
+        //数据引擎模式映射数据
+        if (searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            diag = transferFacade.addItemUniqueName(diag, ConceptTypeEnum.Disease.getKey(), searchVO.getHosCode());
+        }
         return diag;
     }
 
@@ -130,7 +139,10 @@ public class SearchItemAggregate {
     @DataProvider("setLisOrder")
     public List<Lis> setLisOrder(@InvokeParameter("searchVO") SearchVO searchVO) {
         List<Lis> lisOrder = searchVO.getLisOrder();
-        lisOrder = transferFacade.addLisUniqueName(lisOrder, searchVO.getHosCode());
+        //数据引擎模式映射数据
+        if (searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            lisOrder = transferFacade.addLisUniqueName(lisOrder, searchVO.getHosCode());
+        }
         return lisOrder;
     }
 
@@ -143,7 +155,10 @@ public class SearchItemAggregate {
     @DataProvider("setPacsOrder")
     public List<Pacs> setPacsOrder(@InvokeParameter("searchVO") SearchVO searchVO) {
         List<Pacs> pacsOrder = searchVO.getPacsOrder();
-        pacsOrder = transferFacade.addPacsUniqueName(pacsOrder, searchVO.getHosCode());
+        //数据引擎模式映射数据
+        if (searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            pacsOrder = transferFacade.addPacsUniqueName(pacsOrder, searchVO.getHosCode());
+        }
         return pacsOrder;
     }
 
@@ -156,7 +171,11 @@ public class SearchItemAggregate {
     @DataProvider("setDiagOrder")
     public List<Item> setDiagOrder(@InvokeParameter("searchVO") SearchVO searchVO) {
         List<Item> diagOrder = searchVO.getDiagOrder();
-        diagOrder = transferFacade.addItemUniqueName(diagOrder, ConceptTypeEnum.Disease.getKey(), searchVO.getHosCode());
+        //数据引擎模式映射数据
+        if (searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            diagOrder
+                    = transferFacade.addItemUniqueName(diagOrder, ConceptTypeEnum.Disease.getKey(), searchVO.getHosCode());
+        }
         return diagOrder;
     }
 
@@ -182,7 +201,12 @@ public class SearchItemAggregate {
     @DataProvider("setOperationOrder")
     public List<Item> setOperationOrder(@InvokeParameter("searchVO") SearchVO searchVO) {
         List<Item> operationOrder = searchVO.getOperationOrder();
-        operationOrder = transferFacade.addItemUniqueName(operationOrder, ConceptTypeEnum.OPERATION.getKey(), searchVO.getHosCode());
+        //数据引擎模式和页面推送模式对手术开单项入参做公表映射
+        if (searchVO.getSysType().intValue() == SysTypeEnum.DATA_SERVICE.getKey()
+                || searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            operationOrder
+                    = transferFacade.addItemUniqueName(operationOrder, ConceptTypeEnum.OPERATION.getKey(), searchVO.getHosCode());
+        }
         return operationOrder;
     }
 
@@ -211,7 +235,10 @@ public class SearchItemAggregate {
         }
         List<Item> diseaseItem = Lists.newLinkedList();
         diseaseItem.add(searchVO.getDiseaseName());
-        diseaseItem = transferFacade.addItemUniqueName(diseaseItem, ConceptTypeEnum.Disease.getKey(), searchVO.getHosCode());
+        //数据引擎模式映射数据
+        if (searchVO.getSysType().intValue() == SysTypeEnum.LTAPI_SERVICE.getKey()) {
+            diseaseItem = transferFacade.addItemUniqueName(diseaseItem, ConceptTypeEnum.Disease.getKey(), searchVO.getHosCode());
+        }
         if (ListUtil.isNotEmpty(diseaseItem)) {
             return diseaseItem.get(0);
         } else {

aipt-service/src/main/java/com/diagbot/client/TranServiceClient.java

@@ -20,6 +20,7 @@ import com.diagbot.vo.HospitalSetVO;
 import com.diagbot.vo.IndexDataSaveVO;
 import com.diagbot.vo.IndexDataiIds;
 import com.diagbot.vo.LisConfigVO;
+import com.diagbot.vo.OperationConfigVO;
 import com.diagbot.vo.PacsConfigVO;
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -87,8 +88,8 @@ public interface TranServiceClient {
      * @param hosCodeVO
      * @return
      */
-    @PostMapping("/pacsConfig/getPacsConfigByHosCode")
-    RespDTO<Map<String, String>> getPacsConfigByHosCode(@RequestBody HosCodeVO hosCodeVO);
+    @PostMapping("/pacsConfig/getPacsConfigByMealNameAndHosCode")
+    RespDTO<Map<String, List<String>>> getPacsConfigByMealNameAndHosCode(@RequestBody HosCodeVO hosCodeVO);
 
     /**
      * 获取辅检映射关系
@@ -99,6 +100,15 @@ public interface TranServiceClient {
     @PostMapping("/pacsConfig/getPacsConfig")
     RespDTO<Map<String, List<String>>> getPacsConfig(@RequestBody PacsConfigVO pacsConfigVO);
 
+    /**
+     * 获取手术映射关系
+     *
+     * @param operationConfigVO
+     * @return
+     */
+    @PostMapping("/operationConfig/getOperationConfig")
+    RespDTO<Map<String, List<String>>> getOperationConfig(@RequestBody OperationConfigVO operationConfigVO);
+
     /**
      * 根据医院编码获取提示信息标题映射关系
      *

aipt-service/src/main/java/com/diagbot/client/hystrix/TranServiceHystrix.java

@@ -20,10 +20,10 @@ import com.diagbot.vo.HospitalSetVO;
 import com.diagbot.vo.IndexDataSaveVO;
 import com.diagbot.vo.IndexDataiIds;
 import com.diagbot.vo.LisConfigVO;
+import com.diagbot.vo.OperationConfigVO;
 import com.diagbot.vo.PacsConfigVO;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
-import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 
 import javax.validation.Valid;
@@ -81,8 +81,8 @@ public class TranServiceHystrix implements TranServiceClient {
      * @return
      */
     @Override
-    public RespDTO<Map<String, String>> getPacsConfigByHosCode(@RequestBody HosCodeVO hosCodeVO) {
-        log.error("【hystrix】调用{}异常", "getPacsConfigByHosCode");
+    public RespDTO<Map<String, List<String>>> getPacsConfigByMealNameAndHosCode(@RequestBody HosCodeVO hosCodeVO) {
+        log.error("【hystrix】调用{}异常", "getPacsConfigByMealNameAndHosCode");
         return null;
     }
 
@@ -98,6 +98,18 @@ public class TranServiceHystrix implements TranServiceClient {
         return null;
     }
 
+    /**
+     * 获取手术映射关系
+     *
+     * @param operationConfigVO
+     * @return
+     */
+    @Override
+    public RespDTO<Map<String, List<String>>> getOperationConfig(@RequestBody OperationConfigVO operationConfigVO) {
+        log.error("【hystrix】调用{}异常", "getOperationConfig");
+        return null;
+    }
+
     /**
      * 根据医院编码获取提示信息标题映射关系
      *

aipt-service/src/main/java/com/diagbot/config/CacheDeleteInit.java

@@ -0,0 +1,29 @@
+package com.diagbot.config;
+
+import com.diagbot.facade.CacheFacade;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+
+/**
+ * @description: 项目启动后初始化缓存
+ * @author: zhoutg
+ * @time: 2020/4/3 14:31
+ */
+@Component //把类交给spring容器管理
+@Order(100)  //使用order属性，设置该类在spring容器中的加载顺序
+@Slf4j
+public class CacheDeleteInit implements CommandLineRunner {
+
+    @Autowired
+    CacheFacade cacheFacade;
+
+    @Override
+    public void run(String... args) throws Exception {
+        // 服务启动清除redis缓存
+        log.info("知识库预处理缓存启动初始化成功！");
+        cacheFacade.clear();
+    }
+}

aipt-service/src/main/java/com/diagbot/config/RedisConfigurer.java

@@ -0,0 +1,169 @@
+package com.diagbot.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.time.Duration;
+
+@Configuration
+@EnableCaching
+@Slf4j
+public class RedisConfigurer extends CachingConfigurerSupport {
+
+    @Value("${spring.redis.database.data-service}")
+    private String databaseCache;
+    @Value("${spring.redis.host}")
+    private String host;
+    @Value("${spring.redis.password}")
+    private String password;
+    @Value("${spring.redis.port}")
+    private int port;
+    @Value("${spring.redis.timeout}")
+    private int timeout;
+    @Value("${spring.redis.lettuce.pool.max-active}")
+    private int maxActive;
+    @Value("${spring.redis.lettuce.pool.max-idle}")
+    private int maxIdle;
+    @Value("${spring.redis.lettuce.pool.max-wait}")
+    private long maxWaitMillis;
+    @Value("${spring.redis.lettuce.pool.min-idle}")
+    private int minIdle;
+
+    @Autowired
+    @Qualifier("factoryForCache")
+    private LettuceConnectionFactory lettuceConnectionFactory;
+
+    @Bean
+    public GenericObjectPoolConfig getRedisConfig() {
+        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+        poolConfig.setMaxTotal(maxActive);
+        poolConfig.setMaxIdle(maxIdle);
+        poolConfig.setMaxWaitMillis(maxWaitMillis);
+        poolConfig.setMinIdle(minIdle);
+        return poolConfig;
+    }
+
+    @Bean
+    @Override
+    public CacheManager cacheManager() {
+        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
+                // 设置 key为string序列化
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
+                // 设置value为json序列化
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(getSerializer()))
+                // 不缓存空值
+                .disableCachingNullValues();
+        RedisCacheManager cacheManager = RedisCacheManager.builder(lettuceConnectionFactory)
+                .cacheDefaults(redisCacheConfiguration)
+                .transactionAware()
+                .build();
+        cacheManager.afterPropertiesSet();
+        log.info("RedisCacheManager config success");
+        return cacheManager;
+    }
+
+    @Bean(name = "springSessionDefaultRedisSerializer")
+    public GenericJackson2JsonRedisSerializer getGenericJackson2JsonRedisSerializer() {
+        return new GenericJackson2JsonRedisSerializer();
+    }
+
+    /**
+     * 缓存使用的redis
+     *
+     * @return
+     */
+    @Bean("factoryForCache")
+    @Primary
+    public LettuceConnectionFactory redisConnectionFactory() {
+        return getRedisConnectionFactory(Integer.valueOf(databaseCache));
+    }
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate() {
+        return getRedisTemplate(lettuceConnectionFactory);
+    }
+
+    private Jackson2JsonRedisSerializer getSerializer() {
+        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
+        ObjectMapper om = new ObjectMapper();
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        jackson2JsonRedisSerializer.setObjectMapper(om);
+        return jackson2JsonRedisSerializer;
+    }
+
+    @Bean
+    @Override
+    public KeyGenerator keyGenerator() {
+        //  设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
+        // 使用：进行分割，可以很多显示出层级关系
+        // 这里其实就是new了一个KeyGenerator对象
+        return (target, method, params) -> {
+            StringBuilder sb = new StringBuilder();
+            sb.append(target.getClass().getName());
+            sb.append(":");
+            sb.append(method.getName());
+            for (Object obj : params) {
+                sb.append(":" + String.valueOf(obj));
+            }
+            String rsToUse = String.valueOf(sb);
+            log.info("自动生成Redis Key -> [{}]", rsToUse);
+            return rsToUse;
+        };
+    }
+
+    private LettuceConnectionFactory getRedisConnectionFactory(Integer database) {
+        RedisStandaloneConfiguration connection = new RedisStandaloneConfiguration();
+        connection.setHostName(host);
+        connection.setPort(port);
+        connection.setPassword(password);
+        connection.setDatabase(database);
+        GenericObjectPoolConfig poolConfig = getRedisConfig();
+        LettuceClientConfiguration builder = LettucePoolingClientConfiguration.builder()
+                .commandTimeout(Duration.ofMillis(timeout))
+                .poolConfig(poolConfig)
+                .shutdownTimeout(Duration.ZERO)
+                .build();
+        LettuceConnectionFactory factory = new LettuceConnectionFactory(connection, builder);
+        return factory;
+    }
+
+    private RedisTemplate<String, Object> getRedisTemplate(LettuceConnectionFactory factory) {
+        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(factory);
+
+        // value值的序列化
+        redisTemplate.setValueSerializer(getSerializer());
+        redisTemplate.setHashValueSerializer(getSerializer());
+        // key的序列化采用StringRedisSerializer
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.afterPropertiesSet();
+        return redisTemplate;
+    }
+}
+ 

aipt-service/src/main/java/com/diagbot/facade/CacheFacade.java

@@ -0,0 +1,23 @@
+package com.diagbot.facade;
+
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description:
+ * @Author:zhoutg
+ * @time: 2018/11/23 11:37
+ */
+@Component
+public class CacheFacade {
+
+    /**
+     * 清除缓存信息
+     *
+     * @return
+     */
+    @CacheEvict(value = "aipt-service", allEntries = true)
+    public void clear() {
+
+    }
+}

aipt-service/src/main/java/com/diagbot/facade/PushFacade.java

@@ -166,8 +166,8 @@ public class PushFacade {
      * @return
      */
     public SearchVO precSearchData(SearchVO searchVO, Boolean isConnect) {
-        //未对接或非数据引擎模式，不做映射
-        if (!isConnect || (!searchVO.getSysType().equals(SysTypeEnum.LTAPI_SERVICE.getKey()))) {
+        //未对接不做映射，细分参数是否对接单独处理，由sysType决定
+        if (!isConnect) {
             return searchVO;
         }
         try {

aipt-service/src/main/java/com/diagbot/facade/TranEnDeFacade.java

@@ -75,11 +75,11 @@ public class TranEnDeFacade {
      * @param hosCodeVO
      * @return
      */
-    public Map<String, String> getPacsConfigByHosCode(@RequestBody HosCodeVO hosCodeVO) {
-        RespDTO<Map<String, String>> respDTO = tranServiceClient.getPacsConfigByHosCode(hosCodeVO);
-        Map<String, String> retMap = new LinkedHashMap<>();
+    public Map<String, List<String>> getPacsConfigByMealNameAndHosCode(@RequestBody HosCodeVO hosCodeVO) {
+        RespDTO<Map<String, List<String>>> respDTO = tranServiceClient.getPacsConfigByMealNameAndHosCode(hosCodeVO);
+        Map<String, List<String>> retMap = new LinkedHashMap<>();
         if (RespDTOUtil.respIsOK(respDTO)) {
-            Map<String, String> map = respDTO.data;
+            Map<String, List<String>> map = respDTO.data;
             retMap = map;
         }
         return retMap;
@@ -91,13 +91,16 @@ public class TranEnDeFacade {
      * @param hosCodeVO
      * @return
      */
-    public Map<String, String> getPacsConfigByHosCode_en(@RequestBody HosCodeVO hosCodeVO) {
-        RespDTO<Map<String, String>> respDTO = tranServiceClient.getPacsConfigByHosCode(hosCodeVO);
-        Map<String, String> retMap = new LinkedHashMap<>();
+    public Map<String, List<String>> getPacsConfigByMealNameAndHosCode_en(@RequestBody HosCodeVO hosCodeVO) {
+        RespDTO<Map<String, List<String>>> respDTO = tranServiceClient.getPacsConfigByMealNameAndHosCode(hosCodeVO);
+        Map<String, List<String>> retMap = new LinkedHashMap<>();
         if (RespDTOUtil.respIsOK(respDTO)) {
-            Map<String, String> map = respDTO.data;
-            for (Map.Entry<String, String> entry : map.entrySet()) {
-                retMap.put(CryptUtil.encrypt_char(entry.getKey()), CryptUtil.encrypt_char(entry.getValue()));
+            Map<String, List<String>> map = respDTO.data;
+            for (Map.Entry<String, List<String>> entry : map.entrySet()) {
+                if (ListUtil.isNotEmpty(entry.getValue())) {
+                    CryptUtil.encryptList(entry.getValue());
+                }
+                retMap.put(CryptUtil.encrypt_char(entry.getKey()), entry.getValue());
             }
         }
         return retMap;

aipt-service/src/main/java/com/diagbot/facade/TransferFacade.java

@@ -19,9 +19,11 @@ import com.diagbot.util.StringUtil;
 import com.diagbot.vo.DiseaseIcdVO;
 import com.diagbot.vo.HospitalSetVO;
 import com.diagbot.vo.LisConfigVO;
+import com.diagbot.vo.OperationConfigVO;
 import com.diagbot.vo.PacsConfigVO;
 import com.google.common.collect.Lists;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Component;
 
 import java.util.Arrays;
@@ -49,6 +51,7 @@ public class TransferFacade {
      * @param sysType
      * @return
      */
+    @Cacheable(value = "aipt-service", key = "'Connect:hosCode_' + #hosCode + '_sysType_' + #sysType")
     public Boolean isConnect(String hosCode, Integer sysType) {
         Boolean isConnect = false;
         if (StringUtil.isNotBlank(hosCode)) {
@@ -226,7 +229,9 @@ public class TransferFacade {
                 if (StringUtil.isBlank(disease.getName())) {
                     continue;
                 } else {
-                    disease.setUniqueName(disMap.get(disease.getName()));
+                    if (StringUtil.isNotBlank(disMap.get(disease.getName()))) {
+                        disease.setUniqueName(disMap.get(disease.getName()));
+                    }
                 }
             }
             convertItems = BeanUtil.listCopyTo(items, Item.class);
@@ -234,8 +239,36 @@ public class TransferFacade {
             //暂无映射关系
             convertItems.addAll(items);
         } else if (type.equals(ConceptTypeEnum.OPERATION.getKey())) {
-            //暂无映射关系
-            convertItems.addAll(items);
+            OperationConfigVO operationConfigVO = new OperationConfigVO();
+            operationConfigVO.setHosCode(hosCode);
+            operationConfigVO.setNameList(items
+                    .stream()
+                    .map(operation -> operation.getName())
+                    .distinct()
+                    .collect(Collectors.toList()));
+            Map<String, List<String>> operationMap = new LinkedHashMap<>();
+            RespDTO<Map<String, List<String>>> respDTO = tranServiceClient.getOperationConfig(operationConfigVO);
+            if (RespDTOUtil.respIsOK(respDTO)) {
+                operationMap = respDTO.data;
+            }
+            for (Item item : items) {
+                if (StringUtil.isBlank(item.getName())) {
+                    convertItems.add(item);
+                    continue;
+                } else {
+                    if (ListUtil.isNotEmpty(operationMap.get(item.getName()))) {
+                        //外部一个项目对应到内部多个项目的数据，都保留
+                        for (String uniqueName : operationMap.get(item.getName())) {
+                            Item convertItem = new Item();
+                            BeanUtil.copyProperties(item, convertItem);
+                            convertItem.setUniqueName(uniqueName);
+                            convertItems.add(convertItem);
+                        }
+                    } else {
+                        convertItems.add(item);
+                    }
+                }
+            }
         }
         return convertItems;
     }

aipt-service/src/main/java/com/diagbot/vo/OperationConfigVO.java

@@ -0,0 +1,19 @@
+package com.diagbot.vo;
+
+import com.diagbot.client.bean.HosCodeVO;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/3/27 15:45
+ */
+@Getter
+@Setter
+public class OperationConfigVO extends HosCodeVO {
+    private List<String> nameList;
+    private List<String> uniqueNameList;
+}

aipt-service/src/main/java/com/diagbot/web/CacheController.java

@@ -0,0 +1,39 @@
+package com.diagbot.web;
+
+import com.diagbot.annotation.SysLogger;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.facade.CacheFacade;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * <p>
+ * 缓存 前端控制器
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2018-12-25
+ */
+@RequestMapping("/cache")
+@RestController
+@SuppressWarnings("unchecked")
+@Api(value = "知识库预处理缓存API", tags = { "知识库预处理缓存API" })
+public class CacheController {
+
+
+    @Autowired
+    CacheFacade cacheFacade;
+
+    @ApiOperation(value = "清除缓存[by:zhoutg]",
+            notes = "")
+    @PostMapping("/clear")
+    @SysLogger("clear")
+    public RespDTO<Boolean> clear() {
+        cacheFacade.clear();
+        return RespDTO.onSuc(true);
+    }
+}

config-server/src/main/resources/shared/aipt-service-dev.yml

@@ -66,6 +66,21 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 9 # aipt服务缓存信息
+    host: 192.168.2.236  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
 #mybatis
 mybatis-plus:
   mapper-locations: classpath:/mapper/*Mapper.xml

config-server/src/main/resources/shared/aipt-service-local.yml

@@ -66,6 +66,21 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 9 # aipt服务缓存信息
+    host: 192.168.2.236  #Redis服务器地址
+    port: 6378 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
 #mybatis
 mybatis-plus:
   mapper-locations: classpath:/mapper/*Mapper.xml

config-server/src/main/resources/shared/aipt-service-pre.yml

@@ -66,6 +66,21 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 9 # aipt服务缓存信息
+    host: 192.168.2.121  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
 #mybatis
 mybatis-plus:
   mapper-locations: classpath:/mapper/*Mapper.xml

config-server/src/main/resources/shared/aipt-service-pro.yml

@@ -66,6 +66,21 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 9 # aipt服务缓存信息
+    host: 192.168.2.122  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
 #mybatis
 mybatis-plus:
   mapper-locations: classpath:/mapper/*Mapper.xml

config-server/src/main/resources/shared/aipt-service-test.yml

@@ -66,6 +66,21 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 9 # aipt服务缓存信息
+    host: 192.168.2.241  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）
+
 #mybatis
 mybatis-plus:
   mapper-locations: classpath:/mapper/*Mapper.xml

config-server/src/main/resources/shared/application-dev.yml

@@ -3,10 +3,20 @@
 #    org.springframework.security: INFO
 
 hystrix:
+  threadpool:
+    default:
+      coreSize: 200 #并发执行的最大线程数，默认10
+      maxQueueSize: 200 #BlockingQueue的最大队列数
+      queueSizeRejectionThreshold: 50 #即使maxQueueSize没有达到，达到queueSizeRejectionThreshold该值后，请求也会被拒绝
   command:
     default:
       execution:
+        timeout:
+          enabled: true
         isolation:
+          strategy: SEMAPHORE
+          semaphore:
+            maxConcurrentRequests: 2000
           thread:
             timeoutInMilliseconds: 20000
 
@@ -16,6 +26,20 @@ ribbon:
   MaxAutoRetries: 0
   MaxAutoRetriesNextServer: 1
 
+feign:
+  hystrix:
+    enabled: true
+  #开启Feign请求压缩
+  compression:
+    response:
+      enabled: true
+  httpclient:
+    enabled: false
+  okhttp:
+    enabled: true
+    max-connections: 1000 # 默认值
+    max-connections-per-route: 250 # 默认值
+
 eureka:
   instance:
     prefer-ip-address: true #使用IP注册
@@ -50,9 +74,6 @@ management:
   endpoint:
     health:
       show-details: always
-feign:
-  hystrix:
-    enabled: true
 
 spring:
   #消息总线

config-server/src/main/resources/shared/application-local.yml

@@ -3,10 +3,20 @@
 #    org.springframework.security: INFO
 
 hystrix:
+  threadpool:
+    default:
+      coreSize: 200 #并发执行的最大线程数，默认10
+      maxQueueSize: 200 #BlockingQueue的最大队列数
+      queueSizeRejectionThreshold: 50 #即使maxQueueSize没有达到，达到queueSizeRejectionThreshold该值后，请求也会被拒绝
   command:
     default:
       execution:
+        timeout:
+          enabled: true
         isolation:
+          strategy: SEMAPHORE
+          semaphore:
+            maxConcurrentRequests: 2000
           thread:
             timeoutInMilliseconds: 20000
 
@@ -16,6 +26,20 @@ ribbon:
   MaxAutoRetries: 0
   MaxAutoRetriesNextServer: 1
 
+feign:
+  hystrix:
+    enabled: true
+  #开启Feign请求压缩
+  compression:
+    response:
+      enabled: true
+  httpclient:
+    enabled: false
+  okhttp:
+    enabled: true
+    max-connections: 1000 # 默认值
+    max-connections-per-route: 250 # 默认值
+
 eureka:
   instance:
     prefer-ip-address: true #使用IP注册
@@ -50,9 +74,6 @@ management:
   endpoint:
     health:
       show-details: always
-feign:
-  hystrix:
-    enabled: true
 
 spring:
   #消息总线

config-server/src/main/resources/shared/application-pre.yml

@@ -3,10 +3,20 @@
 #    org.springframework.security: INFO
 
 hystrix:
+  threadpool:
+    default:
+      coreSize: 200 #并发执行的最大线程数，默认10
+      maxQueueSize: 200 #BlockingQueue的最大队列数
+      queueSizeRejectionThreshold: 50 #即使maxQueueSize没有达到，达到queueSizeRejectionThreshold该值后，请求也会被拒绝
   command:
     default:
       execution:
+        timeout:
+          enabled: true
         isolation:
+          strategy: SEMAPHORE
+          semaphore:
+            maxConcurrentRequests: 2000
           thread:
             timeoutInMilliseconds: 20000
 
@@ -16,6 +26,20 @@ ribbon:
   MaxAutoRetries: 0
   MaxAutoRetriesNextServer: 1
 
+feign:
+  hystrix:
+    enabled: true
+  #开启Feign请求压缩
+  compression:
+    response:
+      enabled: true
+  httpclient:
+    enabled: false
+  okhttp:
+    enabled: true
+    max-connections: 1000 # 默认值
+    max-connections-per-route: 250 # 默认值
+
 eureka:
   instance:
     prefer-ip-address: true #使用IP注册
@@ -50,9 +74,6 @@ management:
   endpoint:
     health:
       show-details: always
-feign:
-  hystrix:
-    enabled: true
 
 spring:
   #消息总线

config-server/src/main/resources/shared/application-pro.yml

@@ -3,10 +3,20 @@
 #    org.springframework.security: INFO
 
 hystrix:
+  threadpool:
+    default:
+      coreSize: 200 #并发执行的最大线程数，默认10
+      maxQueueSize: 200 #BlockingQueue的最大队列数
+      queueSizeRejectionThreshold: 50 #即使maxQueueSize没有达到，达到queueSizeRejectionThreshold该值后，请求也会被拒绝
   command:
     default:
       execution:
+        timeout:
+          enabled: true
         isolation:
+          strategy: SEMAPHORE
+          semaphore:
+            maxConcurrentRequests: 2000
           thread:
             timeoutInMilliseconds: 20000
 
@@ -16,6 +26,20 @@ ribbon:
   MaxAutoRetries: 0
   MaxAutoRetriesNextServer: 1
 
+feign:
+  hystrix:
+    enabled: true
+  #开启Feign请求压缩
+  compression:
+    response:
+      enabled: true
+  httpclient:
+    enabled: false
+  okhttp:
+    enabled: true
+    max-connections: 1000 # 默认值
+    max-connections-per-route: 250 # 默认值
+
 eureka:
   instance:
     prefer-ip-address: true #使用IP注册
@@ -50,9 +74,6 @@ management:
   endpoint:
     health:
       show-details: always
-feign:
-  hystrix:
-    enabled: true
 
 spring:
   #消息总线

config-server/src/main/resources/shared/application-test.yml

@@ -3,10 +3,20 @@
 #    org.springframework.security: INFO
 
 hystrix:
+  threadpool:
+    default:
+      coreSize: 200 #并发执行的最大线程数，默认10
+      maxQueueSize: 200 #BlockingQueue的最大队列数
+      queueSizeRejectionThreshold: 50 #即使maxQueueSize没有达到，达到queueSizeRejectionThreshold该值后，请求也会被拒绝
   command:
     default:
       execution:
+        timeout:
+          enabled: true
         isolation:
+          strategy: SEMAPHORE
+          semaphore:
+            maxConcurrentRequests: 2000
           thread:
             timeoutInMilliseconds: 20000
 
@@ -16,6 +26,20 @@ ribbon:
   MaxAutoRetries: 0
   MaxAutoRetriesNextServer: 1
 
+feign:
+  hystrix:
+    enabled: true
+  #开启Feign请求压缩
+  compression:
+    response:
+      enabled: true
+  httpclient:
+    enabled: false
+  okhttp:
+    enabled: true
+    max-connections: 1000 # 默认值
+    max-connections-per-route: 250 # 默认值
+
 eureka:
   instance:
     prefer-ip-address: true #使用IP注册
@@ -50,9 +74,6 @@ management:
   endpoint:
     health:
       show-details: always
-feign:
-  hystrix:
-    enabled: true
 
 spring:
   #消息总线

config-server/src/main/resources/shared/data-service-dev.yml

@@ -21,3 +21,17 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 8 # data服务缓存信息
+    host: 192.168.2.236  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）

config-server/src/main/resources/shared/data-service-local.yml

@@ -20,3 +20,18 @@ spring:
     password: guest
     publisher-confirms: true
     virtual-host: /
+
+  #redis
+  redis:
+    database:
+      data-service: 8 # data服务缓存信息
+    host: 192.168.2.236  #Redis服务器地址
+    port: 6378 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）

config-server/src/main/resources/shared/data-service-pre.yml

@@ -21,3 +21,17 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 8 # data服务缓存信息
+    host: 192.168.2.121  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）

config-server/src/main/resources/shared/data-service-pro.yml

@@ -21,3 +21,17 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 8 # data服务缓存信息
+    host: 192.168.2.122  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）

config-server/src/main/resources/shared/data-service-test.yml

@@ -20,3 +20,17 @@ spring:
     publisher-confirms: true
     virtual-host: /
 
+  #redis
+  redis:
+    database:
+      data-service: 8 # data服务缓存信息
+    host: 192.168.2.241  #Redis服务器地址
+    port: 6379 # Redis服务器连接端口(本地环境端口6378，其他环境端口是6379)
+    password: lantone # Redis服务器连接密码（默认为空）
+    lettuce:
+      pool:
+        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
+        max-idle: 5 # 连接池中的最大空闲连接
+        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
+        min-idle: 0 # 连接池中的最小空闲连接
+    timeout: 20000 # 连接超时时间（毫秒）

data-service/pom.xml

@@ -129,6 +129,16 @@
             <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
         </dependency>
 
+        <!--redis设置-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
+        <!-- 必须加上，jedis依赖此  -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-pool2</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

data-service/src/main/java/com/diagbot/config/CacheDeleteInit.java

@@ -0,0 +1,29 @@
+package com.diagbot.config;
+
+import com.diagbot.facade.CacheFacade;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+
+/**
+ * @description: 项目启动后初始化缓存
+ * @author: zhoutg
+ * @time: 2020/4/3 14:31
+ */
+@Component //把类交给spring容器管理
+@Order(100)  //使用order属性，设置该类在spring容器中的加载顺序
+@Slf4j
+public class CacheDeleteInit  implements CommandLineRunner {
+
+    @Autowired
+    CacheFacade cacheFacade;
+
+    @Override
+    public void run(String... args) throws Exception {
+        // 服务启动清除redis缓存
+        log.info("页面推送模式缓存启动初始化成功！");
+        cacheFacade.clear();
+    }
+}

data-service/src/main/java/com/diagbot/config/RedisConfigurer.java

@@ -0,0 +1,169 @@
+package com.diagbot.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.time.Duration;
+
+@Configuration
+@EnableCaching
+@Slf4j
+public class RedisConfigurer extends CachingConfigurerSupport {
+
+    @Value("${spring.redis.database.data-service}")
+    private String databaseCache;
+    @Value("${spring.redis.host}")
+    private String host;
+    @Value("${spring.redis.password}")
+    private String password;
+    @Value("${spring.redis.port}")
+    private int port;
+    @Value("${spring.redis.timeout}")
+    private int timeout;
+    @Value("${spring.redis.lettuce.pool.max-active}")
+    private int maxActive;
+    @Value("${spring.redis.lettuce.pool.max-idle}")
+    private int maxIdle;
+    @Value("${spring.redis.lettuce.pool.max-wait}")
+    private long maxWaitMillis;
+    @Value("${spring.redis.lettuce.pool.min-idle}")
+    private int minIdle;
+
+    @Autowired
+    @Qualifier("factoryForCache")
+    private LettuceConnectionFactory lettuceConnectionFactory;
+
+    @Bean
+    public GenericObjectPoolConfig getRedisConfig() {
+        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+        poolConfig.setMaxTotal(maxActive);
+        poolConfig.setMaxIdle(maxIdle);
+        poolConfig.setMaxWaitMillis(maxWaitMillis);
+        poolConfig.setMinIdle(minIdle);
+        return poolConfig;
+    }
+
+    @Bean
+    @Override
+    public CacheManager cacheManager() {
+        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
+                // 设置 key为string序列化
+                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
+                // 设置value为json序列化
+                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(getSerializer()))
+                // 不缓存空值
+                .disableCachingNullValues();
+        RedisCacheManager cacheManager = RedisCacheManager.builder(lettuceConnectionFactory)
+                .cacheDefaults(redisCacheConfiguration)
+                .transactionAware()
+                .build();
+        cacheManager.afterPropertiesSet();
+        log.info("RedisCacheManager config success");
+        return cacheManager;
+    }
+
+    @Bean(name = "springSessionDefaultRedisSerializer")
+    public GenericJackson2JsonRedisSerializer getGenericJackson2JsonRedisSerializer() {
+        return new GenericJackson2JsonRedisSerializer();
+    }
+
+    /**
+     * 缓存使用的redis
+     *
+     * @return
+     */
+    @Bean("factoryForCache")
+    @Primary
+    public LettuceConnectionFactory redisConnectionFactory() {
+        return getRedisConnectionFactory(Integer.valueOf(databaseCache));
+    }
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate() {
+        return getRedisTemplate(lettuceConnectionFactory);
+    }
+
+    private Jackson2JsonRedisSerializer getSerializer() {
+        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
+        ObjectMapper om = new ObjectMapper();
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        jackson2JsonRedisSerializer.setObjectMapper(om);
+        return jackson2JsonRedisSerializer;
+    }
+
+    @Bean
+    @Override
+    public KeyGenerator keyGenerator() {
+        //  设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
+        // 使用：进行分割，可以很多显示出层级关系
+        // 这里其实就是new了一个KeyGenerator对象
+        return (target, method, params) -> {
+            StringBuilder sb = new StringBuilder();
+            sb.append(target.getClass().getName());
+            sb.append(":");
+            sb.append(method.getName());
+            for (Object obj : params) {
+                sb.append(":" + String.valueOf(obj));
+            }
+            String rsToUse = String.valueOf(sb);
+            log.info("自动生成Redis Key -> [{}]", rsToUse);
+            return rsToUse;
+        };
+    }
+
+    private LettuceConnectionFactory getRedisConnectionFactory(Integer database) {
+        RedisStandaloneConfiguration connection = new RedisStandaloneConfiguration();
+        connection.setHostName(host);
+        connection.setPort(port);
+        connection.setPassword(password);
+        connection.setDatabase(database);
+        GenericObjectPoolConfig poolConfig = getRedisConfig();
+        LettuceClientConfiguration builder = LettucePoolingClientConfiguration.builder()
+                .commandTimeout(Duration.ofMillis(timeout))
+                .poolConfig(poolConfig)
+                .shutdownTimeout(Duration.ZERO)
+                .build();
+        LettuceConnectionFactory factory = new LettuceConnectionFactory(connection, builder);
+        return factory;
+    }
+
+    private RedisTemplate<String, Object> getRedisTemplate(LettuceConnectionFactory factory) {
+        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(factory);
+
+        // value值的序列化
+        redisTemplate.setValueSerializer(getSerializer());
+        redisTemplate.setHashValueSerializer(getSerializer());
+        // key的序列化采用StringRedisSerializer
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.afterPropertiesSet();
+        return redisTemplate;
+    }
+}
+ 

data-service/src/main/java/com/diagbot/facade/CacheFacade.java

@@ -0,0 +1,23 @@
+package com.diagbot.facade;
+
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description:
+ * @Author:zhoutg
+ * @time: 2018/11/23 11:37
+ */
+@Component
+public class CacheFacade {
+
+    /**
+     * 清除缓存信息
+     *
+     * @return
+     */
+    @CacheEvict(value = "data-service", allEntries = true)
+    public void clear() {
+
+    }
+}

data-service/src/main/java/com/diagbot/facade/ConceptDetailCacheFacade.java

@@ -0,0 +1,38 @@
+package com.diagbot.facade;
+
+import com.diagbot.client.AiptServiceClient;
+import com.diagbot.dto.ConceptIntroduceDTO;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
+import com.diagbot.vo.ConceptIntroduceVO;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2019/5/14 9:49
+ */
+@Component
+public class ConceptDetailCacheFacade {
+    @Autowired
+    private AiptServiceClient aiptServiceClient;
+
+    /**
+     * 获取提示信息
+     *
+     * @param conceptIntroduceVO
+     * @return
+     */
+    @Cacheable(value = "data-service", key = "'ConceptDetail:name_' + #conceptIntroduceVO.name + '_type_' + #conceptIntroduceVO.type+ '_pos_' + #conceptIntroduceVO.position")
+    public ConceptIntroduceDTO getConceptDetail(ConceptIntroduceVO conceptIntroduceVO) {
+        RespDTO<ConceptIntroduceDTO> res = aiptServiceClient.getConceptDetail(conceptIntroduceVO);
+        RespDTOUtil.respNGDeal(res, "获取静态知识失败");
+        return res.data;
+    }
+}

data-service/src/main/java/com/diagbot/facade/ConceptDetailFacade.java

@@ -1,13 +1,12 @@
 package com.diagbot.facade;
 
-import com.diagbot.client.AiptServiceClient;
 import com.diagbot.dto.ConceptIntroduceDTO;
-import com.diagbot.dto.RespDTO;
-import com.diagbot.util.RespDTOUtil;
+import com.diagbot.util.ListUtil;
 import com.diagbot.vo.ConceptIntroduceVO;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -18,7 +17,7 @@ import java.util.List;
 @Component
 public class ConceptDetailFacade {
     @Autowired
-    private AiptServiceClient aiptServiceClient;
+    private ConceptDetailCacheFacade conceptDetailCacheFacade;
 
     /**
      * 获取提示信息
@@ -27,9 +26,7 @@ public class ConceptDetailFacade {
      * @return
      */
     public ConceptIntroduceDTO getConceptDetail(ConceptIntroduceVO conceptIntroduceVO) {
-        RespDTO<ConceptIntroduceDTO> res = aiptServiceClient.getConceptDetail(conceptIntroduceVO);
-        RespDTOUtil.respNGDeal(res, "获取静态知识失败");
-        return res.data;
+        return conceptDetailCacheFacade.getConceptDetail(conceptIntroduceVO);
     }
 
     /**
@@ -39,8 +36,16 @@ public class ConceptDetailFacade {
      * @return
      */
     public List<ConceptIntroduceDTO> getConceptDetails(List<ConceptIntroduceVO> conceptIntroduceVOList) {
-        RespDTO<List<ConceptIntroduceDTO>> res = aiptServiceClient.getConceptDetails(conceptIntroduceVOList);
-        RespDTOUtil.respNGDeal(res, "获取静态知识失败");
-        return res.data;
+        List<ConceptIntroduceDTO> res = new ArrayList<>();
+        if (ListUtil.isNotEmpty(conceptIntroduceVOList)) {
+            for (ConceptIntroduceVO conceptIntroduceVO : conceptIntroduceVOList) {
+                ConceptIntroduceDTO conceptIntroduceDTO
+                        = conceptDetailCacheFacade.getConceptDetail(conceptIntroduceVO);
+                if (null != conceptIntroduceDTO) {
+                    res.add(conceptIntroduceDTO);
+                }
+            }
+        }
+        return res;
     }
 }

data-service/src/main/java/com/diagbot/facade/DictionaryFacade.java

@@ -5,6 +5,7 @@ import com.diagbot.dto.DictionaryInfoDTO;
 import com.diagbot.dto.RespDTO;
 import com.diagbot.util.RespDTOUtil;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -26,6 +27,7 @@ public class DictionaryFacade {
      *
      * @return
      */
+    @Cacheable(value = "data-service", key = "'dictionary'")
     public Map<Long, List<DictionaryInfoDTO>> getList() {
         RespDTO<Map<Long, List<DictionaryInfoDTO>>> res = aiptServiceClient.getList();
         RespDTOUtil.respNGDealCover(res, "获取字典信息失败");

data-service/src/main/java/com/diagbot/facade/DisclaimerInformationFacade.java

@@ -6,6 +6,7 @@ import com.diagbot.dto.RespDTO;
 import com.diagbot.util.RespDTOUtil;
 import com.diagbot.vo.DisclaimerInformationVO;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -24,6 +25,7 @@ public class DisclaimerInformationFacade {
     /**
      * @return
      */
+    @Cacheable(value = "data-service", key = "'disclaimerInfo'")
     public List<DisclaimerInformationDTO> getDisclaimerInformation() {
         DisclaimerInformationVO disclaimerInformationVO = new DisclaimerInformationVO();
         disclaimerInformationVO.setType(2);

data-service/src/main/java/com/diagbot/facade/SysSetFacade.java

@@ -6,6 +6,7 @@ import com.diagbot.dto.SysSetInfoDTO;
 import com.diagbot.util.RespDTOUtil;
 import com.diagbot.vo.HospitalSetVO;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -26,6 +27,7 @@ public class SysSetFacade {
      *
      * @return
      */
+    @Cacheable(value = "data-service", key = "'SysSetInfo:hospCode_' + #hospitalSetVO.hospitalCode + '_plan_' + #hospitalSetVO.plan")
     public List<SysSetInfoDTO> getSysSetInfoData(HospitalSetVO hospitalSetVO) {
         RespDTO<List<SysSetInfoDTO>> sysSetInfoLists = tranServiceClient.getSysSetInfoDatas(hospitalSetVO);
         RespDTOUtil.respNGDeal(sysSetInfoLists, "获取配置数据失败！");

data-service/src/main/java/com/diagbot/facade/VersionInfoFacade.java

@@ -7,6 +7,7 @@ import com.diagbot.enums.ProductTypeEnum;
 import com.diagbot.util.RespDTOUtil;
 import com.diagbot.vo.VersionVO;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Component;
 
 /**
@@ -25,6 +26,7 @@ public class VersionInfoFacade {
      *
      * @return
      */
+    @Cacheable(value = "data-service", key = "'version'")
     public VersionWrapperDTO getVersionInfoAll() {
         VersionVO versionVO = new VersionVO();
         versionVO.setProductType(ProductTypeEnum.DATA.getKey());

data-service/src/main/java/com/diagbot/web/CacheController.java

@@ -0,0 +1,39 @@
+package com.diagbot.web;
+
+import com.diagbot.annotation.SysLogger;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.facade.CacheFacade;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * <p>
+ * 缓存 前端控制器
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2018-12-25
+ */
+@RequestMapping("/cache")
+@RestController
+@SuppressWarnings("unchecked")
+@Api(value = "页面推送模式缓存API", tags = { "页面推送模式缓存API" })
+public class CacheController {
+
+
+    @Autowired
+    CacheFacade cacheFacade;
+
+    @ApiOperation(value = "清除缓存[by:zhoutg]",
+            notes = "")
+    @PostMapping("/clear")
+    @SysLogger("clear")
+    public RespDTO<Boolean> clear() {
+        cacheFacade.clear();
+        return RespDTO.onSuc(true);
+    }
+}

data-service/src/main/java/com/diagbot/web/ConceptDetailController.java

@@ -30,7 +30,7 @@ public class ConceptDetailController {
     @Autowired
     private ConceptDetailFacade conceptDetailFacade;
 
-    @ApiOperation(value = "获取提示信息[by:zhaops]",
+    @ApiOperation(value = "[已加缓存]获取提示信息[by:zhaops]",
             notes = "name: 标签名称，必填<br>" +
                     "type：标签类型（1-症状，5-化验，6-辅检，7-诊断，8-药品，9-药品大类，10-不良反应，11-药品小类，12-化验公表项，22-指标，25-手术），单选必填<br>" +
                     "titles：提示信息标题列表，数组选填<br>" +
@@ -42,7 +42,7 @@ public class ConceptDetailController {
         return RespDTO.onSuc(data);
     }
 
-    @ApiOperation(value = "批量获取提示信息[by:zhaops]",
+    @ApiOperation(value = "[已加缓存]批量获取提示信息[by:zhaops]",
             notes = "conceptIntorduces:数组，必填<br>" +
                     "name: 标签名称，必填<br>" +
                     "type：标签类型（1-症状，5-化验，6-辅检，7-诊断，8-药品，9-药品大类，10-不良反应，11-药品小类，12-化验公表项，22-指标，25-手术），单选必填<br>" +

data-service/src/main/java/com/diagbot/web/DictionaryInfoController.java

@@ -32,7 +32,7 @@ public class DictionaryInfoController {
     @Autowired
     DictionaryFacade dictionaryFacade;
 
-    @ApiOperation(value = "返回字典信息[by:zhoutg]",
+    @ApiOperation(value = "[已加缓存]返回字典信息[by:zhoutg]",
             notes = "")
     @PostMapping("/getList")
     @SysLogger("getList")

data-service/src/main/java/com/diagbot/web/DisclaimerInformationController.java

@@ -29,7 +29,7 @@ public class DisclaimerInformationController {
     @Autowired
     DisclaimerInformationFacade disclaimerInformationFacade;
 
-    @ApiOperation(value = "获取免责申明详情[by:wangfeng]", notes = "获取免责申明详情")
+    @ApiOperation(value = "[已加缓存]获取免责申明详情[by:wangfeng]", notes = "获取免责申明详情")
     @PostMapping("/getDisclaimerInformations")
     @SysLogger("getDisclaimerInformations")
     public RespDTO<List<DisclaimerInformationDTO>> getDisclaimerInformations() {

data-service/src/main/java/com/diagbot/web/SysSetController.java

@@ -34,13 +34,11 @@ public class SysSetController {
     @Autowired
     SysSetFacade sysSetFacade;
 
-    @ApiOperation(value = "根据医院编码获取配置信息[by:wangfeng]", notes = "hospitalCode ：医院code  必填<br> ")
+    @ApiOperation(value = "[已加缓存]根据医院编码获取配置信息[by:wangfeng]", notes = "hospitalCode ：医院code  必填<br> ")
     @PostMapping("/getSysSetInfoDatas")
     @SysLogger("getSysSetInfoDatas")
     public RespDTO<List<SysSetInfoDTO>> getSysSetInfoDatas(@Valid @RequestBody HospitalSetVO hospitalSetVO) {
-
         List<SysSetInfoDTO> data = sysSetFacade.getSysSetInfoData(hospitalSetVO);
-
         return RespDTO.onSuc(data);
     }
 }

data-service/src/main/java/com/diagbot/web/VersionInfoController.java

@@ -28,7 +28,7 @@ public class VersionInfoController {
     @Autowired
     VersionInfoFacade versionInfoFacade;
 
-    @ApiOperation(value = "获取版本信息[by:wangfeng]", notes = "获取版本信息")
+    @ApiOperation(value = "[已加缓存]获取版本信息[by:wangfeng]", notes = "获取版本信息")
     @PostMapping("/getVersionInfoAlls")
     @SysLogger("getVersionInfoAlls")
     public RespDTO<VersionWrapperDTO> getVersionInfoAlls() {

docs/033.20200330手术开单合理项映射脚本/init_tran.sql

@@ -0,0 +1,15 @@
+use `sys-tran`;
+
+DROP TABLE IF EXISTS `tran_operation_config`;
+CREATE TABLE `tran_operation_config` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
+  `is_deleted` char(1) NOT NULL DEFAULT 'N' COMMENT '是否删除,N:未删除，Y:删除',
+  `gmt_create` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录创建时间',
+  `gmt_modified` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录修改时间,如果时间是1970年则表示纪录未修改',
+  `creator` varchar(20) NOT NULL DEFAULT '0' COMMENT '创建人，0表示无创建人值',
+  `modifier` varchar(20) NOT NULL DEFAULT '0' COMMENT '修改人,如果为0则表示纪录未修改',
+  `hospital_code` varchar(60) DEFAULT NULL COMMENT '医院编码',
+  `name` varchar(100) DEFAULT NULL COMMENT '外部名称',
+  `unique_name` varchar(100) DEFAULT NULL COMMENT '内部名称',
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

icss-service/src/main/java/com/diagbot/aggregate/PushItemAggregate.java

@@ -3,33 +3,23 @@ package com.diagbot.aggregate;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.diagbot.biz.push.entity.Treat;
 import com.diagbot.biz.push.enums.FeatureTypeEnum;
-import com.diagbot.client.AiptServiceClient;
-import com.diagbot.client.bean.ConceptBaseVO;
-import com.diagbot.client.bean.ConceptExistVO;
-import com.diagbot.dto.ConceptBaseDTO;
 import com.diagbot.dto.ConceptPushDTO;
 import com.diagbot.dto.PushDTO;
 import com.diagbot.dto.QuestionDTO;
 import com.diagbot.dto.QuestionPushDTO;
-import com.diagbot.dto.RespDTO;
-import com.diagbot.entity.DeptVital;
 import com.diagbot.entity.QuestionInfo;
 import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
 import com.diagbot.enums.QuestionTypeEnum;
 import com.diagbot.enums.TagTypeEnum;
-import com.diagbot.exception.CommonErrorCode;
-import com.diagbot.exception.CommonException;
-import com.diagbot.facade.DeptVitalFacade;
+import com.diagbot.facade.PushCacheFacade;
 import com.diagbot.facade.QuestionFacade;
 import com.diagbot.facade.TreatmentFacade;
 import com.diagbot.util.BeanUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
-import com.diagbot.util.RespDTOUtil;
 import com.diagbot.vo.PushVO;
 import com.diagbot.vo.QuestionIds2VO;
-import com.diagbot.vo.QuestionVO;
 import com.google.common.collect.Lists;
 import io.github.lvyahui8.spring.annotation.DataConsumer;
 import io.github.lvyahui8.spring.annotation.DataProvider;
@@ -53,9 +43,7 @@ public class PushItemAggregate {
     @Autowired
     private QuestionFacade questionFacade;
     @Autowired
-    private AiptServiceClient aiptServiceClient;
-    @Autowired
-    private DeptVitalFacade deptVitalFacade;
+    private PushCacheFacade pushCacheFacade;
     @Autowired
     private TreatmentFacade treatmentFacade;
 
@@ -126,7 +114,7 @@ public class PushItemAggregate {
         List<QuestionPushDTO> moduleVitalDTO = Lists.newLinkedList();
         if (featureTypeSet.contains(String.valueOf(FeatureTypeEnum.Feature_Type_Vital_Module.getKey()))) {
             ConceptPushDTO dept = data.getDept();
-            moduleVitalDTO = getVitalModule(dept, pushVO);
+            moduleVitalDTO = pushCacheFacade.getVitalModule(dept, pushVO);
         }
         return moduleVitalDTO;
     }
@@ -214,74 +202,6 @@ public class PushItemAggregate {
         return concepts;
     }
 
-    /**
-     * 获取查体模板
-     *
-     * @param dept
-     * @param pushVO
-     * @return
-     */
-    public List<QuestionPushDTO> getVitalModule(ConceptPushDTO dept, PushVO pushVO) {
-        List<QuestionPushDTO> vitalDTO = Lists.newLinkedList();
-        if (dept.getConceptId() == null) {
-            throw new CommonException(CommonErrorCode.NOT_EXISTS, "全科信息未维护");
-        }
-        QueryWrapper<DeptVital> deptVitalQueryWrapper = new QueryWrapper<>();
-        deptVitalQueryWrapper
-                .eq("is_deleted", IsDeleteEnum.N.getKey())
-                .eq("dept_id", dept.getConceptId())
-                .orderByAsc("order_no");
-        List<DeptVital> deptVitalList = deptVitalFacade.list(deptVitalQueryWrapper);
-        //科室模板为空时，取全科模板
-        if (deptVitalList.size() == 0 && dept.getName().equals("全科") == false) {
-            ConceptBaseVO conceptBaseVO = new ConceptBaseVO();
-            conceptBaseVO.setName("全科");
-            conceptBaseVO.setLibType(ConceptTypeEnum.DEPARTMENT.getKey());
-            RespDTO<ConceptBaseDTO> res = aiptServiceClient.existConcept(conceptBaseVO);
-            RespDTOUtil.respNGDeal(res, "全科信息未维护");
-            BeanUtil.copyProperties(res.data, dept);
-            deptVitalQueryWrapper = new QueryWrapper<>();
-            deptVitalQueryWrapper
-                    .eq("is_deleted", IsDeleteEnum.N.getKey())
-                    .eq("dept_id", dept.getConceptId())
-                    .orderByAsc("order_no");
-            deptVitalList = deptVitalFacade.list(deptVitalQueryWrapper);
-        }
-        //标签列表
-        for (DeptVital deptVital : deptVitalList) {
-            QuestionVO questionVO = new QuestionVO();
-            QuestionPushDTO questionPushDTO = new QuestionPushDTO();
-            questionVO.setAge(pushVO.getAge());
-            questionVO.setSexType(pushVO.getSex());
-            questionVO.setId(deptVital.getVitalId());
-            QuestionDTO questionDTO = questionFacade.getById(questionVO);
-            if (questionDTO != null && questionDTO.getId() != null) {
-                BeanUtil.copyProperties(questionDTO, questionPushDTO);
-                questionPushDTO.setLibType(ConceptTypeEnum.Vital.getKey());
-                vitalDTO.add(questionPushDTO);
-            }
-        }
-        //增加概念id
-        if (ListUtil.isNotEmpty(vitalDTO)) {
-            ConceptExistVO conceptExistVO = new ConceptExistVO();
-            conceptExistVO.setType(ConceptTypeEnum.Vital.getKey());
-            List<String> vitalNames = vitalDTO
-                    .stream()
-                    .map(vital -> vital.getTagName())
-                    .collect(Collectors.toList());
-            conceptExistVO.setNameList(vitalNames);
-            RespDTO<Map<String, Long>> respDTO = aiptServiceClient.getConceptMapByNameAndType(conceptExistVO);
-            if (RespDTOUtil.respIsOK(respDTO)) {
-                Map<String, Long> vitalMap = respDTO.data;
-                for (QuestionPushDTO questionPushDTO : vitalDTO) {
-                    if (vitalMap.get(questionPushDTO.getTagName()) != null) {
-                        questionPushDTO.setConceptId(vitalMap.get(questionPushDTO.getTagName()));
-                    }
-                }
-            }
-        }
-        return vitalDTO;
-    }
 
     /**
      * 获取化验填写单

icss-service/src/main/java/com/diagbot/client/TranServiceClient.java

@@ -169,15 +169,6 @@ public interface TranServiceClient {
     @PostMapping("/inquiryInfo/getExportInquirys")
     RespDTO<List<GetExportInquirysDTO>> getExportInquirys(@RequestBody List<Long> inquiryIds);
 
-    /**
-     * 根据医院编码获取辅检公表映射关系
-     *
-     * @param hosCodeVO
-     * @return
-     */
-    @PostMapping("/pacsConfig/getPacsConfigByHosCode")
-    RespDTO<Map<String, String>> getPacsConfigByHosCode(@RequestBody HosCodeVO hosCodeVO);
-
     /**
      * 根据医院编码获取提示信息标题映射关系
      *
@@ -196,15 +187,6 @@ public interface TranServiceClient {
     @PostMapping("/diseaseIcd/getDiseaseIcdByHosCode")
     RespDTO<Map<String, String>> getDiseaseIcdByHosCode(@RequestBody HosCodeVO hosCodeVO);
 
-    /**
-     * 根据医院编码查询辅检公表映射，公表项做key
-     *
-     * @param hosCodeVO
-     * @return
-     */
-    @PostMapping("/pacsConfig/getPacsConfigByUniqueNameAndHosCode")
-    RespDTO<Map<String, List<String>>> getPacsConfigByUniqueNameAndHosCode(@RequestBody HosCodeVO hosCodeVO);
-
     @PostMapping("/lisDockingImports/lisDockingImports")
     public RespDTO<LisRetrieveListAllDTO> getLisDatas(@RequestBody @Valid LisArgumentsVO lisArgumentsVO);
 

icss-service/src/main/java/com/diagbot/client/hystrix/TranServiceHystrix.java

@@ -136,18 +136,6 @@ public class TranServiceHystrix implements TranServiceClient {
         return null;
     }
 
-    /**
-     * 根据医院编码获取辅检公表映射关系
-     *
-     * @param hosCodeVO
-     * @return
-     */
-    @Override
-    public RespDTO<Map<String, String>> getPacsConfigByHosCode(@RequestBody HosCodeVO hosCodeVO) {
-        log.error("【hystrix】调用{}异常", "getPacsConfigByHosCode");
-        return null;
-    }
-
     /**
      * 根据医院编码获取提示信息标题映射关系
      *
@@ -172,18 +160,6 @@ public class TranServiceHystrix implements TranServiceClient {
         return null;
     }
 
-    /**
-     * 根据医院编码查询辅检公表映射，公表项做key
-     *
-     * @param hosCodeVO
-     * @return
-     */
-    @Override
-    public RespDTO<Map<String, List<String>>> getPacsConfigByUniqueNameAndHosCode(@RequestBody HosCodeVO hosCodeVO) {
-        log.error("【hystrix】调用{}异常", "getPacsConfigByUniqueNameAndHosCode");
-        return null;
-    }
-
     @Override
     public RespDTO<LisRetrieveListAllDTO> getLisDatas(@RequestBody @Valid LisArgumentsVO lisArgumentsVO) {
         log.error("【hystrix】调用{}异常", "getLisDatas");

icss-service/src/main/java/com/diagbot/facade/PushCacheFacade.java

@@ -0,0 +1,115 @@
+package com.diagbot.facade;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.client.AiptServiceClient;
+import com.diagbot.client.bean.ConceptBaseVO;
+import com.diagbot.client.bean.ConceptExistVO;
+import com.diagbot.dto.ConceptBaseDTO;
+import com.diagbot.dto.ConceptPushDTO;
+import com.diagbot.dto.QuestionDTO;
+import com.diagbot.dto.QuestionPushDTO;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.entity.DeptVital;
+import com.diagbot.enums.ConceptTypeEnum;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
+import com.diagbot.vo.PushVO;
+import com.diagbot.vo.QuestionVO;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/4/8 13:40
+ */
+@Component
+public class PushCacheFacade {
+    @Autowired
+    private DeptVitalFacade deptVitalFacade;
+    @Autowired
+    private AiptServiceClient aiptServiceClient;
+    @Autowired
+    private QuestionFacade questionFacade;
+
+    /**
+     * 获取查体模板
+     *
+     * @param dept
+     * @param pushVO
+     * @return
+     */
+    @Cacheable(value = "icss-service", key = "'VitalModule:deptName_' + #dept.name + '_sex_' + #pushVO.sex")
+    public List<QuestionPushDTO> getVitalModule(ConceptPushDTO dept, PushVO pushVO) {
+        List<QuestionPushDTO> vitalDTO = Lists.newLinkedList();
+        if (dept.getConceptId() == null) {
+            throw new CommonException(CommonErrorCode.NOT_EXISTS, "全科信息未维护");
+        }
+        QueryWrapper<DeptVital> deptVitalQueryWrapper = new QueryWrapper<>();
+        deptVitalQueryWrapper
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("dept_id", dept.getConceptId())
+                .orderByAsc("order_no");
+        List<DeptVital> deptVitalList = deptVitalFacade.list(deptVitalQueryWrapper);
+        //科室模板为空时，取全科模板
+        if (deptVitalList.size() == 0 && dept.getName().equals("全科") == false) {
+            ConceptBaseVO conceptBaseVO = new ConceptBaseVO();
+            conceptBaseVO.setName("全科");
+            conceptBaseVO.setLibType(ConceptTypeEnum.DEPARTMENT.getKey());
+            RespDTO<ConceptBaseDTO> res = aiptServiceClient.existConcept(conceptBaseVO);
+            RespDTOUtil.respNGDeal(res, "全科信息未维护");
+            BeanUtil.copyProperties(res.data, dept);
+            deptVitalQueryWrapper = new QueryWrapper<>();
+            deptVitalQueryWrapper
+                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .eq("dept_id", dept.getConceptId())
+                    .orderByAsc("order_no");
+            deptVitalList = deptVitalFacade.list(deptVitalQueryWrapper);
+        }
+        //标签列表
+        for (DeptVital deptVital : deptVitalList) {
+            QuestionVO questionVO = new QuestionVO();
+            QuestionPushDTO questionPushDTO = new QuestionPushDTO();
+            questionVO.setAge(pushVO.getAge());
+            questionVO.setSexType(pushVO.getSex());
+            questionVO.setId(deptVital.getVitalId());
+            QuestionDTO questionDTO = questionFacade.getById(questionVO);
+            if (questionDTO != null && questionDTO.getId() != null) {
+                BeanUtil.copyProperties(questionDTO, questionPushDTO);
+                questionPushDTO.setLibType(ConceptTypeEnum.Vital.getKey());
+                vitalDTO.add(questionPushDTO);
+            }
+        }
+        //增加概念id
+        if (ListUtil.isNotEmpty(vitalDTO)) {
+            ConceptExistVO conceptExistVO = new ConceptExistVO();
+            conceptExistVO.setType(ConceptTypeEnum.Vital.getKey());
+            List<String> vitalNames = vitalDTO
+                    .stream()
+                    .map(vital -> vital.getTagName())
+                    .collect(Collectors.toList());
+            conceptExistVO.setNameList(vitalNames);
+            RespDTO<Map<String, Long>> respDTO = aiptServiceClient.getConceptMapByNameAndType(conceptExistVO);
+            if (RespDTOUtil.respIsOK(respDTO)) {
+                Map<String, Long> vitalMap = respDTO.data;
+                for (QuestionPushDTO questionPushDTO : vitalDTO) {
+                    if (vitalMap.get(questionPushDTO.getTagName()) != null) {
+                        questionPushDTO.setConceptId(vitalMap.get(questionPushDTO.getTagName()));
+                    }
+                }
+            }
+        }
+        return vitalDTO;
+    }
+
+}

tran-service/src/main/java/com/diagbot/entity/OperationConfig.java

@@ -0,0 +1,146 @@
+package com.diagbot.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import java.io.Serializable;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author zhaops
+ * @since 2020-03-27
+ */
+@TableName("tran_operation_config")
+public class OperationConfig implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * 是否删除,N:未删除，Y:删除
+     */
+    private String isDeleted;
+
+    /**
+     * 记录创建时间
+     */
+    private LocalDateTime gmtCreate;
+
+    /**
+     * 记录修改时间,如果时间是1970年则表示纪录未修改
+     */
+    private LocalDateTime gmtModified;
+
+    /**
+     * 创建人，0表示无创建人值
+     */
+    private String creator;
+
+    /**
+     * 修改人,如果为0则表示纪录未修改
+     */
+    private String modifier;
+
+    /**
+     * 医院编码
+     */
+    private String hospitalCode;
+
+    /**
+     * 外部名称
+     */
+    private String name;
+
+    /**
+     * 内部名称
+     */
+    private String uniqueName;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+    public String getIsDeleted() {
+        return isDeleted;
+    }
+
+    public void setIsDeleted(String isDeleted) {
+        this.isDeleted = isDeleted;
+    }
+    public LocalDateTime getGmtCreate() {
+        return gmtCreate;
+    }
+
+    public void setGmtCreate(LocalDateTime gmtCreate) {
+        this.gmtCreate = gmtCreate;
+    }
+    public LocalDateTime getGmtModified() {
+        return gmtModified;
+    }
+
+    public void setGmtModified(LocalDateTime gmtModified) {
+        this.gmtModified = gmtModified;
+    }
+    public String getCreator() {
+        return creator;
+    }
+
+    public void setCreator(String creator) {
+        this.creator = creator;
+    }
+    public String getModifier() {
+        return modifier;
+    }
+
+    public void setModifier(String modifier) {
+        this.modifier = modifier;
+    }
+    public String getHospitalCode() {
+        return hospitalCode;
+    }
+
+    public void setHospitalCode(String hospitalCode) {
+        this.hospitalCode = hospitalCode;
+    }
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+    public String getUniqueName() {
+        return uniqueName;
+    }
+
+    public void setUniqueName(String uniqueName) {
+        this.uniqueName = uniqueName;
+    }
+
+    @Override
+    public String toString() {
+        return "OperationConfig{" +
+            "id=" + id +
+            ", isDeleted=" + isDeleted +
+            ", gmtCreate=" + gmtCreate +
+            ", gmtModified=" + gmtModified +
+            ", creator=" + creator +
+            ", modifier=" + modifier +
+            ", hospitalCode=" + hospitalCode +
+            ", name=" + name +
+            ", uniqueName=" + uniqueName +
+        "}";
+    }
+}

tran-service/src/main/java/com/diagbot/facade/OperationConfigFacade.java

@@ -0,0 +1,57 @@
+package com.diagbot.facade;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.entity.OperationConfig;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.service.impl.OperationConfigServiceImpl;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.vo.OperationConfigVO;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/3/27 15:41
+ */
+@Component
+public class OperationConfigFacade extends OperationConfigServiceImpl {
+
+    /**
+     * 获取辅检映射关系
+     *
+     * @param operationConfigVO
+     * @return
+     */
+    public Map<String, List<String>> getOperationConfig(OperationConfigVO operationConfigVO) {
+        Map<String, List<String>> map = new HashMap<>();
+        Map<String, List<OperationConfig>> operationMap = new LinkedHashMap<>();
+        QueryWrapper<OperationConfig> operationConfigQueryWrapper = new QueryWrapper<>();
+        operationConfigQueryWrapper
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("hospital_code", operationConfigVO.getHosCode());
+        if (ListUtil.isNotEmpty(operationConfigVO.getNameList())) {
+            operationConfigQueryWrapper.in("name", operationConfigVO.getNameList());
+            List<OperationConfig> operationConfigList = this.list(operationConfigQueryWrapper);
+            operationMap = EntityUtil.makeEntityListMap(operationConfigList, "name");
+        } else if (ListUtil.isNotEmpty(operationConfigVO.getUniqueNameList())) {
+            operationConfigQueryWrapper.in("unique_name", operationConfigVO.getUniqueNameList());
+            List<OperationConfig> operationConfigList = this.list(operationConfigQueryWrapper);
+            operationMap = EntityUtil.makeEntityListMap(operationConfigList, "uniqueName");
+        }
+        for (Map.Entry<String, List<OperationConfig>> entry : operationMap.entrySet()) {
+            map.put(entry.getKey(), entry.getValue()
+                    .stream()
+                    .map(operationConfig -> operationConfig.getUniqueName())
+                    .distinct()
+                    .collect(Collectors.toList()));
+        }
+        return map;
+    }
+}

tran-service/src/main/java/com/diagbot/facade/PacsConfigFacade.java

@@ -13,7 +13,6 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 /**
  * @Description:
@@ -24,18 +23,22 @@ import java.util.stream.Collectors;
 public class PacsConfigFacade extends PacsConfigServiceImpl{
 
     /**
-     * 根据医院编码获取辅检公表映射关系 Map<mealName,uniqueName>
+     * 根据医院编码获取辅检公表映射关系 Map<mealName,List<uniqueName>>
      *
      * @return
      */
-    public Map<String, String> getPacsConfigByHosCode(String hosCode) {
+    public Map<String, List<String>> getPacsConfigByMealNameAndHosCode(String hosCode) {
+        Map<String, List<String>> retMap = new LinkedHashMap<>();
         QueryWrapper<PacsConfig> pacsConfigQueryWrapper = new QueryWrapper<>();
         pacsConfigQueryWrapper
                 .eq("is_deleted", IsDeleteEnum.N.getKey())
                 .eq("hospital_code", hosCode);
         List<PacsConfig> pacsConfigList = this.list(pacsConfigQueryWrapper);
-        Map<String, String> retMap
-                = EntityUtil.makeMapWithKeyValue(pacsConfigList, "mealName", "uniqueName");
+        Map<String, List<PacsConfig>> pacsConfigMap
+                = EntityUtil.makeEntityListMap(pacsConfigList, "mealName");
+        for (Map.Entry<String, List<PacsConfig>> entry : pacsConfigMap.entrySet()) {
+            retMap.put(entry.getKey(), EntityUtil.makeListByFieldName(entry.getValue(), "uniqueName"));
+        }
         return retMap;
     }
 
@@ -55,17 +58,16 @@ public class PacsConfigFacade extends PacsConfigServiceImpl{
             pacsConfigQueryWrapper.in("meal_name", pacsConfigVO.getMealNameList());
             List<PacsConfig> pacsConfigList = this.list(pacsConfigQueryWrapper);
             pacsMap = EntityUtil.makeEntityListMap(pacsConfigList, "mealName");
+            for (Map.Entry<String, List<PacsConfig>> entry : pacsMap.entrySet()) {
+                map.put(entry.getKey(), EntityUtil.makeListByFieldName(entry.getValue(), "uniqueName"));
+            }
         } else if (ListUtil.isNotEmpty(pacsConfigVO.getUniqueNameList())) {
             pacsConfigQueryWrapper.in("unique_name", pacsConfigVO.getUniqueNameList());
             List<PacsConfig> pacsConfigList = this.list(pacsConfigQueryWrapper);
             pacsMap = EntityUtil.makeEntityListMap(pacsConfigList, "uniqueName");
-        }
-        for (Map.Entry<String, List<PacsConfig>> entry : pacsMap.entrySet()) {
-            map.put(entry.getKey(), entry.getValue()
-                    .stream()
-                    .map(pacsConfig -> pacsConfig.getUniqueName())
-                    .distinct()
-                    .collect(Collectors.toList()));
+            for (Map.Entry<String, List<PacsConfig>> entry : pacsMap.entrySet()) {
+                map.put(entry.getKey(), EntityUtil.makeListByFieldName(entry.getValue(), "mealName"));
+            }
         }
         return map;
     }

tran-service/src/main/java/com/diagbot/facade/TranLisConfigFacade.java

@@ -56,9 +56,13 @@ public class TranLisConfigFacade extends TranLisConfigServiceImpl{
 				.select("hospital_code,meal_name,ifnull(item_name,'') as item_name,unique_name,unique_id")
 				.eq("is_deleted", IsDeleteEnum.N.getKey())
 				.eq("hospital_code", lisConfigVO.getHosCode());
-		if (ListUtil.isNotEmpty(lisConfigVO.getMealNameList())) {
+		/*if (ListUtil.isNotEmpty(lisConfigVO.getMealNameList())) {
 			lisConfigQueryWrapper.in("meal_name", lisConfigVO.getMealNameList());
-		}
+		}*/
+		lisConfigQueryWrapper.in(ListUtil.isNotEmpty(lisConfigVO.getMealNameList()),
+				"meal_name", lisConfigVO.getMealNameList());
+		lisConfigQueryWrapper.in(ListUtil.isNotEmpty(lisConfigVO.getUniqueNameList()),
+				"unique_name", lisConfigVO.getUniqueNameList());
 		List<TranLisConfig> lisConfigList = this.list(lisConfigQueryWrapper);
 		Map<String, List<TranLisConfig>> lisConfigMap
 				= EntityUtil.makeEntityListMap(lisConfigList, "mealName");
@@ -96,9 +100,13 @@ public class TranLisConfigFacade extends TranLisConfigServiceImpl{
 		tranLisConfigQueryWrapper
 				.eq("is_deleted", IsDeleteEnum.N.getKey())
 				.eq("hospital_code", lisConfigVO.getHosCode());
-		if (ListUtil.isNotEmpty(lisConfigVO.getUniqueNameList())) {
+		/*if (ListUtil.isNotEmpty(lisConfigVO.getUniqueNameList())) {
 			tranLisConfigQueryWrapper.in("unique_name", lisConfigVO.getUniqueNameList());
-		}
+		}*/
+		tranLisConfigQueryWrapper.in(ListUtil.isNotEmpty(lisConfigVO.getMealNameList()),
+				"meal_name", lisConfigVO.getMealNameList());
+		tranLisConfigQueryWrapper.in(ListUtil.isNotEmpty(lisConfigVO.getUniqueNameList()),
+				"unique_name", lisConfigVO.getUniqueNameList());
 		List<TranLisConfig> tranLisConfigList = this.list(tranLisConfigQueryWrapper);
 		Map<String, List<TranLisConfig>> lisConfigMap
 				= EntityUtil.makeEntityListMap(tranLisConfigList, "uniqueName");

tran-service/src/main/java/com/diagbot/mapper/OperationConfigMapper.java

@@ -0,0 +1,16 @@
+package com.diagbot.mapper;
+
+import com.diagbot.entity.OperationConfig;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ *  Mapper 接口
+ * </p>
+ *
+ * @author zhaops
+ * @since 2020-03-27
+ */
+public interface OperationConfigMapper extends BaseMapper<OperationConfig> {
+
+}

tran-service/src/main/java/com/diagbot/service/OperationConfigService.java

@@ -0,0 +1,16 @@
+package com.diagbot.service;
+
+import com.diagbot.entity.OperationConfig;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author zhaops
+ * @since 2020-03-27
+ */
+public interface OperationConfigService extends IService<OperationConfig> {
+
+}

tran-service/src/main/java/com/diagbot/service/impl/OperationConfigServiceImpl.java

@@ -0,0 +1,20 @@
+package com.diagbot.service.impl;
+
+import com.diagbot.entity.OperationConfig;
+import com.diagbot.mapper.OperationConfigMapper;
+import com.diagbot.service.OperationConfigService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author zhaops
+ * @since 2020-03-27
+ */
+@Service
+public class OperationConfigServiceImpl extends ServiceImpl<OperationConfigMapper, OperationConfig> implements OperationConfigService {
+
+}

tran-service/src/main/java/com/diagbot/vo/OperationConfigVO.java

@@ -0,0 +1,18 @@
+package com.diagbot.vo;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/3/27 15:45
+ */
+@Getter
+@Setter
+public class OperationConfigVO extends HosCodeVO {
+    private List<String> nameList;
+    private List<String> uniqueNameList;
+}

tran-service/src/main/java/com/diagbot/web/OperationConfigController.java

@@ -0,0 +1,44 @@
+package com.diagbot.web;
+
+
+import com.diagbot.annotation.SysLogger;
+import com.diagbot.dto.RespDTO;
+import com.diagbot.facade.OperationConfigFacade;
+import com.diagbot.vo.OperationConfigVO;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p>
+ *  前端控制器
+ * </p>
+ *
+ * @author zhaops
+ * @since 2020-03-27
+ */
+@RestController
+@RequestMapping("/operationConfig")
+@Api(value = "手术公表映射配置相关API", tags = { "手术公表映射配置相关API" })
+public class OperationConfigController {
+
+    @Autowired
+    private OperationConfigFacade operationConfigFacade;
+
+    @ApiOperation(value = "获取手术项目映射关系:[by:zhaops]",
+            notes = "hosCode:医院编码，必填<br>" +
+                    "nameList:手术项目外部名称列表<br>" +
+                    "uniqueNameList:手术项目内部名称列表<br>")
+    @PostMapping("/getOperationConfig")
+    @SysLogger("getOperationConfig")
+    public RespDTO<Map<String, List<String>>> getOperationConfig(@RequestBody OperationConfigVO operationConfigVO) {
+        return RespDTO.onSuc(operationConfigFacade.getOperationConfig(operationConfigVO));
+    }
+}

tran-service/src/main/java/com/diagbot/web/PacsConfigController.java

@@ -30,15 +30,15 @@ public class PacsConfigController {
     @Autowired
     PacsConfigFacade pacsConfigFacade;
 
-    @ApiOperation(value = "根据医院编码查询辅检公表映射:[by:zhaops]",
+    @ApiOperation(value = "根据医院编码查询辅检公表映射,Map<外部名称,List<内部名称>>:[by:zhaops]",
             notes = "hosCode: 医院编码，必填<br>")
-    @PostMapping("/getPacsConfigByHosCode")
-    @SysLogger("getPacsConfigByHosCode")
-    public RespDTO<Map<String, String>> getPacsConfigByHosCode(@RequestBody HosCodeVO hosCodeVO) {
-        return RespDTO.onSuc(pacsConfigFacade.getPacsConfigByHosCode(hosCodeVO.getHosCode()));
+    @PostMapping("/getPacsConfigByMealNameAndHosCode")
+    @SysLogger("getPacsConfigByMealNameAndHosCode")
+    public RespDTO<Map<String, List<String>>> getPacsConfigByMealNameAndHosCode(@RequestBody HosCodeVO hosCodeVO) {
+        return RespDTO.onSuc(pacsConfigFacade.getPacsConfigByMealNameAndHosCode(hosCodeVO.getHosCode()));
     }
 
-    @ApiOperation(value = "根据医院编码查询辅检公表映射，公表项做key :[by:zhaops]",
+    @ApiOperation(value = "根据医院编码查询辅检公表映射，公表项做key ，Map<内部名称,List<外部名称>>:[by:zhaops]",
             notes = "hosCode: 医院编码，必填<br>")
     @PostMapping("/getPacsConfigByUniqueNameAndHosCode")
     @SysLogger("getPacsConfigByUniqueNameAndHosCode")

tran-service/src/main/java/com/diagbot/web/TranLisConfigController.java

@@ -39,7 +39,7 @@ public class TranLisConfigController {
 		return RespDTO.onSuc(tranLisConfigFacade.getLisConfigByhospitalIds(lisHospitalCodeVO));
 	}
 
-	@ApiOperation(value = "根据医院编码和套餐名称获取化验公表映射关系:[by:zhaops]",
+	@ApiOperation(value = "根据医院编码和套餐名称获取化验公表映射关系，Map<大项,Map<小项,List<公表>>>:[by:zhaops]",
 			notes = "hosCode: 医院编码，必填<br>")
 	@PostMapping("/getLisConfigByMealNameAndHosCode")
 	@SysLogger("getLisConfigByMealNameAndHosCode")
@@ -47,7 +47,7 @@ public class TranLisConfigController {
 		return RespDTO.onSuc(tranLisConfigFacade.getLisConfigByMealNameAndHosCode(lisConfigVO));
 	}
 
-	@ApiOperation(value = "根据医院编码获取化验公表映射关系，公表项做key :[by:zhaops]",
+	@ApiOperation(value = "根据医院编码获取化验公表映射关系，公表项做key，Map<公表,List<大项>> :[by:zhaops]",
 			notes = "hosCode: 医院编码，必填<br>")
 	@PostMapping("/getLisConfigByUniqueNameAndHosCode")
 	@SysLogger("getLisConfigByUniqueNameAndHosCode")

tran-service/src/main/resources/mapper/OperationConfigMapper.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.diagbot.mapper.OperationConfigMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.diagbot.entity.OperationConfig">
+        <id column="id" property="id" />
+        <result column="is_deleted" property="isDeleted" />
+        <result column="gmt_create" property="gmtCreate" />
+        <result column="gmt_modified" property="gmtModified" />
+        <result column="creator" property="creator" />
+        <result column="modifier" property="modifier" />
+        <result column="hospital_code" property="hospitalCode" />
+        <result column="name" property="name" />
+        <result column="unique_name" property="uniqueName" />
+    </resultMap>
+
+</mapper>