Merge branch 'dev' of http://192.168.1.220:10080/Amoy2/wlyy2.0 into dev

# Conflicts:
#	svr/svr-internet-hospital/src/main/java/com/yihu/jw/hospital/endpoint/consult/PatientConsultEndpoint.java

business/base-service/src/main/java/com/yihu/jw/wechat/service/BaseSensitiveFilterWordsService.java

@@ -42,10 +42,7 @@ public class BaseSensitiveFilterWordsService extends BaseJpaService<BaseSensitiv
        }
        SensitivewordFilter filter = new SensitivewordFilter(set);
        Set<String> words = filter.getSensitiveWord(txt, 1);
        logger.info("语句中包含敏感词的个数为：" + words.size() + "。包含：" + words);
        logger.info("过滤前="+txt);
        String replaceTxt = filter.replaceSensitiveWord(txt, 1, "*");
        logger.info("过滤后="+replaceTxt);
        String replaceTxt = filter.replaceSensitiveWord(txt, 1, "***");
        return replaceTxt;
    }
}

svr/svr-base/src/main/java/com/yihu/jw/base/service/word/BaseSensitiveService.java

@@ -286,10 +286,7 @@ public class BaseSensitiveService extends BaseJpaService<BaseSensitiveDO, BaseSe
        }
        SensitivewordFilter filter = new SensitivewordFilter(set);
        Set<String> words = filter.getSensitiveWord(txt, 1);
        logger.info("语句中包含敏感词的个数为：" + words.size() + "。包含：" + words);
        logger.info("过滤前="+txt);
        String replaceTxt = filter.replaceSensitiveWord(txt, 1, "*");
        logger.info("过滤后="+replaceTxt);
        String replaceTxt = filter.replaceSensitiveWord(txt, 1, "***");
        return replaceTxt;
    }
}

svr/svr-internet-hospital/src/main/java/com/yihu/jw/hospital/endpoint/patient/PatientNoLoginEndPoint.java

