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

business/base-service/src/main/java/com/yihu/jw/dict/dao/DictHospitalDeptDao.java

@@ -3,9 +3,11 @@ package com.yihu.jw.dict.dao;
import com.yihu.jw.entity.base.dict.DictHospitalDeptDO;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import javax.transaction.Transactional;
import java.util.List;
import java.util.Map;
@@ -21,6 +23,7 @@ import java.util.Map;
 * </pre>
 * @since 1.
 */
//@Transactional
public interface DictHospitalDeptDao extends PagingAndSortingRepository<DictHospitalDeptDO, Integer>, JpaSpecificationExecutor<DictHospitalDeptDO>  {
    @Query("select code as code,name as name from DictHospitalDeptDO where orgCode in ?1")
@@ -39,4 +42,8 @@ public interface DictHospitalDeptDao extends PagingAndSortingRepository<DictHosp
    DictHospitalDeptDO findByCode(String code);
    @Modifying
    @Query("delete from DictHospitalDeptDO  where orgCode=?1")
    void deleteByOrgCode(String orgCode);
}

business/base-service/src/main/java/com/yihu/jw/hospital/mapping/dao/PatientMappingDao.java

@@ -10,4 +10,5 @@ import org.springframework.data.repository.PagingAndSortingRepository;
public interface PatientMappingDao extends PagingAndSortingRepository<PatientMappingDO, String>, JpaSpecificationExecutor<PatientMappingDO> {
    PatientMappingDO findByIdcardAndSource(String idcard,String source);
    PatientMappingDO findByMappingCodeAndSource(String mappingCode,String source);
}

business/base-service/src/main/java/com/yihu/jw/hospital/prescription/dao/OutpatientDao.java

@@ -2,6 +2,7 @@ package com.yihu.jw.hospital.prescription.dao;
import com.yihu.jw.entity.hospital.prescription.WlyyOutpatientDO;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
@@ -14,4 +15,5 @@ public interface OutpatientDao extends PagingAndSortingRepository<WlyyOutpatient
    @Query("from WlyyOutpatientDO a where a.patient = ?1 and a.status in(0,1)")
    List<WlyyOutpatientDO> findByPatientList(String patient);
}

business/base-service/src/main/java/com/yihu/jw/hospital/prescription/service/PrescriptionExpressageService.java

@@ -1,638 +1,716 @@
//package com.yihu.jw.hospital.prescription.service;
//
//import com.yihu.jw.entity.base.org.BaseOrgDO;
//import com.yihu.jw.entity.hospital.prescription.*;
//import com.yihu.jw.hospital.prescription.dao.*;
//import com.yihu.jw.hospital.prescription.service.entrance.util.SFUtils;
//import com.yihu.jw.org.dao.BaseOrgDao;
//import com.yihu.jw.util.date.DateUtil;
//import com.yihu.jw.util.http.HttpClientKit;
//import com.yihu.mysql.query.BaseJpaService;
//import org.apache.commons.lang3.StringUtils;
//import org.apache.http.NameValuePair;
//import org.apache.http.message.BasicNameValuePair;
//import org.dom4j.Document;
//import org.dom4j.DocumentHelper;
//import org.dom4j.Element;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.orm.jpa.JpaTransactionManager;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.TransactionDefinition;
//import org.springframework.transaction.TransactionStatus;
//import org.springframework.transaction.support.DefaultTransactionDefinition;
//
//import java.util.*;
//
///**
// *  门诊物流服务
// * lith 2019.06.04
// */
//
//@Service
//public class PrescriptionExpressageService extends BaseJpaService<WlyyPrescriptionExpressageDO, PrescriptionExpressageDao> {
//    private static Logger logger = LoggerFactory.getLogger(PrescriptionExpressageService.class);
//
////    //顺丰快递接口请求地址
////    //@Value("${express.sf_url}")
////    private String sf_url;
////
////    //顺丰快递接口接入编码
////    //@Value("${express.sf_code}")
////    private String sf_code;
////
////    //顺丰快递接口checkword
////    //@Value("${express.sf_check_word}")
////    private String sf_check_word;
//
//    @Autowired
//    private SFUtils SFUtils;
//
//    @Autowired
//    private JpaTransactionManager transactionManager;
//
//    //处方日志
//    @Autowired
//    private WlyyOutpatientExpressageLogDao outpatientExpressageLogDao;
//
//    @Autowired
//    private PrescriptionDao prescriptionDao;
//
//    @Autowired
//    private WlyyExpressagePriceDao expressagePriceDao;
//
//    @Autowired
//    private PrescriptionExpressageLogDao prescriptionExpressageLogDao;
//
//    @Autowired
//    private PrescriptionExpressageDao prescriptionExpressageDao;
//
//    @Autowired
//    private BaseOrgDao baseOrgDao;
//
//
//    /**
//     * 组装请求参数，发送请求
//     * @param xml
//     * @return
//     * @throws Exception
//     */
//    private String SFExpressPost(String xml)throws Exception{
//        String verifyCode = SFUtils.verifyCodeSFXmlStr(xml,sf_check_word);
//        List<NameValuePair> params = new ArrayList<>();
//        params.add(new BasicNameValuePair("xml", xml));
//        params.add(new BasicNameValuePair("verifyCode", verifyCode));
//        String re = HttpClientKit.post(sf_url, params, "UTF-8");
//        return re;
//    }
//
//    /**
//     * 校验返回的xml报文
//     * @param responseXml
//     * @param title
//     */
//    private void verificationResponXml(String responseXml,String title) throws Exception {
//        String error = "";
//        if (StringUtils.isBlank(responseXml)) {
//            // 如果返回的XML报文为空，请求也算失败
//            //保存http日志
//            error = title + "，返回的XML为空！";
//            logger.info(error);
//            throw new Exception(error);
//        }else{
////          报错的报文示例<Response service="ScopeService"><Head>ERR</Head><ERROR code="8014">校验码错误 </ERROR></Response>
//            Document doc = DocumentHelper.parseText(responseXml);
//            String headvalue = doc.selectSingleNode("/Response/Head").getText();
//            if(StringUtils.isNotBlank(headvalue) && "ERR".equals(headvalue)){
//                //错误代码
//                String errorCode = "";
//                //错误代对应的文字
//                String errorMessage = doc.selectSingleNode("/Response/ERROR").getText();
//                Document error_doc = doc.selectSingleNode("/Response/ERROR").getDocument();
//                Element root = error_doc.getRootElement();
//                List<?> child = root.elements();
//                for (Object o : child){
//                    Element e = (Element) o;
//                    errorCode = e.attributeValue("code");
//                }
//                error = title+","+errorCode+","+errorMessage;
//                logger.info(error);
//                throw new Exception(error);
//            }
//        }
//    }
//
//
//    /**
//     * 查询派送地址是否属于顺丰的派送范围
//     * @param d_address 派送地址
//     * @return
//     */
//    public Boolean getSFOrderFilterService(String d_address) throws Exception {
//
//        boolean result = false;
//
//        String xml = SFUtils.getSFOrderFilterXml(d_address,sf_code,"","","","");
//
//        String re = this.SFExpressPost(xml);
//
////        String re = "<Response service=\"OrderFilterService\"><Head>OK</Head><Body><OrderFilterResponse orderid=\"TE201407020016\" filter_result=\"2\" origincode=\"755\" remark=\"2\"/></Body></Response>";
//
//        //xml验证
//        verificationResponXml(re,"查询派送地址是否有效失败！");
//
//
//        Document doc = DocumentHelper.parseText(re);
//        String headvalue = doc.selectSingleNode("/Response/Head").getText();
//        Element root = doc.getRootElement();
//        if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
//            //是否能派送：1：人工确认；2：可收派；3：不可以收派
//            String filter_result = "";
//
//            Element firstWorldElement = root.element("Body");
//
//            List<Element> elements = firstWorldElement.elements();
//
//            for (Element o : elements){
//                filter_result = o.attributeValue("filter_result");
//            }
//
//            if(StringUtils.isNotBlank(filter_result) && "2".equals(filter_result)){
//                result = true;
//            }
//        }
//        return result;
//
//
//    }
//
//    /**
//     * 向顺丰快递下订单
//     * @param sfexpress_obj
//     * @return
//     * @throws Exception
//     */
//    public WlyyPrescriptionExpressageDO postSFOrderService(WlyyPrescriptionExpressageDO sfexpress_obj) throws Exception {
//
//        //获取医生所处的医院详细地址,作为寄件人地址
//        WlyyPrescriptionDO prescription = prescriptionDao.findOne(sfexpress_obj.getOutpatientId());
//        BaseOrgDO hospital = baseOrgDao.findByCode(prescription.getHospital());
//
//        String xml = SFUtils.postSFOrderService(sfexpress_obj,hospital,sf_code);
//        logger.info("顺丰快递下订单：xml"+xml);
//        String re = this.SFExpressPost(xml);
////        String re = "<Response service=\"OrderService\"><Head>OK</Head><Body><OrderResponse filter_result=\"2\" destcode=\"592\" mailno=\"444844978335\" origincode=\"592\" orderid=\"6daa6baec5fd4b65a1b023a8b60e2e91\"/></Body></Response>";
//
//        //xml验证
//        logger.info("顺丰快递下订单：re"+re);
//        verificationResponXml(re,"向顺丰快递下订单失败！");
//
//        Document doc = DocumentHelper.parseText(re);
//        String headvalue = doc.selectSingleNode("/Response/Head").getText();
//        if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
//            Element root = doc.getRootElement();
//            if (root.element("Body") != null)     //包含OrderResponse节点
//            {
//                root = root.element("Body");
//            }
//
//            //是否能派送：1：人工确认；2：可收派；3：不可以收派
//            String filter_result = "";
//            String orderid = "";//业务订单号
//            String mailno = "";//顺丰运单号
//            String destCode = "";//目的地区域代码
//            List<?> child = root.elements();
//            for (Object o : child) {
//                Element e = (Element) o;
//                filter_result = e.attributeValue("filter_result");
//                orderid = e.attributeValue("orderid");
//                mailno = e.attributeValue("mailno");
//                destCode = e.attributeValue("destcode");
//            }
//            if(StringUtils.isNotBlank(filter_result) && "3".equals(filter_result)){
//                logger.info("顺丰快递下订单失败：派送地址不可派送，门诊编号："+sfexpress_obj.getOutpatientId());
//                throw new Exception("顺丰快递下订单失败：派送地址不可派送");
//            }
//
//            if(StringUtils.isBlank(mailno)){
//                logger.info("顺丰快递下订单失败：未获取到快递单号！门诊编号："+sfexpress_obj.getOutpatientId());
//                throw new Exception("顺丰快递下订单失败：未获取到快递单号！");
//            }
//            sfexpress_obj.setMailno(mailno);
//            sfexpress_obj.setCityCode(destCode);
//        }
//        return sfexpress_obj;
//    }
//
//
//    /**
//     * 调用顺丰接口获取物流路由日志，与本地匹配，进行增量修改,并返回完整日志列表
//     * @param prescription
//     * @param sfexpress_obj
//     * @param sfexpresslogList
//     * @return
//     */
//    public List<WlyyPrescriptionExpressageLogDO> getRoutInfos(WlyyPrescriptionDO prescription, WlyyPrescriptionExpressageDO sfexpress_obj, List<WlyyPrescriptionExpressageLogDO> sfexpresslogList) throws Exception {
//        String xml = SFUtils.getRoutInfos(sfexpress_obj,sf_code);
//        String re = this.SFExpressPost(xml);
//        //xml验证
//        verificationResponXml(re,"查询顺丰快递路由信息失败！");
//        Document doc = DocumentHelper.parseText(re);
//        String headvalue = doc.selectSingleNode("/Response/Head").getText();
//        if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
//            Element root = doc.getRootElement();
//            if (root.element("Body") != null)     //取报文根节点
//            {
//                root = root.element("Body");
//            }
//            List<?> child = root.elements();
//            String mailno = "";
//            Map<String,List<WlyyPrescriptionExpressageLogDO>> wayroutlsit = new HashMap<>();
//            for (Object o : child) {
//                Element e = (Element) o;
//                mailno = e.attributeValue("mailno");
//                //判断快递单号不为空，且和我们本地的一致
//                if(StringUtils.isNotBlank(mailno) &&
//                        sfexpress_obj.getMailno().equals(mailno)){
//
//                    //解析报文，结合本地数据返回最终的日志结果
//                    return this.xmltologlist(e,sfexpresslogList,sfexpress_obj);
//                }else{
//                    continue;
//                }
//            }
//        }
//        return null;
//    }
//
//    private List<WlyyPrescriptionExpressageLogDO> xmltologlist(Element e, List<WlyyPrescriptionExpressageLogDO> sfexpresslogList, WlyyPrescriptionExpressageDO sfexpress_obj)throws Exception{
//
//        //获取本地所有路由信息的时间集
//        Set<String> routAcceptTimeSet = new HashSet<>();
//        for (WlyyPrescriptionExpressageLogDO log: sfexpresslogList) {
//            routAcceptTimeSet.add(DateUtil.dateToStrLong(log.getAcceptTime()));
//        }
//
//        List<?> child = e.elements();
//
//        List<WlyyPrescriptionExpressageLogDO> newroutinfolist = new ArrayList<>();
//
//        //用于判断新节点是否包含了"已收件"的节点
//        boolean isContainEndRoutInfo = false;
//
//        for (Object o : child) {
//            Element routinfoe = (Element) o;
//            String accept_time = routinfoe.attributeValue("accept_time");
//            String accept_address = routinfoe.attributeValue("accept_address");
//            String accept_remark = routinfoe.attributeValue("remark");
//            String opcode = routinfoe.attributeValue("opcode");
//
//            //和时间集作比对，过滤已存在的
//            if(!routAcceptTimeSet.contains(accept_time)){
//                WlyyPrescriptionExpressageLogDO newlogobj = new WlyyPrescriptionExpressageLogDO();
//                newlogobj.setAcceptTime(DateUtil.strToDate(accept_time));
//                newlogobj.setAcceptAddress(accept_address);
//                newlogobj.setAcceptRemark(accept_remark);
//                newlogobj.setOpCode(opcode);
//                newlogobj.setId(UUID.randomUUID().toString().replace("-",""));
//                newlogobj.setOutpatientId(sfexpress_obj.getOutpatientId());
//                newlogobj.setExpressageId(sfexpress_obj.getId());
//                newlogobj.setCreateTime(new Date());
//                newroutinfolist.add(newlogobj);
//                sfexpresslogList.add(newlogobj);
//                //aopcode=80，为已签收
//                if("80".equals(opcode)){
//                    isContainEndRoutInfo = true;
//                }
//            }
//        }
//
//
//        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
//        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); // 事物隔离级别，开启新事务
//        TransactionStatus status = transactionManager.getTransaction(def); // 获得事务状态
//        try {
//
//            //如果有新增的路由信息，则添加到数据库
//            if(!newroutinfolist.isEmpty()){
//                prescriptionExpressageLogDao.save(newroutinfolist);
//            }
//
//            //如果路由信息节点包含了"已收件"节点，这修改处方派送状态为完成，增加物流派送日志为完成
//            if(isContainEndRoutInfo){
//                //修改处方状态为完成
//                prescriptionDao.updateStatus(sfexpress_obj.getId(), 100,new Date());
//
//                //保存门诊处方配送成功的日志
//                WlyyOutpatientExpressageLogDO outpatiExpressLog = new WlyyOutpatientExpressageLogDO();
//                outpatiExpressLog.setOutpatientId(sfexpress_obj.getOutpatientId());
//                outpatiExpressLog.setId(UUID.randomUUID().toString());
//                outpatiExpressLog.setType(8);
//                outpatiExpressLog.setCreateTime(new Date());
//                outpatiExpressLog.setFlag(1);
//                outpatiExpressLog.setStatus(100);
//                outpatientExpressageLogDao.save(outpatiExpressLog);
//            }
//
//            //事务提交
//            transactionManager.commit(status);
//        } catch (Exception ex) {
//            //报错事务回滚
//            transactionManager.rollback(status);
//        }
//
//
//        return sfexpresslogList;
//    }
//
//    /**
//     * 解析顺丰推送过来的路由信息，和本地数据匹配并进行增量更新）
//     * @param xml
//     * @return
//     * @throws Exception
//     */
//    public void SFRoutePushService(String xml) throws Exception{
//        Document doc = DocumentHelper.parseText(xml);
//        Element root = doc.getRootElement();
//        if (root.element("Body") != null)     //包含WaybillRoute节点
//        {
//            root = root.element("Body");
//        }
//        List<?> child = root.elements();
//
//        Map<String,List<WlyyPrescriptionExpressageLogDO>> wayroutlsit = new HashMap<>();
//        for (Object o : child) {
//            Element routinfoe = (Element) o;
//            WlyyPrescriptionExpressageLogDO sflog = new WlyyPrescriptionExpressageLogDO();
//            String accept_time = routinfoe.attributeValue("accepttime");
//            String accept_address = routinfoe.attributeValue("acceptaddress");
//            String accept_remark = routinfoe.attributeValue("remark");
//            String opcode = routinfoe.attributeValue("opcode");
//            String mailno = routinfoe.attributeValue("mailno");
//            String orderid = routinfoe.attributeValue("orderid");
//
//            sflog.setAcceptTime(DateUtil.strToDate(accept_time));
//            sflog.setAcceptAddress(accept_address);
//            sflog.setAcceptRemark(accept_remark);
//            sflog.setOpCode(opcode);
//            sflog.setExpressageId(orderid);
//            sflog.setId(UUID.randomUUID().toString());
//            sflog.setCreateTime(new Date());
//            if(wayroutlsit.keySet().contains(mailno)){
//                wayroutlsit.get(mailno).add(sflog);
//            }else{
//                List<WlyyPrescriptionExpressageLogDO> newsflogs = new ArrayList<>();
//                newsflogs.add(sflog);
//                wayroutlsit.put(mailno,newsflogs);
//            }
//        }
//
//        if(!wayroutlsit.keySet().isEmpty()){
//            for (String mailno:wayroutlsit.keySet()) {
//                List<WlyyPrescriptionExpressageLogDO> pushSFLogs = wayroutlsit.get(mailno);
//                //同一个快递单号的执行一个事务操作
//                this.saveSFPushRoutInfos(mailno,pushSFLogs);
//            }
//        }
//    }
//
//    /**
//     * 同一个快递单号的执行一个事务操作
//     * @param mailno
//     * @param pushSFLogs
//     */
//    public void saveSFPushRoutInfos(String mailno,List<WlyyPrescriptionExpressageLogDO> pushSFLogs){
//
//        //根据快递单号获取处方配送详细信息
//        WlyyPrescriptionExpressageDO sfexpress = prescriptionExpressageDao.findByPrescriptionExpressMailno(mailno);
//        //根据快递单号获取本地的路由信息
//        List<WlyyPrescriptionExpressageLogDO> localroutinfos = prescriptionExpressageLogDao.queryByOutpatientId(sfexpress.getOutpatientId());
//        //需要增量更新到本地的路由信息集合
//        List<WlyyPrescriptionExpressageLogDO> newroutinfolist = new ArrayList<>();
//
//        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
//        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); // 事务隔离级别，开启新事务
//        TransactionStatus status = transactionManager.getTransaction(def); // 获得事务状态
//        try {
//
//            //用于判断新节点是否包含了"已收件"的节点
//            boolean isContainEndRoutInfo = false;
//
//            //获取本地所有路由信息的时间集
//            Set<String> routAcceptTimeSet = new HashSet<>();
//            for (WlyyPrescriptionExpressageLogDO log: localroutinfos) {
//                routAcceptTimeSet.add(DateUtil.dateToStrLong(log.getAcceptTime()));
//            }
//
//            for (WlyyPrescriptionExpressageLogDO pushlog: pushSFLogs) {
//
//                //判断是否有已收件的路由节点
//                if("80".equals(pushlog.getOpCode())){
//                    isContainEndRoutInfo = true;
//                }
//
//                if(routAcceptTimeSet.contains(DateUtil.dateToStrLong(pushlog.getAcceptTime()))){
//                    continue;
//                }else{
//                    pushlog.setOutpatientId(sfexpress.getOutpatientId());
//                    newroutinfolist.add(pushlog);
//                }
//            }
//
//            //如果有新增的路由信息，则添加到数据库
//            if(!newroutinfolist.isEmpty()){
//                prescriptionExpressageLogDao.save(newroutinfolist);
//            }
//
//            //如果路由信息节点包含了"已收件"节点，则修改处方状态为完成，增加物流派送日志为完成
//            if(isContainEndRoutInfo){
//                //修改处方状态为完成
//                prescriptionDao.updateStatus(sfexpress.getOutpatientId(), 100,new Date());
//
//                //保存配送成功的日志
//                WlyyOutpatientExpressageLogDO outpatiExpressLog = new WlyyOutpatientExpressageLogDO();
//                outpatiExpressLog.setOutpatientId(sfexpress.getOutpatientId());
//                outpatiExpressLog.setId(UUID.randomUUID().toString());
//                outpatiExpressLog.setType(8);
//                outpatiExpressLog.setCreateTime(new Date());
//                outpatiExpressLog.setFlag(1);
//                outpatiExpressLog.setStatus(100);
//                outpatientExpressageLogDao.save(outpatiExpressLog);
//            }
//            //事务提交
//            transactionManager.commit(status);
//        } catch (Exception ex) {
//            //报错事务回滚
//            transactionManager.rollback(status);
//        }
//
//
//    }
//
//    /**
//     * 根据收寄地址获取快递费用
//     * @param d_province 省份名称
//     * @param d_city     城市名称
//     * @return
//     */
//    public WlyyExpressagePriceDO getSFExpressPrice(String d_province, String d_city) throws Exception{
//        String end_address_name = "";
//
//        if("厦门市".equals(d_city)){
//            end_address_name = "同城";
//        }else{
//            if("福建省".equals(d_province)){
//                end_address_name = "省内";
//            }else{
//                end_address_name = d_province;
//            }
//        }
//        end_address_name = "%"+end_address_name.replaceAll("省","").replaceAll("市","")+"%";
//        WlyyExpressagePriceDO sfprice =  expressagePriceDao.getExprePriceByIdAndEndAdressName("shunfeng",end_address_name);
//        return sfprice;
//    }
//
//    /**
//     * 根据处方快递订单号判断是否下单成功
//     * 如果下单成功，保存处方物流记录，保存配送日志
//     * @param sfexpress_obj
//     * @return
//     * @throws Exception
//     */
//    public boolean sfOrderSearchService(WlyyPrescriptionExpressageDO sfexpress_obj)  throws Exception{
//
//        boolean go_on = false;
//
//        String xml = SFUtils.sfOrderSearchService(sfexpress_obj.getId(),sf_code);
//        String re = this.SFExpressPost(xml);
//
//        try {
//            //xml验证
//            verificationResponXml(re,"订单处理失败！");
//
//            Document doc = DocumentHelper.parseText(re);
//            String headvalue = doc.selectSingleNode("/Response/Head").getText();
//            if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
//                //是否能派送：1：人工确认；2：可收派；3：不可以收派
//                String filter_result = "";
//                String orderid = "";//业务订单号
//                String mailno = "";//顺丰运单号
//                String destCode = "";//目的地区域代码
//
//                //错误代对应的文字
//                Document redoc = doc.selectSingleNode("/Response/Body/Orderresponse").getDocument();
//                Element root = redoc.getRootElement();
//                List<?> child = root.elements();
//                for (Object o : child) {
//                    Element e = (Element) o;
//                    filter_result = e.attributeValue("filter_result");
//                    orderid = e.attributeValue("orderid");
//                    mailno = e.attributeValue("mailno");
//                    destCode = e.attributeValue("destCode");
//                }
//
//                if(StringUtils.isBlank(mailno)){
//                    logger.info("顺丰快递下订单失败：未获取到快递单号！"+sfexpress_obj.getOutpatientId());
//                    return true;
//                }
//
//                if(StringUtils.isNotBlank(filter_result) && "3".equals(filter_result)){
//                    logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
//                    return true;
//                }
//
//                sfexpress_obj.setMailno(mailno);
//                sfexpress_obj.setCityCode(destCode);
//            }
//
//            //如果成功获取到快递单号，则保存处方物流记录，保存配送日志
//            //修改处方状态为配送中
//            prescriptionDao.updateStatus(sfexpress_obj.getOutpatientId(),65);
//
//            //保存处方物流记录
//            prescriptionExpressageDao.save(sfexpress_obj);
//
//            //保存配送日志
//            WlyyOutpatientExpressageLogDO outpatiExpressLog = new WlyyOutpatientExpressageLogDO();
//            outpatiExpressLog.setOutpatientId(sfexpress_obj.getOutpatientId());
//            outpatiExpressLog.setId(UUID.randomUUID().toString());
//            outpatiExpressLog.setType(8);
//            outpatiExpressLog.setCreateTime(new Date());
//            outpatiExpressLog.setFlag(1);
//            outpatiExpressLog.setStatus(100);
//            outpatientExpressageLogDao.save(outpatiExpressLog);
//
//
//        }catch (Exception ex){
//            logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
//            //如果订单处理失败，则可以继续下单
//            go_on = true;
//        }
//
//        return go_on;
//
//    }
//
//    public boolean sfOrderSearchServiceJustSearch(WlyyPrescriptionExpressageDO sfexpress_obj)  throws Exception{
//
//        String xml = SFUtils.sfOrderSearchService(sfexpress_obj.getId(),sf_code);
//        String re = this.SFExpressPost(xml);
//
//        boolean reslut = false;
//
//        try {
//            //xml验证
//            verificationResponXml(re,"订单处理失败！");
//
//            Document doc = DocumentHelper.parseText(re);
//            String headvalue = doc.selectSingleNode("/Response/Head").getText();
//            if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
//                Element root = doc.getRootElement();
//                if (root.element("Body") != null)     //包含OrderResponse节点
//                {
//                    root = root.element("Body");
//                }
//
//                //是否能派送：1：人工确认；2：可收派；3：不可以收派
//                String filter_result = "";
//                String orderid = "";//业务订单号
//                String mailno = "";//顺丰运单号
//                List<?> child = root.elements();
//                for (Object o : child) {
//                    Element e = (Element) o;
//                    filter_result = e.attributeValue("filter_result");
//                    orderid = e.attributeValue("orderid");
//                    mailno = e.attributeValue("mailno");
//                }
//                if(StringUtils.isNotBlank(filter_result) && "3".equals(filter_result)){
//                    logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
//                    throw new Exception("顺丰快递下订单失败：派送地址不可派送");
//                }
//
//                if(StringUtils.isBlank(mailno)){
//                    logger.info("顺丰快递下订单失败：未获取到快递单号！"+sfexpress_obj.getOutpatientId());
//                    throw new Exception("顺丰快递下订单失败：未获取到快递单号！");
//                }
//            }
//
//
//
//        }catch (Exception ex){
//            logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
//            //如果订单处理失败，则可以继续下单
//            throw new Exception(ex.getMessage());
//        }
//
//        return reslut;
//    }
//
//    public String getRoutInfosSearch(WlyyPrescriptionExpressageDO sfexpress_obj)throws Exception {
//        String xml = SFUtils.getRoutInfos(sfexpress_obj,sf_code);
//        String re = this.SFExpressPost(xml);
//
//        return xml;
//    }
//
//}
package com.yihu.jw.hospital.prescription.service;
import com.yihu.jw.entity.base.org.BaseOrgDO;
import com.yihu.jw.entity.hospital.prescription.*;
import com.yihu.jw.hospital.prescription.dao.*;
import com.yihu.jw.hospital.prescription.service.entrance.util.SFUtils;
import com.yihu.jw.org.dao.BaseOrgDao;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.jw.util.http.HttpClientKit;
import com.yihu.mysql.query.BaseJpaService;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import java.util.*;
/**
 *  门诊物流服务
 * lith 2019.06.04
 */