@@ -10,6 +10,7 @@ import com.yihu.jw.entity.base.dict.DictHospitalDeptDO;
import com.yihu.jw.entity.base.dict.DictJobTitleDO;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.entity.base.doctor.BaseDoctorHospitalDO;
import com.yihu.jw.entity.base.wx.WxWechatDO;
import com.yihu.jw.entity.hospital.article.KnowledgeArticleDO;
import com.yihu.jw.entity.hospital.article.KnowledgeArticleUserDO;
import com.yihu.jw.entity.hospital.httplog.WlyyHttpLogDO;
@@ -41,6 +42,7 @@ import com.yihu.jw.rm.hospital.BaseHospitalRequestMapping;
import com.yihu.jw.rm.patient.PatientRequestMapping;
import com.yihu.jw.util.common.XMLUtil;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.jw.wechat.dao.WechatDao;
import com.yihu.jw.wechat.service.WechatInfoService;
import com.ylzinfo.onepay.sdk.OnepayClient;
import com.ylzinfo.onepay.sdk.OnepayDefaultClient;
@@ -66,12 +68,11 @@ import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.concurrent.TimeUnit;
import static com.yihu.jw.utils.sfutils.SHAUtils.SHA1;
/**
 * @author zmk
 * 患者不用登陆访问居民PC端控制类
@@ -130,6 +131,8 @@ public class PatientNoLoginEndPoint extends EnvelopRestEndpoint {
    private KnowledgeArticleUserDao knowledgeArticleUserDao;
    @Autowired
    private KnowledgeArticleService knowledgeArticleService;
    @Autowired
    private WechatDao wechatDao;
    private String successxml = "SUCCESS";
    private String failedxml = "FALSE";
@@ -673,4 +676,34 @@ public class PatientNoLoginEndPoint extends EnvelopRestEndpoint {
        }
        return success(articleDO);
    }
    @PostMapping(value = BaseHospitalRequestMapping.PatientIM.getSign)
    @ApiOperation(value = "获取微信签名", notes = "获取微信签名")
    public Envelop getSign(@ApiParam(name = "pageUrl", value = "授权页面")
                           @RequestParam(value = "pageUrl", required = true)String pageUrl,
                           @ApiParam(name = "wxId", value = "微信id")
                           @RequestParam(value = "wxId", required = true)String wxId) throws Exception {
        logger.info("pageUrl="+pageUrl);
        logger.info("wxId="+wxId);
        String ticket = wechatInfoService.getJsapi_ticketByToken(wxId);
        WxWechatDO wxWechatDO = wechatDao.findById(wxId);
        Map<Object, Object> map = new HashMap<Object, Object>();
        if (ticket != null) {
            String noncestr = UUID.randomUUID().toString();
            long timestamp = System.currentTimeMillis() / 1000;
            String url = pageUrl;
            logger.info("getSign.url="+url);
            String str = "jsapi_ticket=" + ticket + "&noncestr=" + noncestr + "&timestamp=" + timestamp + "&url=" + url;
            logger.info("getSign.str="+str);
            // sha1加密
            String signature = SHA1(str);
            map.put("noncestr", noncestr);
            map.put("timestamp", timestamp);
            map.put("signature", signature);
            map.put("appid", wxWechatDO.getAppId());
            return success(PatientRequestMapping.Wechat.api_success,map);
        }
        return failed(PatientRequestMapping.Wechat.api_error);
    }
}

svr/svr-internet-hospital/src/main/java/com/yihu/jw/hospital/service/consult/KnowledgeArticleService.java

@@ -231,6 +231,7 @@ public class KnowledgeArticleService extends BaseJpaService<KnowledgeArticleDO,
					object.put("id",knowledgeArticleDO.getId());
					object.put("title",knowledgeArticleDO.getTitle());
					object.put("content",knowledgeArticleDO.getIntro());
					object.put("img",knowledgeArticleDO.getImage());
					imUtil.sendImMsg(patientBusinessDO.getDoctor(), patientBusinessDO.getDoctorName(), patientBusinessDO.getSessionId(), "4", object.toJSONString(),"1");
				}
@@ -265,6 +266,7 @@ public class KnowledgeArticleService extends BaseJpaService<KnowledgeArticleDO,
			knowledgeArticleUserDO.setUpdateTime(new Date());
			knowledgeArticleUserDO.setCreateUser(doctor);
			knowledgeArticleUserDO.setUpdateUser(doctor);
			knowledgeArticleUserDO.setUsed(used);
			knowledgeArticleUserDO = knowledgeArticleUserDao.save(knowledgeArticleUserDO);
		}
        if (knowledgeArticleDO!=null){

svr/svr-iot/src/main/java/com/yihu/iot/service/equipment/IotEqtDetailService.java

@@ -3,9 +3,12 @@ package com.yihu.iot.service.equipment;
import com.alibaba.fastjson.JSONObject;
import com.yihu.iot.dao.equipment.IotEquipmentDetailDao;
import com.yihu.iot.util.excel.EntityUtils;
import com.yihu.iot.util.excel.HibenateUtils;
import com.yihu.jw.entity.iot.equipment.IotEquipmentDetailDO;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.mysql.query.BaseJpaService;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -18,6 +21,10 @@ import java.util.UUID;
public class IotEqtDetailService  extends BaseJpaService<IotEquipmentDetailDO, IotEquipmentDetailDao> {
    @Autowired
    private IotEquipmentDetailDao iotEquipmentDetailDao;
    @Autowired
    private HibenateUtils hibenateUtils;
    public void updateEquipment(String jsonData){
        IotEquipmentDetailDO iotEquipmentDetailDO = EntityUtils.jsonToEntity(jsonData, IotEquipmentDetailDO.class);
        if(null==iotEquipmentDetailDO.getId()){
@@ -71,4 +78,30 @@ public class IotEqtDetailService  extends BaseJpaService<IotEquipmentDetailDO, I
        return result;
    }
    public Long findCountByHealthHourse(String startTime,String endTime,String area){
        Map<String,Object> params = new HashedMap();
        String sql = "select count(1) as \"total\" from iot_equipmet_detail where 1=1 ";
        if (StringUtils.isNoneBlank(startTime)){
            sql+=" AND create_time >=:startTime";
            params.put("startTime", DateUtil.stringToDate(startTime,"yyyy-MM-dd HH:mm:ss"));
        }
        if (StringUtils.isNoneBlank(startTime)){
            sql+=" AND create_time <=:endTime";
            params.put("endTime", DateUtil.stringToDate(endTime,"yyyy-MM-dd HH:mm:ss"));
        }
        if (StringUtils.isNoneBlank(area)){
            sql+=" AND belong_are_code <:area";
            params.put("area", area);
        }
        Long count = 0L;
        List<Map<String,Object>> total = hibenateUtils.createSQLQuery(sql,params);
        if(total!=null){
            //mysql 与 Oracle 聚合函数返回类型不一致，需要判断装换
            count = hibenateUtils.objTransformLong(total.get(0).get("total"));
        }
        return count;
    }
}

svr/svr-iot/src/main/java/com/yihu/iot/service/monitorPlatform/MonitorPlatformService.java

@@ -3,9 +3,12 @@ package com.yihu.iot.service.monitorPlatform;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.yihu.iot.dao.dict.IotSystemDictDao;
import com.yihu.iot.service.common.MyJdbcTemplate;
import com.yihu.iot.service.device.IotPatientDeviceService;
import com.yihu.iot.service.equipment.IotEqtDetailService;
import com.yihu.iot.service.label.FigureLabelSerachService;
import com.yihu.jw.entity.iot.dict.IotSystemDictDO;
import com.yihu.jw.restmodel.web.MixEnvelop;
import com.yihu.jw.util.http.HttpClientUtil;
import io.swagger.annotations.ApiOperation;
@@ -46,6 +49,10 @@ public class MonitorPlatformService  {
    private MyJdbcTemplate myJdbcTemplate;
    @Autowired
    private FigureLabelSerachService figureLabelSerachService;
    @Autowired
    private IotSystemDictDao iotSystemDictDao;
    @Autowired
    private IotEqtDetailService iotEqtDetailService;
    /**
     * 获取位置信息
@@ -426,21 +433,87 @@ public class MonitorPlatformService  {
        String response = sendGet(url,params);
        JSONObject json = JSONObject.parseObject(response);
        if(json.getInteger("status")==200){
            IotSystemDictDO iotSystemDictDO = iotSystemDictDao.findByDictNameAndValueAndDel("DEVICE_TYPE","健康小屋",1);
            JSONArray jsonArray = json.getJSONArray("data");
            for (int i=0;i<jsonArray.size();i++){
                JSONObject jo = jsonArray.getJSONObject(i);
                String tmp = jo.getString("type");
                if("1".equals(tmp)){
                    jo.put("typeName","血糖仪");
                }else if("2".equals(tmp)){
                    jo.put("typeName","血压计");
                }else if("3".equals(tmp)){
                    jo.put("typeName","智能药盒");
                }else if("4".equals(tmp)){
                    jo.put("typeName","智能手表");
            String[] str =deviceType.split(",");
            List<String> list = new ArrayList<>();
            for (int i=0;i<str.length;i++){
                list.add(str[i]);
            }
            if (iotSystemDictDO!=null){
                if (!list.contains(iotSystemDictDO.getCode())){
                    for (int i=0;i<jsonArray.size();i++){
                        JSONObject jo = jsonArray.getJSONObject(i);
                        String tmp = jo.getString("type");
                        if("1".equals(tmp)){
                            jo.put("typeName","血糖仪");
                        }else if("2".equals(tmp)){
                            jo.put("typeName","血压计");
                        }else if("3".equals(tmp)){
                            jo.put("typeName","智能药盒");
                        }else if("4".equals(tmp)){
                            jo.put("typeName","智能手表");
                        }
                    }
                }else {
                    if (jsonArray!=null&&jsonArray.size()!=0){
                        for (int i=0;i<jsonArray.size();i++){
                            JSONObject jo = jsonArray.getJSONObject(i);
                            String tmp = jo.getString("type");
                            if("1".equals(tmp)){
                                jo.put("typeName","血糖仪");
                            }else if("2".equals(tmp)){
                                jo.put("typeName","血压计");
                            }else if("3".equals(tmp)){
                                jo.put("typeName","智能药盒");
                            }else if("4".equals(tmp)){
                                jo.put("typeName","智能手表");
                            }
                        }
                        if (org.apache.commons.lang3.StringUtils.isNoneBlank(hospital)){
                            JSONObject jsonObject= new JSONObject();
                            jsonObject.put("type",iotSystemDictDO.getCode());
                            jsonObject.put("typeName",iotSystemDictDO.getValue());
                            jsonObject.put("signNum",0);
                            jsonObject.put("unSignNum",0);
                            jsonArray.add(jsonObject);
                        }else {
                            Long count = iotEqtDetailService.findCountByHealthHourse(startTime,endTime,area);
                            JSONObject jsonObject= new JSONObject();
                            jsonObject.put("type",iotSystemDictDO.getCode());
                            jsonObject.put("typeName",iotSystemDictDO.getValue());
                            jsonObject.put("signNum",count);
                            jsonObject.put("unSignNum",0);
                            jsonArray.add(jsonObject);
                        }
                    }else {
                        if (org.apache.commons.lang3.StringUtils.isNoneBlank(hospital)){
                            jsonArray = new JSONArray();
                            JSONObject jsonObject= new JSONObject();
                            jsonObject.put("type",iotSystemDictDO.getCode());
                            jsonObject.put("typeName",iotSystemDictDO.getValue());
                            jsonObject.put("signNum",0);
                            jsonObject.put("unSignNum",0);
                            jsonArray.add(jsonObject);
                        }else {
                            Long count = iotEqtDetailService.findCountByHealthHourse(startTime,endTime,area);
                            jsonArray = new JSONArray();
                            JSONObject jsonObject= new JSONObject();
                            jsonObject.put("type",iotSystemDictDO.getCode());
                            jsonObject.put("typeName",iotSystemDictDO.getValue());
                            jsonObject.put("signNum",count);
                            jsonObject.put("unSignNum",0);
                            jsonArray.add(jsonObject);
                        }
                    }
                }
            }
            return jsonArray;
        }

svr/svr-iot/src/main/java/com/yihu/iot/util/excel/HibenateUtils.java

@@ -0,0 +1,186 @@
package com.yihu.iot.util.excel;
import com.yihu.jw.entity.hospital.prescription.HlwCf01DO;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
 * 数据库查询工具，mysql与Oracle 通用复诊查询
 * 支持原生SQL。联表，动态传参。分页查询
 * 不支持数据库特有的函数
 * <p>
 * Created by Trick on 2019/12/10.
 */
@Component
@Transactional
public class HibenateUtils {
    /**
     * JPA 数据源
     */
    @PersistenceContext
    private EntityManager entityManager;
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     *
     * @param sql
     * @param page 第几页，1开始
     * @param size 每页记录数
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql, Integer page, Integer size) {
        Session session = (Session) entityManager.getDelegate();
        SQLQuery query = session.createSQLQuery(sql);
        query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        if(page!=null&&size!=null){
            query.setFirstResult((page - 1) * size);
            query.setMaxResults(size);
        }
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     * 无分页
     * @param sql
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql) {
        Session session = (Session) entityManager.getDelegate();
        SQLQuery query = session.createSQLQuery(sql);
        query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     * @param sql
     * @param params 动态占位符入参，例如 like:name
     * @param page 第几页，1开始
     * @param size 每页记录数
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql, Map<String, Object> params, Integer page, Integer size) {
        Session session = (Session) entityManager.getDelegate();
        SQLQuery query = session.createSQLQuery(sql);
        query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        //设置查询参数
        setSqlQueryByMap(query, params);
        if(page!=null&&size!=null){
            query.setFirstResult((page - 1) * size);
            query.setMaxResults(size);
        }
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 创建SQL查询，根据配置，获取数据库方言
     * sql为原生sql语句，查询，Oracle不区分大小写，返回值需要驼峰命名，字段别名需要加 双引号
     * 目前只支持通用的聚合函数，特有的聚合函数不支持
     * @param sql
     * @param params 动态占位符入参，例如 like:name
     * @return
     */
    public List<Map<String, Object>> createSQLQuery(String sql, Map<String, Object> params) {
        Session session = (Session) entityManager.getDelegate();
        SQLQuery query = session.createSQLQuery(sql);
        query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        //设置查询参数
        setSqlQueryByMap(query, params);
        List<Map<String, Object>> list = query.list();
        return list;
    }
    /**
     * 设置查询参数
     * @param sqlQuery
     * @param params
     * @return
     */
    private SQLQuery setSqlQueryByMap(SQLQuery sqlQuery, Map<String, Object> params) {
        if (params != null && !params.isEmpty()) {
            for (String key : params.keySet()) {
                Object obj = params.get(key);
                if (obj instanceof Collection<?>) {
                    sqlQuery.setParameterList(key, (Collection<?>) obj);
                } else if (obj instanceof Object[]) {
                    sqlQuery.setParameterList(key, (Object[]) obj);
                } else {
                    sqlQuery.setParameter(key, obj);
                }
            }
        }
        return sqlQuery;
    }
    /**
     * 聚合函数类型装换
     * @param obj
     * @return
     */
    public Long objTransformLong(Object obj){
        //Oracle count(1) 聚合函数类型装换
        if(obj instanceof BigDecimal){
            return ((BigDecimal) obj).longValue();
        //Mysql count(1) 聚合函数类型装换
        }else if(obj instanceof BigInteger){
            return ((BigInteger)obj).longValue();
        }else{
            return 0L;
        }
    }
    public void updateBySql(String sql){
        Session session = (Session) entityManager.getDelegate();
        session.createSQLQuery(sql).executeUpdate();
    }
    public void save(Object object) {
        entityManager.persist(object);
    }
    /**
     * 更新
     * @param entity
     */
    public void update(Object entity){
        entityManager.merge(entity);
        entityManager.flush();
    }
    public void update(String id,Integer status){
        HlwCf01DO hlwCf01DO = entityManager.find(HlwCf01DO.class,id);
        hlwCf01DO.setFKZT(status);
        update(hlwCf01DO);
    }
}