@Service
public class PrescriptionExpressageService extends BaseJpaService<WlyyPrescriptionExpressageDO, PrescriptionExpressageDao> {
    private static Logger logger = LoggerFactory.getLogger(PrescriptionExpressageService.class);
    //顺丰快递接口请求地址
    @Value("${express.sf_url}")
    private String sf_url;
    //顺丰快递接口接入编码
    @Value("${express.sf_code}")
    private String sf_code;
    //顺丰快递接口checkword
    @Value("${express.sf_check_word}")
    private String sf_check_word;
    @Autowired
    private SFUtils SFUtils;
    @Autowired
    private JpaTransactionManager transactionManager;
    //处方日志
    @Autowired
    private WlyyOutpatientExpressageLogDao outpatientExpressageLogDao;
    @Autowired
    private PrescriptionDao prescriptionDao;
    @Autowired
    private WlyyExpressagePriceDao expressagePriceDao;
    @Autowired
    private PrescriptionExpressageLogDao prescriptionExpressageLogDao;
    @Autowired
    private PrescriptionExpressageDao prescriptionExpressageDao;
    @Autowired
    private BaseOrgDao baseOrgDao;
    @Autowired
    private OutpatientDao outpatientDao;
    /**
     * 组装请求参数，发送请求
     * @param xml
     * @return
     * @throws Exception
     */
    private String SFExpressPost(String xml)throws Exception{
        String verifyCode = SFUtils.verifyCodeSFXmlStr(xml,sf_check_word);
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("xml", xml));
        params.add(new BasicNameValuePair("verifyCode", verifyCode));
        String re = HttpClientKit.post(sf_url, params, "UTF-8");
        return re;
    }
    /**
     * 校验返回的xml报文
     * @param responseXml
     * @param title
     */
    private void verificationResponXml(String responseXml,String title) throws Exception {
        String error = "";
        if (StringUtils.isBlank(responseXml)) {
            // 如果返回的XML报文为空，请求也算失败
            //保存http日志
            error = title + "，返回的XML为空！";
            logger.info(error);
            throw new Exception(error);
        }else{
//          报错的报文示例<Response service="ScopeService"><Head>ERR</Head><ERROR code="8014">校验码错误 </ERROR></Response>
            Document doc = DocumentHelper.parseText(responseXml);
            String headvalue = doc.selectSingleNode("/Response/Head").getText();
            if(StringUtils.isNotBlank(headvalue) && "ERR".equals(headvalue)){
                //错误代码
                String errorCode = "";
                //错误代对应的文字
                String errorMessage = doc.selectSingleNode("/Response/ERROR").getText();
                Document error_doc = doc.selectSingleNode("/Response/ERROR").getDocument();
                Element root = error_doc.getRootElement();
                List<?> child = root.elements();
                for (Object o : child){
                    Element e = (Element) o;
                    errorCode = e.attributeValue("code");
                }
                error = title+","+errorCode+","+errorMessage;
                logger.info(error);
                throw new Exception(error);
            }
        }
    }
    /**
     * 查询派送地址是否属于顺丰的派送范围
     * @param d_address 派送地址
     * @return
     */
    public Boolean getSFOrderFilterService(String d_address) throws Exception {
        boolean result = false;
        String xml = SFUtils.getSFOrderFilterXml(d_address,sf_code,"","","","");
        String re = this.SFExpressPost(xml);
//        String re = "<Response service=\"OrderFilterService\"><Head>OK</Head><Body><OrderFilterResponse orderid=\"TE201407020016\" filter_result=\"2\" origincode=\"755\" remark=\"2\"/></Body></Response>";
        //xml验证
        verificationResponXml(re,"查询派送地址是否有效失败！");
        Document doc = DocumentHelper.parseText(re);
        String headvalue = doc.selectSingleNode("/Response/Head").getText();
        Element root = doc.getRootElement();
        if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
            //是否能派送：1：人工确认；2：可收派；3：不可以收派
            String filter_result = "";
            Element firstWorldElement = root.element("Body");
            List<Element> elements = firstWorldElement.elements();
            for (Element o : elements){
                filter_result = o.attributeValue("filter_result");
            }
            if(StringUtils.isNotBlank(filter_result) && "2".equals(filter_result)){
                result = true;
            }
        }
        return result;
    }
    /**
     * 向顺丰快递下订单
     * @param sfexpress_obj
     * @return
     * @throws Exception
     */
    public WlyyPrescriptionExpressageDO postSFOrderService(WlyyPrescriptionExpressageDO sfexpress_obj) throws Exception {
        //获取医生所处的医院详细地址,作为寄件人地址
        WlyyOutpatientDO outpatientDO = outpatientDao.findOne(sfexpress_obj.getOutpatientId());
        BaseOrgDO hospital = baseOrgDao.findByCode(outpatientDO.getHospital());
        String xml = SFUtils.postSFOrderService(sfexpress_obj,hospital,sf_code);
        logger.info("顺丰快递下订单：xml"+xml);
        String re = this.SFExpressPost(xml);
//        String re = "<Response service=\"OrderService\"><Head>OK</Head><Body><OrderResponse filter_result=\"2\" destcode=\"592\" mailno=\"444844978335\" origincode=\"592\" orderid=\"6daa6baec5fd4b65a1b023a8b60e2e91\"/></Body></Response>";
        //xml验证
        logger.info("顺丰快递下订单：re"+re);
        verificationResponXml(re,"向顺丰快递下订单失败！");
        Document doc = DocumentHelper.parseText(re);
        String headvalue = doc.selectSingleNode("/Response/Head").getText();
        if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
            Element root = doc.getRootElement();
            if (root.element("Body") != null)     //包含OrderResponse节点
            {
                root = root.element("Body");
            }
            //是否能派送：1：人工确认；2：可收派；3：不可以收派
            String filter_result = "";
            String orderid = "";//业务订单号
            String mailno = "";//顺丰运单号
            String destCode = "";//目的地区域代码
            List<?> child = root.elements();
            for (Object o : child) {
                Element e = (Element) o;
                filter_result = e.attributeValue("filter_result");
                orderid = e.attributeValue("orderid");
                mailno = e.attributeValue("mailno");
                destCode = e.attributeValue("destcode");
            }
            if(StringUtils.isNotBlank(filter_result) && "3".equals(filter_result)){
                logger.info("顺丰快递下订单失败：派送地址不可派送，门诊编号："+sfexpress_obj.getOutpatientId());
                throw new Exception("顺丰快递下订单失败：派送地址不可派送");
            }
            if(StringUtils.isBlank(mailno)){
                logger.info("顺丰快递下订单失败：未获取到快递单号！门诊编号："+sfexpress_obj.getOutpatientId());
                throw new Exception("顺丰快递下订单失败：未获取到快递单号！");
            }
            sfexpress_obj.setMailno(mailno);
            sfexpress_obj.setCityCode(destCode);
        }
        return sfexpress_obj;
    }
    /**
     * 向顺丰快递取消订单
     * @param sfexpress_obj
     * @return
     * @throws Exception
     */
    public String postOrderConfirmService(WlyyPrescriptionExpressageDO sfexpress_obj) throws Exception {
        //获取医生所处的医院详细地址,作为寄件人地址
        WlyyOutpatientDO outpatientDO = outpatientDao.findOne(sfexpress_obj.getOutpatientId());
        BaseOrgDO hospital = baseOrgDao.findByCode(outpatientDO.getHospital());
        String xml = SFUtils.SFOrderConfirmXml(sf_code,sfexpress_obj.getId(),sfexpress_obj.getMailno(),2);
        logger.info("顺丰快递取消订单请求：xml"+xml);
        String re = this.SFExpressPost(xml);
//        String re = "<Response service=\"OrderService\"><Head>OK</Head><Body><OrderResponse filter_result=\"2\" destcode=\"592\" mailno=\"444844978335\" origincode=\"592\" orderid=\"6daa6baec5fd4b65a1b023a8b60e2e91\"/></Body></Response>";
        //xml验证
        logger.info("顺丰快递取消订单结果：re"+re);
        verificationResponXml(re,"顺丰快递取消订单失败！");
        Document doc = DocumentHelper.parseText(re);
        String headvalue = doc.selectSingleNode("/Response/Head").getText();
        if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
            Element root = doc.getRootElement();
            if (root.element("Body") != null)     //包含OrderResponse节点
            {
                root = root.element("Body");
            }
            String res_status = "";
            List<?> child = root.elements();
            for (Object o : child) {
                Element e = (Element) o;
                // 1：客户订单号与顺丰运单不匹配 2 ：操作成功
                res_status = e.attributeValue("res_status");
            }
            if(StringUtils.isNotBlank(res_status) && !"2".equals(res_status)){
                logger.info("顺丰快递取消订单失败：门诊编号："+sfexpress_obj.getOutpatientId());
                throw new Exception("顺丰快递取消订单失败：客户订单号与顺丰运单不匹配");
            }
        }
        return "取消成功";
    }
    /**
     * 调用顺丰接口获取物流路由日志，与本地匹配，进行增量修改,并返回完整日志列表
     * @param prescription
     * @param sfexpress_obj
     * @param sfexpresslogList
     * @return
     */
    public List<WlyyPrescriptionExpressageLogDO> getRoutInfos(WlyyPrescriptionDO prescription, WlyyPrescriptionExpressageDO sfexpress_obj, List<WlyyPrescriptionExpressageLogDO> sfexpresslogList) throws Exception {
        String xml = SFUtils.getRoutInfos(sfexpress_obj,sf_code);
        String re = this.SFExpressPost(xml);
        //xml验证
        verificationResponXml(re,"查询顺丰快递路由信息失败！");
        Document doc = DocumentHelper.parseText(re);
        String headvalue = doc.selectSingleNode("/Response/Head").getText();
        if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
            Element root = doc.getRootElement();
            if (root.element("Body") != null)     //取报文根节点
            {
                root = root.element("Body");
            }
            List<?> child = root.elements();
            String mailno = "";
            Map<String,List<WlyyPrescriptionExpressageLogDO>> wayroutlsit = new HashMap<>();
            for (Object o : child) {
                Element e = (Element) o;
                mailno = e.attributeValue("mailno");
                //判断快递单号不为空，且和我们本地的一致
                if(StringUtils.isNotBlank(mailno) &&
                        sfexpress_obj.getMailno().equals(mailno)){
                    //解析报文，结合本地数据返回最终的日志结果
                    return this.xmltologlist(e,sfexpresslogList,sfexpress_obj);
                }else{
                    continue;
                }
            }
        }
        return null;
    }
    private List<WlyyPrescriptionExpressageLogDO> xmltologlist(Element e, List<WlyyPrescriptionExpressageLogDO> sfexpresslogList, WlyyPrescriptionExpressageDO sfexpress_obj)throws Exception{
        //获取本地所有路由信息的时间集
        Set<String> routAcceptTimeSet = new HashSet<>();
        for (WlyyPrescriptionExpressageLogDO log: sfexpresslogList) {
            routAcceptTimeSet.add(DateUtil.dateToStrLong(log.getAcceptTime()));
        }
        List<?> child = e.elements();
        List<WlyyPrescriptionExpressageLogDO> newroutinfolist = new ArrayList<>();
        //用于判断新节点是否包含了"已收件"的节点
        boolean isContainEndRoutInfo = false;
        for (Object o : child) {
            Element routinfoe = (Element) o;
            String accept_time = routinfoe.attributeValue("accept_time");
            String accept_address = routinfoe.attributeValue("accept_address");
            String accept_remark = routinfoe.attributeValue("remark");
            String opcode = routinfoe.attributeValue("opcode");
            //和时间集作比对，过滤已存在的
            if(!routAcceptTimeSet.contains(accept_time)){
                WlyyPrescriptionExpressageLogDO newlogobj = new WlyyPrescriptionExpressageLogDO();
                newlogobj.setAcceptTime(DateUtil.strToDate(accept_time));
                newlogobj.setAcceptAddress(accept_address);
                newlogobj.setAcceptRemark(accept_remark);
                newlogobj.setOpCode(opcode);
                newlogobj.setId(UUID.randomUUID().toString().replace("-",""));
                newlogobj.setOutpatientId(sfexpress_obj.getOutpatientId());
                newlogobj.setExpressageId(sfexpress_obj.getId());
                newlogobj.setCreateTime(new Date());
                newroutinfolist.add(newlogobj);
                sfexpresslogList.add(newlogobj);
                //aopcode=80，为已签收
                if("80".equals(opcode)){
                    isContainEndRoutInfo = true;
                }
            }
        }
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); // 事物隔离级别，开启新事务
        TransactionStatus status = transactionManager.getTransaction(def); // 获得事务状态
        try {
            //如果有新增的路由信息，则添加到数据库
            if(!newroutinfolist.isEmpty()){
                prescriptionExpressageLogDao.save(newroutinfolist);
            }
            //如果路由信息节点包含了"已收件"节点，这修改处方派送状态为完成，增加物流派送日志为完成
            if(isContainEndRoutInfo){
                //修改处方状态为完成
                prescriptionDao.updateStatus(sfexpress_obj.getId(), 100,new Date());
                //保存门诊处方配送成功的日志
                WlyyOutpatientExpressageLogDO outpatiExpressLog = new WlyyOutpatientExpressageLogDO();
                outpatiExpressLog.setOutpatientId(sfexpress_obj.getOutpatientId());
                outpatiExpressLog.setId(UUID.randomUUID().toString());
                outpatiExpressLog.setType(8);
                outpatiExpressLog.setCreateTime(new Date());
                outpatiExpressLog.setFlag(1);
                outpatiExpressLog.setStatus(100);
                outpatientExpressageLogDao.save(outpatiExpressLog);
            }
            //事务提交
            transactionManager.commit(status);
        } catch (Exception ex) {
            //报错事务回滚
            transactionManager.rollback(status);
        }
        return sfexpresslogList;
    }
    /**
     * 解析顺丰推送过来的路由信息，和本地数据匹配并进行增量更新）
     * @param xml
     * @return
     * @throws Exception
     */
    public void SFRoutePushService(String xml) throws Exception{
        Document doc = DocumentHelper.parseText(xml);
        Element root = doc.getRootElement();
        if (root.element("Body") != null)     //包含WaybillRoute节点
        {
            root = root.element("Body");
        }
        List<?> child = root.elements();
        Map<String,List<WlyyPrescriptionExpressageLogDO>> wayroutlsit = new HashMap<>();
        for (Object o : child) {
            Element routinfoe = (Element) o;
            WlyyPrescriptionExpressageLogDO sflog = new WlyyPrescriptionExpressageLogDO();
            String accept_time = routinfoe.attributeValue("accepttime");
            String accept_address = routinfoe.attributeValue("acceptaddress");
            String accept_remark = routinfoe.attributeValue("remark");
            String opcode = routinfoe.attributeValue("opcode");
            String mailno = routinfoe.attributeValue("mailno");
            String orderid = routinfoe.attributeValue("orderid");
            sflog.setAcceptTime(DateUtil.strToDate(accept_time));
            sflog.setAcceptAddress(accept_address);
            sflog.setAcceptRemark(accept_remark);
            sflog.setOpCode(opcode);
            sflog.setExpressageId(orderid);
            sflog.setId(UUID.randomUUID().toString());
            sflog.setCreateTime(new Date());
            if(wayroutlsit.keySet().contains(mailno)){
                wayroutlsit.get(mailno).add(sflog);
            }else{
                List<WlyyPrescriptionExpressageLogDO> newsflogs = new ArrayList<>();
                newsflogs.add(sflog);
                wayroutlsit.put(mailno,newsflogs);
            }
        }
        if(!wayroutlsit.keySet().isEmpty()){
            for (String mailno:wayroutlsit.keySet()) {
                List<WlyyPrescriptionExpressageLogDO> pushSFLogs = wayroutlsit.get(mailno);
                //同一个快递单号的执行一个事务操作
                this.saveSFPushRoutInfos(mailno,pushSFLogs);
            }
        }
    }
    /**
     * 同一个快递单号的执行一个事务操作
     * @param mailno
     * @param pushSFLogs
     */
    public void saveSFPushRoutInfos(String mailno,List<WlyyPrescriptionExpressageLogDO> pushSFLogs){
        //根据快递单号获取处方配送详细信息
        WlyyPrescriptionExpressageDO sfexpress = prescriptionExpressageDao.findByPrescriptionExpressMailno(mailno);
        //根据快递单号获取本地的路由信息
        List<WlyyPrescriptionExpressageLogDO> localroutinfos = prescriptionExpressageLogDao.queryByOutpatientId(sfexpress.getOutpatientId());
        //需要增量更新到本地的路由信息集合
        List<WlyyPrescriptionExpressageLogDO> newroutinfolist = new ArrayList<>();
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); // 事务隔离级别，开启新事务
        TransactionStatus status = transactionManager.getTransaction(def); // 获得事务状态
        try {
            //用于判断新节点是否包含了"已收件"的节点
            boolean isContainEndRoutInfo = false;
            //获取本地所有路由信息的时间集
            Set<String> routAcceptTimeSet = new HashSet<>();
            for (WlyyPrescriptionExpressageLogDO log: localroutinfos) {
                routAcceptTimeSet.add(DateUtil.dateToStrLong(log.getAcceptTime()));
            }
            for (WlyyPrescriptionExpressageLogDO pushlog: pushSFLogs) {
                //判断是否有已收件的路由节点
                if("80".equals(pushlog.getOpCode())){
                    isContainEndRoutInfo = true;
                }
                if(routAcceptTimeSet.contains(DateUtil.dateToStrLong(pushlog.getAcceptTime()))){
                    continue;
                }else{
                    pushlog.setOutpatientId(sfexpress.getOutpatientId());
                    newroutinfolist.add(pushlog);
                }
            }
            //如果有新增的路由信息，则添加到数据库
            if(!newroutinfolist.isEmpty()){
                prescriptionExpressageLogDao.save(newroutinfolist);
            }
            //如果路由信息节点包含了"已收件"节点，则修改处方状态为完成，增加物流派送日志为完成
            if(isContainEndRoutInfo){
                //修改处方状态为完成
                prescriptionDao.updateStatus(sfexpress.getOutpatientId(), 100,new Date());
                //保存配送成功的日志
                WlyyOutpatientExpressageLogDO outpatiExpressLog = new WlyyOutpatientExpressageLogDO();
                outpatiExpressLog.setOutpatientId(sfexpress.getOutpatientId());
                outpatiExpressLog.setId(UUID.randomUUID().toString());
                outpatiExpressLog.setType(8);
                outpatiExpressLog.setCreateTime(new Date());
                outpatiExpressLog.setFlag(1);
                outpatiExpressLog.setStatus(100);
                outpatientExpressageLogDao.save(outpatiExpressLog);
            }
            //事务提交
            transactionManager.commit(status);
        } catch (Exception ex) {
            //报错事务回滚
            transactionManager.rollback(status);
        }
    }
    /**
     * 根据收寄地址获取快递费用
     * @param d_province 省份名称
     * @param d_city     城市名称
     * @return
     */
    public WlyyExpressagePriceDO getSFExpressPrice(String d_province, String d_city) throws Exception{
        String end_address_name = "";
        if("厦门市".equals(d_city)){
            end_address_name = "同城";
        }else{
            if("福建省".equals(d_province)){
                end_address_name = "省内";
            }else{
                end_address_name = d_province;
            }
        }
        end_address_name = "%"+end_address_name.replaceAll("省","").replaceAll("市","")+"%";
        WlyyExpressagePriceDO sfprice =  expressagePriceDao.getExprePriceByIdAndEndAdressName("shunfeng",end_address_name);
        return sfprice;
    }
    /**
     * 根据处方快递订单号判断是否下单成功
     * 如果下单成功，保存处方物流记录，保存配送日志
     * @param sfexpress_obj
     * @return
     * @throws Exception
     */
    public boolean sfOrderSearchService(WlyyPrescriptionExpressageDO sfexpress_obj)  throws Exception{
        boolean go_on = false;
        String xml = SFUtils.sfOrderSearchService(sfexpress_obj.getId(),sf_code);
        String re = this.SFExpressPost(xml);
        try {
            //xml验证
            verificationResponXml(re,"订单处理失败！");
            Document doc = DocumentHelper.parseText(re);
            String headvalue = doc.selectSingleNode("/Response/Head").getText();
            if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
                //是否能派送：1：人工确认；2：可收派；3：不可以收派
                String filter_result = "";
                String orderid = "";//业务订单号
                String mailno = "";//顺丰运单号
                String destCode = "";//目的地区域代码
                //错误代对应的文字
                Document redoc = doc.selectSingleNode("/Response/Body/Orderresponse").getDocument();
                Element root = redoc.getRootElement();
                List<?> child = root.elements();
                for (Object o : child) {
                    Element e = (Element) o;
                    filter_result = e.attributeValue("filter_result");
                    orderid = e.attributeValue("orderid");
                    mailno = e.attributeValue("mailno");
                    destCode = e.attributeValue("destCode");
                }
                if(StringUtils.isBlank(mailno)){
                    logger.info("顺丰快递下订单失败：未获取到快递单号！"+sfexpress_obj.getOutpatientId());
                    return true;
                }
                if(StringUtils.isNotBlank(filter_result) && "3".equals(filter_result)){
                    logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
                    return true;
                }
                sfexpress_obj.setMailno(mailno);
                sfexpress_obj.setCityCode(destCode);
            }
            //如果成功获取到快递单号，则保存处方物流记录，保存配送日志
            //修改处方状态为配送中
            prescriptionDao.updateStatus(sfexpress_obj.getOutpatientId(),65);
            //保存处方物流记录
            prescriptionExpressageDao.save(sfexpress_obj);
            //保存配送日志
            WlyyOutpatientExpressageLogDO outpatiExpressLog = new WlyyOutpatientExpressageLogDO();
            outpatiExpressLog.setOutpatientId(sfexpress_obj.getOutpatientId());
            outpatiExpressLog.setId(UUID.randomUUID().toString());
            outpatiExpressLog.setType(8);
            outpatiExpressLog.setCreateTime(new Date());
            outpatiExpressLog.setFlag(1);
            outpatiExpressLog.setStatus(100);
            outpatientExpressageLogDao.save(outpatiExpressLog);
        }catch (Exception ex){
            logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
            //如果订单处理失败，则可以继续下单
            go_on = true;
        }
        return go_on;
    }
    public boolean sfOrderSearchServiceJustSearch(WlyyPrescriptionExpressageDO sfexpress_obj)  throws Exception{
        String xml = SFUtils.sfOrderSearchService(sfexpress_obj.getId(),sf_code);
        String re = this.SFExpressPost(xml);
        boolean reslut = false;
        try {
            //xml验证
            verificationResponXml(re,"订单处理失败！");
            Document doc = DocumentHelper.parseText(re);
            String headvalue = doc.selectSingleNode("/Response/Head").getText();
            if(StringUtils.isNotBlank(headvalue) && "OK".equals(headvalue)) {
                Element root = doc.getRootElement();
                if (root.element("Body") != null)     //包含OrderResponse节点
                {
                    root = root.element("Body");
                }
                //是否能派送：1：人工确认；2：可收派；3：不可以收派
                String filter_result = "";
                String orderid = "";//业务订单号
                String mailno = "";//顺丰运单号
                List<?> child = root.elements();
                for (Object o : child) {
                    Element e = (Element) o;
                    filter_result = e.attributeValue("filter_result");
                    orderid = e.attributeValue("orderid");
                    mailno = e.attributeValue("mailno");
                }
                if(StringUtils.isNotBlank(filter_result) && "3".equals(filter_result)){
                    logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
                    throw new Exception("顺丰快递下订单失败：派送地址不可派送");
                }
                if(StringUtils.isBlank(mailno)){
                    logger.info("顺丰快递下订单失败：未获取到快递单号！"+sfexpress_obj.getOutpatientId());
                    throw new Exception("顺丰快递下订单失败：未获取到快递单号！");
                }
            }
        }catch (Exception ex){
            logger.info("顺丰快递下订单失败：派送地址不可派送，处方编号："+sfexpress_obj.getOutpatientId());
            //如果订单处理失败，则可以继续下单
            throw new Exception(ex.getMessage());
        }
        return reslut;
    }
    public String getRoutInfosSearch(WlyyPrescriptionExpressageDO sfexpress_obj)throws Exception {
        String xml = SFUtils.getRoutInfos(sfexpress_obj,sf_code);
        String re = this.SFExpressPost(xml);
        return xml;
    }
    /**
     * 1，保存快递单号增
     * 2，加处方物流记录为配送
     * 3，修改处方状态为配送配送中
     *
     * @param prescriptionExpressage
     * @throws Exception
     */
    @Transactional
    public void updatePrescriptionExpressage(WlyyPrescriptionExpressageDO prescriptionExpressage) throws Exception {
        //修改门诊处方状态为配送配送中
        prescriptionDao.updateStatus(prescriptionExpressage.getId(), 32);
        //保存处方物流记录
        prescriptionExpressageDao.save(prescriptionExpressage);
        //保存门诊配送日志
        WlyyOutpatientExpressageLogDO prescriptionLog = new WlyyOutpatientExpressageLogDO();
        prescriptionLog.setOutpatientId(prescriptionExpressage.getOutpatientId());
        // 类型: -1 失效 1HIS对接 2易联众对接  3创建处方 4 审核  5付款 6 配送 7完成 8物流对接
        prescriptionLog.setType(8);
        // -2 患者自己取消 -1 审核不通过 , 0 审核中, 10 审核通过/待支付 ,21支付失败  20 配药中/支付成功, 21 等待领药 ,30 配送中 ,100配送成功/已完成
        prescriptionLog.setStatus(30);
        prescriptionLog.setCreateTime(new Date());
        prescriptionLog.setFlag(1);
        outpatientExpressageLogDao.save(prescriptionLog);
    }
}

business/base-service/src/main/java/com/yihu/jw/hospital/prescription/service/entrance/EntranceService.java

@@ -3,8 +3,13 @@ package com.yihu.jw.hospital.prescription.service.entrance;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.dict.dao.DictHospitalDeptDao;
import com.yihu.jw.dict.service.DictHospitalDeptService;
import com.yihu.jw.entity.base.dict.DictHospitalDeptDO;
import com.yihu.jw.entity.hospital.mapping.HospitalDeptMappingDO;
import com.yihu.jw.entity.hospital.mapping.PatientMappingDO;
import com.yihu.jw.hospital.mapping.dao.HospitalDeptMappingDao;
import com.yihu.jw.hospital.mapping.dao.PatientMappingDao;
import com.yihu.jw.hospital.prescription.service.entrance.util.ConvertUtil;
import com.yihu.jw.hospital.prescription.service.entrance.util.MqSdkUtil;
import com.yihu.jw.hospital.prescription.service.entrance.util.WebserviceUtil;
@@ -21,6 +26,7 @@ import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
@@ -35,6 +41,7 @@ import java.util.stream.Collectors;
 * Created by zdm on 2019/5/20.
 */
@Service
@Transactional
public class EntranceService {
    //门诊余额查询
    private static String BS15017="BS15017";
@@ -69,7 +76,9 @@ public class EntranceService {
    @Value("${hospital.TargetSysCode}")
    private String targetSysCode;
    @Autowired
    private HospitalDeptMappingDao hospitalDeptMappingDao;
    private DictHospitalDeptDao dictHospitalDeptDao;
    @Autowired
    private PatientMappingDao patientMappingDao;
    /**
     * 获取本地示例返参
@@ -262,6 +271,8 @@ public class EntranceService {
                                if (!(null != stringSet && stringSet.contains(realOrder))) {
                                    //初始化处方
                                    wlyyPrescriptionVO = initWlyyPrescriptionVo(new WlyyPrescriptionVO(), jsonObjectBody, realOrder);
                                    wlyyPrescriptionVO.setHospital("350211A1002");
                                    wlyyPrescriptionVO.setHospitalName("厦门市中山医院");
                                    wlyyPrescriptionVOMap.put(realOrder, wlyyPrescriptionVO);
                                    //主诊断 毒蛇咬伤&T63.001
                                    String[] icdName = jsonObjectBody.get("icd_name").toString().split("&");
@@ -347,10 +358,18 @@ public class EntranceService {
        wlyyPrescriptionVO.setRealOrder(realOrder);
        wlyyPrescriptionVO.setSerialNo(null != jsonObjectBody.get("REGISTER_SN") ? jsonObjectBody.get("REGISTER_SN").toString() : "");
        wlyyPrescriptionVO.setType(1);
        wlyyPrescriptionVO.setPatientCode(null != jsonObjectBody.get("PAT_NO") ? jsonObjectBody.get("PAT_NO").toString() : "");
        wlyyPrescriptionVO.setPatientName(null != jsonObjectBody.get("UOM") ? jsonObjectBody.get("UOM").toString() : "");
        //TODO 通过映射表获取居民身份证号e
        wlyyPrescriptionVO.setIdcard("");
        String patNo=null != jsonObjectBody.get("PAT_NO") ? jsonObjectBody.get("PAT_NO").toString() : "";
        String patientName=null != jsonObjectBody.get("UOM") ? jsonObjectBody.get("UOM").toString() : "";
        PatientMappingDO patientMappingDo=new PatientMappingDO();
        if(StringUtils.isNotBlank(patNo)){
            patientMappingDo=  patientMappingDao.findByMappingCodeAndSource(patNo,"1");
            patNo=StringUtils.isBlank(patientMappingDo.getPatient())?patNo:patientMappingDo.getPatient();
            patientName=StringUtils.isBlank(patientMappingDo.getPatientName())?patientName:patientMappingDo.getPatientName();
        }
        wlyyPrescriptionVO.setPatientCode(patNo);
        wlyyPrescriptionVO.setPatientName(patientName);
        wlyyPrescriptionVO.setIdcard(patientMappingDo.getIdcard());
        //TODO 社保卡号
        wlyyPrescriptionVO.setSsc("");
        wlyyPrescriptionVO.setHisDoctorCode(null != jsonObjectBody.get("PRESC_DOC") ? jsonObjectBody.get("PRESC_DOC").toString() : "");
@@ -427,13 +446,22 @@ public class EntranceService {
            net.sf.json.JSONObject jsonObjectMgsInfo = (net.sf.json.JSONObject) object;
            if (null != jsonObjectMgsInfo) {
                wlyyOutpatientVO = new WlyyOutpatientVO();
                wlyyOutpatientVO.setHospital("350211A1002");
                wlyyOutpatientVO.setHospitalName("厦门市中山医院");
                wlyyOutpatientVO.setAdmNo(null == jsonObjectMgsInfo.get("ADM_NO") ? "" : jsonObjectMgsInfo.get("ADM_NO") + "");
                wlyyOutpatientVO.setRegisterNo(null == jsonObjectMgsInfo.get("REGISTER_SN") ? "" : jsonObjectMgsInfo.get("REGISTER_SN") + "");
                wlyyOutpatientVO.setDept(null == jsonObjectMgsInfo.get("ADM_SPEC") ? "" : jsonObjectMgsInfo.get("ADM_SPEC") + "");
                wlyyOutpatientVO.setDeptName(null == jsonObjectMgsInfo.get("ADM_SPEC_NAME") ? "" : jsonObjectMgsInfo.get("ADM_SPEC_NAME") + "");
                wlyyOutpatientVO.setPatient(null == jsonObjectMgsInfo.get("PAT_NO") ? "" : jsonObjectMgsInfo.get("PAT_NO") + "");
                wlyyOutpatientVO.setPatientName(null == jsonObjectMgsInfo.get("PAT_NAME") ? "" : jsonObjectMgsInfo.get("PAT_NAME") + "");
                String patNo=null != jsonObjectMgsInfo.get("PAT_NO") ? jsonObjectMgsInfo.get("PAT_NO").toString() : "";
                String patientName=null != jsonObjectMgsInfo.get("PAT_NAME") ? jsonObjectMgsInfo.get("PAT_NAME").toString() : "";
                PatientMappingDO patientMappingDo=new PatientMappingDO();
                if(StringUtils.isNotBlank(patNo)){
                    patientMappingDo=  patientMappingDao.findByMappingCodeAndSource(patNo,"1");
                    patNo=StringUtils.isBlank(patientMappingDo.getPatient())?patNo:patientMappingDo.getPatient();
                    patientName=StringUtils.isBlank(patientMappingDo.getPatientName())?patientName:patientMappingDo.getPatientName();
                }
                wlyyOutpatientVO.setPatient(patNo);
                wlyyOutpatientVO.setPatientName(patientName);
                wlyyOutpatientVO.setDoctor(null == jsonObjectMgsInfo.get("CON_DOC") ? "" : jsonObjectMgsInfo.get("CON_DOC") + "");
                wlyyOutpatientVO.setDoctorName(null == jsonObjectMgsInfo.get("CON_DOC_NAME") ? "" : jsonObjectMgsInfo.get("CON_DOC_NAME") + "");
@@ -697,8 +725,8 @@ public class EntranceService {
     * @return
     * @throws Exception
     */
    @org.springframework.transaction.annotation.Transactional(rollbackFor = Exception.class)
    public List<HospitalDeptMappingDO> MS02001(boolean demoFlag) throws Exception {
//    @org.springframework.transaction.annotation.Transactional(rollbackFor = Exception.class)
    public List<DictHospitalDeptDO> MS02001(boolean demoFlag) throws Exception {
        String fid=MS02001;
        String resp="";
        if (demoFlag) {
@@ -716,14 +744,36 @@ public class EntranceService {
            resp = MqSdkUtil.xml2jsonArrayRootRow(resp);
        }
        JSONArray jsonArray= ConvertUtil.convertListEnvelopInBody(resp);
        List<HospitalDeptMappingDO> hospitalDeptMappingDOS=new ArrayList<>();
        HospitalDeptMappingDO hdmDo;
        List<DictHospitalDeptDO> hospitalDeptMappingDOS=new ArrayList<>();
        DictHospitalDeptDO hdmDo;
        String orgCode="350211A1002";
        Map<String,String> orgCodeMap=new HashMap<>();
        //6总部7金榜8夏禾
        orgCodeMap.put("6",orgCode);
        orgCodeMap.put("7","");
        orgCodeMap.put("8","");
        //删除旧数据
        hospitalDeptMappingDao.deleteBySource("1");
        List<String> strings=new ArrayList<>(orgCodeMap.values()) ;
        for(String s:strings) {
            if(StringUtils.isNotBlank(s)){
                dictHospitalDeptDao.deleteByOrgCode(s);
            }
        }
        for(Object object:jsonArray){
            hdmDo=new HospitalDeptMappingDO();
            hdmDo=new DictHospitalDeptDO();
            net.sf.json.JSONObject jsonObjectBody=(net.sf.json.JSONObject)object;
            hdmDo.setSerialNo(null==jsonObjectBody.get("Serial_No")?"":jsonObjectBody.get("Serial_No").toString());
            String deptTypeCode=null==jsonObjectBody.get("Dept_Type_Code")?"":jsonObjectBody.get("Dept_Type_Code").toString();
            if(StringUtils.isNotBlank(orgCodeMap.get(deptTypeCode))){
                hdmDo.setOrgCode(orgCode);
                hdmDo.setCode(null==jsonObjectBody.get("Dept_Code")?"":jsonObjectBody.get("Dept_Code").toString());
                hdmDo.setName(null==jsonObjectBody.get("Dept_Name")?"":jsonObjectBody.get("Dept_Name").toString());
                hdmDo.setDeptTypeCode(deptTypeCode);
                hdmDo.setCreateTime(new Date());
//                DictHospitalDeptDao.save(hdmDo);
                hospitalDeptMappingDOS.add(hdmDo);
            }
       /*     hdmDo.setSerialNo(null==jsonObjectBody.get("Serial_No")?"":jsonObjectBody.get("Serial_No").toString());
            hdmDo.setDeptCode(null==jsonObjectBody.get("Dept_Code")?"":jsonObjectBody.get("Dept_Code").toString());
            hdmDo.setDeptName(null==jsonObjectBody.get("Dept_Name")?"":jsonObjectBody.get("Dept_Name").toString());
            hdmDo.setDeptAlias(null==jsonObjectBody.get("Dept_Alias")?"":jsonObjectBody.get("Dept_Alias").toString());
@@ -736,7 +786,6 @@ public class EntranceService {
            hdmDo.setInputCode(null==jsonObjectBody.get("Input_Code")?"":jsonObjectBody.get("Input_Code").toString());
            hdmDo.setPinyinCode(null==jsonObjectBody.get("Pinyin_Code")?"":jsonObjectBody.get("Pinyin_Code").toString());
            hdmDo.setWubiCode(null==jsonObjectBody.get("Wubi_Code")?"":jsonObjectBody.get("Wubi_Code").toString());
            hdmDo.setDeptTypeCode(null==jsonObjectBody.get("Dept_Type_Code")?"":jsonObjectBody.get("Dept_Type_Code").toString());
            hdmDo.setLocation(null==jsonObjectBody.get("Location")?"":jsonObjectBody.get("Location").toString());
            hdmDo.setDisplaySequence(null==jsonObjectBody.get("Display_Sequence")?"":jsonObjectBody.get("Display_Sequence").toString());
            hdmDo.setOpenBedNum(null==jsonObjectBody.get("Open_Bed_Num")?"":jsonObjectBody.get("Open_Bed_Num").toString());
@@ -749,11 +798,11 @@ public class EntranceService {
            hdmDo.setDeptZipCode(null==jsonObjectBody.get("Dept_Zip_Code")?"":jsonObjectBody.get("Dept_Zip_Code").toString());
            hdmDo.setDeDlid(null==jsonObjectBody.get("De_Dlid")?"":jsonObjectBody.get("De_Dlid").toString());
            hdmDo.setDeLcid(null==jsonObjectBody.get("De_Lcid")?"":jsonObjectBody.get("De_Lcid").toString());
            hdmDo.setSource("1");
            hdmDo.setCreateTime(new Date());
            hospitalDeptMappingDOS.add(hdmDo);
            hdmDo.setSource("1");*/
        }
        hospitalDeptMappingDao.save(hospitalDeptMappingDOS);
        dictHospitalDeptDao.save(hospitalDeptMappingDOS);
        return hospitalDeptMappingDOS;
    }

business/base-service/src/main/java/com/yihu/jw/hospital/prescription/service/entrance/util/SFUtils.java

@@ -203,6 +203,33 @@ public class SFUtils {
    }
    /**
     * 订单确认/取消
     * @param sf_code
     * @param orderid
     * @param mailno
     * @param dealtype
     * @return
     */
    public String SFOrderConfirmXml(String sf_code,String orderid ,String mailno,int dealtype){
        //head 传入接口接入码
        StringBuilder xml = new StringBuilder("<Request service='OrderConfirmService' lang='zh-cn'><Head>"+sf_code+"</Head><Body>");
        xml.append("<OrderConfirm ");
        //订单号
        if(StringUtils.isNotBlank(orderid)){
            xml.append("orderid='"+orderid+"' ");
        }
        //派送订单号，必填
        xml.append("mailno='" + mailno + "'/> ");
        xml.append("dealtype='" + dealtype + "'/>");
        xml.append("/></OrderConfirm>");
        xml.append("</Body></Request>");
        return xml.toString();
    }
    /**
     * 顺丰路由查询
     * @param sfexpress_obj

common/common-entity/src/main/java/com/yihu/jw/entity/base/dict/DictHospitalDeptDO.java

@@ -41,6 +41,12 @@ public class DictHospitalDeptDO extends IntegerIdentityEntity {
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
	private Date createTime;
    /**
     * 6总部7金榜8夏禾
     */
    @Autowired
    private String deptTypeCode;
	@Column(name = "org_code")
    public String getOrgCode() {
@@ -74,4 +80,11 @@ public class DictHospitalDeptDO extends IntegerIdentityEntity {
        this.createTime = createTime;
    }
    public String getDeptTypeCode() {
        return deptTypeCode;
    }
    public void setDeptTypeCode(String deptTypeCode) {
        this.deptTypeCode = deptTypeCode;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/hospital/prescription/WlyyExpressagePriceDO.java

@@ -1,6 +1,6 @@
package com.yihu.jw.entity.hospital.prescription;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import com.yihu.jw.entity.UuidIdentityEntity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
@@ -14,7 +14,14 @@ import javax.persistence.Table;
*/
@Entity
@Table(name = "wlyy_expressage_price")
public class WlyyExpressagePriceDO extends UuidIdentityEntityWithOperator {
public class WlyyExpressagePriceDO extends UuidIdentityEntity {
    /**
	 * 不同类型快递code
	 */
	private String code;
    /**
	 * 起始地址名称
@@ -46,8 +53,16 @@ public class WlyyExpressagePriceDO extends UuidIdentityEntityWithOperator {
	 */
	private Integer continueWeightPrice;
    @Column(name = "code")
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
	@Column(name = "start_address_name")
    @Column(name = "start_address_name")
    public String getStartAddressName() {
        return startAddressName;
    }

common/common-entity/src/main/java/com/yihu/jw/entity/hospital/prescription/WlyyOutpatientExpressageLogDO.java

@@ -1,6 +1,7 @@
package com.yihu.jw.entity.hospital.prescription;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yihu.jw.entity.UuidIdentityEntity;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Column;
import javax.persistence.Entity;
@@ -16,7 +17,7 @@ import java.util.Date;
*/
@Entity
@Table(name = "wlyy_outpatient_expressage_log")
public class WlyyOutpatientExpressageLogDO extends UuidIdentityEntityWithOperator {
public class WlyyOutpatientExpressageLogDO extends UuidIdentityEntity {
    /**
	 * 

svr/svr-base/src/main/java/com/yihu/jw/base/service/dict/DictHospitalDeptService.java

@@ -95,4 +95,12 @@ public class DictHospitalDeptService extends BaseJpaService<DictHospitalDeptDO,
       return dictHospitalDeptDao.findByOrgCode(orgCode);
    }
    /**
     * 批量保存
     * @return
     */
    public void saveBatch(List<DictHospitalDeptDO> dictHospitalDeptDOS)throws Exception{
        dictHospitalDeptDao.save(dictHospitalDeptDOS);
    }
}

svr/svr-internet-hospital-entrance/src/main/java/com/yihu/jw/entrance/config/JpaConfig.java

@@ -8,7 +8,7 @@ import org.springframework.orm.jpa.JpaTransactionManager;
public class JpaConfig {
    @Bean
    public JpaTransactionManager jpaTransactionManager(){
    public JpaTransactionManager transactionManager(){
        return new JpaTransactionManager();
    }
}

svr/svr-internet-hospital-entrance/src/main/java/com/yihu/jw/entrance/controller/MqSdkController.java

@@ -1,9 +1,9 @@
package com.yihu.jw.entrance.controller;
import com.yihu.jw.entity.base.dict.DictHospitalDeptDO;
import com.yihu.jw.entity.hospital.mapping.HospitalDeptMappingDO;
import com.yihu.jw.hospital.prescription.service.entrance.EntranceService;
import com.yihu.jw.hospital.prescription.service.entrance.util.ConvertUtil;
import com.yihu.jw.restmodel.hospital.prescription.WlyyOutpatientVO;
import com.yihu.jw.restmodel.hospital.prescription.WlyyPrescriptionVO;
import com.yihu.jw.restmodel.web.ListEnvelop;
@@ -12,7 +12,6 @@ import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
@@ -20,7 +19,6 @@ import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
@@ -176,7 +174,7 @@ public class MqSdkController extends EnvelopRestEndpoint {
    @GetMapping(value = "/MS02001")
    @ApiOperation(value = "科室字典  ")
    public ListEnvelop MS02001() throws Exception {
        List<HospitalDeptMappingDO> obj = entranceService.MS02001(demoFlag);
        List<DictHospitalDeptDO> obj = entranceService.MS02001(demoFlag);
        return success(obj);
    }

svr/svr-internet-hospital-entrance/src/main/java/com/yihu/jw/entrance/controller/expressage/ExpressageEndpoint.java

@@ -1,79 +1,209 @@
//package com.yihu.jw.entrance.controller.expressage;
//
//import com.yihu.jw.entity.hospital.prescription.WlyyPrescriptionDO;
//import com.yihu.jw.entity.hospital.prescription.WlyyPrescriptionExpressageDO;
//import com.yihu.jw.hospital.prescription.dao.PrescriptionDao;
//import com.yihu.jw.hospital.prescription.service.PrescriptionExpressageService;
//import com.yihu.jw.hospital.prescription.service.PrescriptionService;
//import com.yihu.jw.restmodel.web.Envelop;
//import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
//import com.yihu.jw.rm.hospital.BaseHospitalRequestMapping;
//import io.swagger.annotations.Api;
//import io.swagger.annotations.ApiOperation;
//import io.swagger.annotations.ApiParam;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.util.CollectionUtils;
//import org.springframework.web.bind.annotation.RequestMapping;
//import org.springframework.web.bind.annotation.RequestMethod;
//import org.springframework.web.bind.annotation.RequestParam;
//import org.springframework.web.bind.annotation.RestController;
//
//import java.net.URLDecoder;
//import java.util.List;
//
//@RestController
//@RequestMapping(value = BaseHospitalRequestMapping.Expressage.PREFIX)
//@Api(value = "门诊处方快递物流管理器", description = "门诊处方快递物流管理器", tags = {"wlyy基础服务 - 门诊处方快递物流管理服务接口"})
//public class ExpressageEndpoint extends EnvelopRestEndpoint {
//    private static Logger logger = LoggerFactory.getLogger(ExpressageEndpoint.class);
//
//    @Autowired
//    private PrescriptionExpressageService sfexpressService;
//
//    @Autowired
//    private PrescriptionExpressageService prescriptionExpressageService;
//
//    private String successxml = "<Response service='RoutePushService'><Head>OK</Head></Response>";
//    private String failedxml = "<Response service='RoutePushService'><Head>ERR</Head><ERROR code='-1'>系统发生数据错误或运行时异常</ERROR></Response>";
//
//    @RequestMapping(value="/routepushservice",method = RequestMethod.POST)
//    @ApiOperation("接受顺丰推送过来的路由信息")
//    public Envelop SFRoutePushService (
//            @ApiParam(name="content", value="入参报文") @RequestParam(value = "content",required = true) String content){
//        try {
//            content = URLDecoder.decode(content,"utf-8");
//            logger.info("顺丰路由信息推送，xml="+content);
//            sfexpressService.SFRoutePushService(content);
//            return success(successxml);
//        }catch (Exception e){
//            logger.error("接收顺丰路由信息推送失败，入参xml:"+content);
//            //日志文件中记录异常信息
//            //返回接口异常信息处理结果
//            return failed(failedxml);
//        }
//    }
//
//    @RequestMapping(value="/sfrouteserviceSearch",method = RequestMethod.GET)
//    @ApiOperation("通过门诊编号查询顺丰物流派送记录")
//    public Envelop SFRouteServiceSearch(@ApiParam(name="outpatientId", value="门诊编号") @RequestParam(value = "outpatientId",required = true) String outpatientId){
//        try {
//            List<WlyyPrescriptionExpressageDO> expressageDOList = prescriptionExpressageService.findByField("outpatientId",outpatientId);
//            if(CollectionUtils.isEmpty(expressageDOList)){
//                return failed("当前门诊没有物流信息！");
//            }
//            WlyyPrescriptionExpressageDO sfexpress_obj = expressageDOList.get(0);
//            String result  = sfexpressService.getRoutInfosSearch(sfexpress_obj);
//            return success(result);
//        }catch (Exception e){
//            //日志文件中记录异常信息
//            //返回接口异常信息处理结果
//            return failed( "查询失败,"+e.getMessage());
//        }
//
//    }
//
//
//
//}
package com.yihu.jw.entrance.controller.expressage;
import com.yihu.jw.entity.hospital.prescription.WlyyExpressagePriceDO;
import com.yihu.jw.entity.hospital.prescription.WlyyPrescriptionExpressageDO;
import com.yihu.jw.hospital.prescription.dao.OutpatientDao;
import com.yihu.jw.hospital.prescription.service.PrescriptionExpressageService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.hospital.BaseHospitalRequestMapping;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.net.URLDecoder;
import java.util.List;
@RestController
@RequestMapping(value = BaseHospitalRequestMapping.Expressage.PREFIX)
@Api(value = "门诊处方快递物流管理器", description = "门诊处方快递物流管理器", tags = {"wlyy基础服务 - 门诊处方快递物流管理服务接口"})
public class ExpressageEndpoint extends EnvelopRestEndpoint {
    private static Logger logger = LoggerFactory.getLogger(ExpressageEndpoint.class);
    @Autowired
    private PrescriptionExpressageService sfexpressService;
    @Autowired
    private OutpatientDao outpatientDao;
    private String successxml = "<Response service='RoutePushService'><Head>OK</Head></Response>";
    private String failedxml = "<Response service='RoutePushService'><Head>ERR</Head><ERROR code='-1'>系统发生数据错误或运行时异常</ERROR></Response>";
    @RequestMapping(value="/routepushservice",method = RequestMethod.POST)
    @ApiOperation("接受顺丰推送过来的路由信息")
    public Envelop SFRoutePushService (
            @ApiParam(name="content", value="入参报文") @RequestParam(value = "content",required = true) String content){
        try {
            content = URLDecoder.decode(content,"utf-8");
            logger.info("顺丰路由信息推送，xml="+content);
            sfexpressService.SFRoutePushService(content);
            return success(successxml);
        }catch (Exception e){
            logger.error("接收顺丰路由信息推送失败，入参xml:"+content);
            //日志文件中记录异常信息
            //返回接口异常信息处理结果
            return failed(failedxml);
        }
    }
    @RequestMapping(value="/sfrouteserviceSearch",method = RequestMethod.GET)
    @ApiOperation("通过门诊编号查询顺丰物流派送记录")
    public Envelop SFRouteServiceSearch(@ApiParam(name="outpatientId", value="门诊编号") @RequestParam(value = "outpatientId",required = true) String outpatientId){
        try {
            List<WlyyPrescriptionExpressageDO> expressageDOList = sfexpressService.findByField("outpatientId",outpatientId);
            if(CollectionUtils.isEmpty(expressageDOList)){
                return failed("当前门诊没有物流信息！");
            }
            WlyyPrescriptionExpressageDO sfexpress_obj = expressageDOList.get(0);
            String result  = sfexpressService.getRoutInfosSearch(sfexpress_obj);
            return success(result);
        }catch (Exception e){
            //返回接口异常信息处理结果
            return failed( "查询失败,"+e.getMessage());
        }
    }
    @RequestMapping(value = "/getsfexpressprice", method = RequestMethod.GET)
    @ApiOperation("根据收寄地址获取快递费用")
    public Envelop SFExpressPrice(
//            @ApiParam(name = "j_city", value = "寄方地址(城市)，默认为厦门", defaultValue = "厦门")
//            @RequestParam(value = "j_city", required = false) String j_city,
            @ApiParam(name = "d_province", value = "收方地址(省份)")
            @RequestParam(value = "d_province", required = false) String d_province,
            @ApiParam(name = "d_city", value = "收方地址(城市)")
            @RequestParam(value = "d_city", required = false) String d_city){
        try {
            WlyyExpressagePriceDO expreprice = sfexpressService.getSFExpressPrice(d_province,d_city);
            return success(expreprice);
        }catch (Exception e){
            //返回接口异常信息处理结果
            return failed("获取快递费用,"+e.getMessage());
        }
    }
    @RequestMapping(value = "/sforderfilterservice", method = RequestMethod.GET)
    @ApiOperation("查询派送地址是否属于顺丰的派送范围")
    public Envelop SFOrderFilterService(
            @ApiParam(name = "d_address", value = "派送地址", defaultValue = "福建省厦门市思明区软件园二期望海路55号")
            @RequestParam(value = "d_address", required = true) String d_address){
        try {
            boolean result = sfexpressService.getSFOrderFilterService(d_address);
            if(result){
                return success("地址可派送！");
            }else{
                return failed("地址不可派送！");
            }
        }catch (Exception e){
            return failed("异常："+e.getMessage());
        }
    }
    @RequestMapping(value="/sforderservice",method = RequestMethod.POST)
    @ApiOperation("向顺丰快递下订单")
    public Envelop SFOrderService(
            @ApiParam(name="outpatientId", value="门诊编号") @RequestParam(value = "outpatientId",required = true) String outpatientId){
        try {
            List<WlyyPrescriptionExpressageDO> expressageDOList = sfexpressService.findByField("outpatientId",outpatientId);
            if(CollectionUtils.isEmpty(expressageDOList)){
                return failed("顺丰快递下单失败，未找到该处方的派送地址！");
            }else{
                WlyyPrescriptionExpressageDO sfexpress_obj = expressageDOList.get(0);
                //如果该处方的快递单号已生成，则说明已经下单成功，不需要重复下单，直接返回成功
                if(StringUtils.isNotBlank(sfexpress_obj.getMailno())){
                    return success("顺丰快递下单成功！");
                }else{
                    //如果该处方的快递单号未生成，则继续下单
                    //由于下单前已经判断过是否派送，这里不再重复判断----huangwenjie-2017.08.04
                    //先判断地址是否可派送boolean delivery = sfexpressService.getSFOrderFilterService(sfexpress_obj.getProvinceName()+sfexpress_obj.getCityName()+sfexpress_obj.getTownName()+sfexpress_obj.getAddress());
                    //根据业务订单号判断是否已经下单成功
                    boolean go_on = sfexpressService.sfOrderSearchService(sfexpress_obj);
                    //如果该业务订单号未下单成功过，则重新下单
                    if(go_on){
                        //请求顺丰接口下单，成功下单后，返回快递单号
                        sfexpress_obj = sfexpressService.postSFOrderService(sfexpress_obj);
                        //保存快递单号和增加处方物流记录为配送
                        sfexpressService.updatePrescriptionExpressage(sfexpress_obj);
                    }
                    return success("顺丰快递下单成功！");
                }
            }
        }catch (Exception e){
            //返回接口异常信息处理结果
            return failed(e.getMessage());
        }
    }
    @RequestMapping(value="/sfgetorderinfoservice",method = RequestMethod.GET)
    @ApiOperation("通过门诊编号查询顺丰快递单信息（不包含物流记录）")
    public Envelop SFGetOrderInfo(
            @ApiParam(name="outpatientId", value="门诊编号") @RequestParam(value = "outpatientId",required = true) String outpatientId){
        try {
            List<WlyyPrescriptionExpressageDO> expressageDOList = sfexpressService.findByField("outpaitentId",outpatientId);
            if(CollectionUtils.isEmpty(expressageDOList)){
                return failed( "查询失败,");
            }
            WlyyPrescriptionExpressageDO sfexpress_obj = expressageDOList.get(0);
            return success(sfexpress_obj);
        }catch (Exception e) {
            return failed("查询失败," + e.getMessage());
        }
    }
    @RequestMapping(value="/sfordersearchservice",method = RequestMethod.GET)
    @ApiOperation("通过门诊编号查询顺丰快递是否下单成功")
    public Envelop SFOrderSearchService(
            @ApiParam(name="outpatientId", value="门诊编号") @RequestParam(value = "outpatientId",required = true) String outpatientId){
        List<WlyyPrescriptionExpressageDO> expressageDOList = sfexpressService.findByField("outpaitentId",outpatientId);
        if(CollectionUtils.isEmpty(expressageDOList)){
            return failed( "查询失败,");
        }
        try {
            WlyyPrescriptionExpressageDO sfexpress_obj = expressageDOList.get(0);
            boolean go_on = sfexpressService.sfOrderSearchServiceJustSearch(sfexpress_obj);
            return success(go_on);
        }catch (Exception e) {
            return failed("查询失败," + e.getMessage());
        }
    }
    @RequestMapping(value="/sforderConfirm",method = RequestMethod.GET)
    @ApiOperation("通过快递单号取消快递")
    public Envelop sforderConfirm(
            @ApiParam(name="mailno", value="快递单号") @RequestParam(value = "mailno",required = true) String mailno){
        List<WlyyPrescriptionExpressageDO> expressageDOList = sfexpressService.findByField("mailno",mailno);
        if(CollectionUtils.isEmpty(expressageDOList)){
            return failed( "当前快递单号的门诊不存在,");
        }
        try {
            WlyyPrescriptionExpressageDO sfexpress_obj = expressageDOList.get(0);
            String result = sfexpressService.postOrderConfirmService(sfexpress_obj);
            return success(result);
        }catch (Exception e) {
            return failed("异常," + e.getMessage());
        }
    }
}

svr/svr-internet-hospital-entrance/src/main/resources/application.yml

@@ -1,6 +1,7 @@
#通用的配置不用区分环境变量
server:
  port: ${server.svr-internet-hospital-entrance-port}
#  port: ${server.svr-internet-hospital-entrance-port}
  port: 10023
spring:
  datasource:
@@ -39,10 +40,9 @@ configDefault: # 默认配置
  saasId: xmjkzl_saasId
express:
  sf_url: http://218.17.248.244:11080/bsp-oisp/sfexpressService
  #  sf_url: https://bsp-ois.sit.sf-express.com:9443/bsp-ois/sfexpressServic
  sf_code: SDDF
  sf_check_word: ttzlgGyOQu4L
  sf_url: http://bsp-oisp.sf-express.com/bsp-oisp/sfexpressService
  sf_code: JKZL
  sf_check_word: QkeIfIvQdheqIv2cVSgAUnBU29lfNbVk
---
spring: