医保凭证开发

server/svr-authentication/pom.xml

@@ -197,6 +197,11 @@
            <artifactId>javax.wsdl</artifactId>
            <version>1.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
        <!--oracle驱动-->
        <dependency>
            <groupId>com.oracle</groupId>

server/svr-authentication/src/main/java/com/yihu/jw/security/dao/YlzHttpLogDao.java

@@ -0,0 +1,14 @@
package com.yihu.jw.security.dao;
import com.yihu.jw.entity.hospital.httplog.YlzHttpLogDO;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * Created by Trick on 2019/6/25.
 */
public interface YlzHttpLogDao extends JpaRepository<YlzHttpLogDO, String>, JpaSpecificationExecutor<YlzHttpLogDO> {
}

server/svr-authentication/src/main/java/com/yihu/jw/security/dao/YlzMedicalUserInfoDao.java

@@ -0,0 +1,16 @@
package com.yihu.jw.security.dao;
import com.yihu.jw.entity.hospital.healthCare.YlzMedicalUserInfoDO;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by wangzhinan 20211003
 */
public interface YlzMedicalUserInfoDao extends PagingAndSortingRepository<YlzMedicalUserInfoDO, String>, JpaSpecificationExecutor<YlzMedicalUserInfoDO> {
    @Query("from YlzMedicalUserInfoDO a where a.no = ?1 ")
    YlzMedicalUserInfoDO findByNo(String no);
}

server/svr-authentication/src/main/java/com/yihu/jw/security/dao/patient/WlyyHospitalSysDictDao.java

@@ -3,6 +3,7 @@ package com.yihu.jw.security.dao.patient;
import com.yihu.jw.entity.hospital.consult.WlyyHospitalSysDictDO;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import java.util.List;
@@ -10,5 +11,6 @@ import java.util.List;
public interface WlyyHospitalSysDictDao  extends JpaRepository<WlyyHospitalSysDictDO, String>, JpaSpecificationExecutor<WlyyHospitalSysDictDO> {
    WlyyHospitalSysDictDO findDictById(String id);
    List<WlyyHospitalSysDictDO> findByDictName(String dictName);
    @Query("from WlyyHospitalSysDictDO where dictName = ?1  and  dictCode=?2 ")
    WlyyHospitalSysDictDO findOneByDictNameAndDictCode(String dictName,String dictCode);
}

server/svr-authentication/src/main/java/com/yihu/jw/security/oauth2/provider/endpoint/WlyyLoginEndpoint.java

@@ -28,6 +28,7 @@ import com.yihu.jw.security.oauth2.core.redis.WlyyRedisVerifyCodeService;
import com.yihu.jw.security.oauth2.provider.WlyyTokenGranter;
import com.yihu.jw.security.oauth2.provider.error.WlyyOAuth2ExceptionTranslator;
import com.yihu.jw.security.service.*;
import com.yihu.jw.security.service.healthCare.HealthCareNewService;
import com.yihu.jw.security.utils.AES;
import com.yihu.jw.security.utils.DateUtil;
import com.yihu.jw.security.utils.IdCardUtil;
@@ -187,6 +188,9 @@ public class WlyyLoginEndpoint extends AbstractEndpoint {
    @Autowired
    private DsyyService dsyyService;
    @Autowired
    private HealthCareNewService healthCareNewService;
    @PostConstruct
    private void init() {
        super.setTokenGranter(tokenGranter);
@@ -3415,4 +3419,140 @@ public class WlyyLoginEndpoint extends AbstractEndpoint {
        return getResponse(wlyyUserSimple);
    }
    /**
     * 更新医保授权用户信息
     *
     * @return
     */
    @RequestMapping(value = "/oauth/updateUserInfo", method = RequestMethod.POST)
    public ObjEnvelop updateUserInfo(String no,String code) {
        try {
            return ObjEnvelop.getSuccess("success", healthCareNewService.updateUserInfo(no,code));
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("getOauthQRCodeImg error");
        }
    }
    /**
     * 医保凭证
     *
     * @return
     */
    @RequestMapping(value = "/oauth/getYbOauthQRCodeImg", method = RequestMethod.GET)
    public ObjEnvelop getYbOauthQRCodeImg() {
        try {
            Map<String,Object> map = healthCareNewService.getYbImage();
            return ObjEnvelop.getSuccess("success", map);
        } catch (Exception e) {
            e.printStackTrace();
            return ObjEnvelop.getError("getOauthQRCodeImg error");
        }
    }
    /**
     * 居民医保二维码登录
     */
    @RequestMapping(value = "/oauth/checkYbQRCodeLogin", method = RequestMethod.POST)
    public ObjEnvelop checkYbQRCodeLogin(String no,String client_id,String login_type) throws Exception {
        if (StringUtils.isEmpty(client_id)) {
            throw new InvalidRequestException("client_id is null");
        }
        Map<String, Object> map = healthCareNewService.checkOauthQRCode(no);
        String sCode = (String) map.get("sCode");
        if (!"succ".equals(sCode)) {
            return ObjEnvelop.getSuccess("error", map);
        }
        BasePatientDO patient = (BasePatientDO) map.get("patient");
        ClientDetails authenticatedClient = clientDetailsService.loadClientByClientId(client_id);
        Map<String, String> parameters = new HashedMap();
        parameters.put("username", patient.getIdcard());
        parameters.put("grant_type", "ihealthCode");
        TokenRequest tokenRequest = oAuth2RequestFactory.createTokenRequest(parameters, authenticatedClient);
        if (authenticatedClient != null) {
            oAuth2RequestValidator.validateScope(tokenRequest, authenticatedClient);
        }
        OAuth2AccessToken token = getTokenGranter().grant(tokenRequest.getGrantType(), tokenRequest);
        if (token == null) {
            throw new UnsupportedGrantTypeException("Unsupported grant type: " + tokenRequest.getGrantType());
        }
        WlyyUserSimple wlyyUserSimple = userDetailsService.authSuccess(parameters.get("username"));
        wlyyUserSimple.setAccessToken(token.getValue());
        wlyyUserSimple.setTokenType(token.getTokenType());
        wlyyUserSimple.setExpiresIn(token.getExpiresIn());
        wlyyUserSimple.setRefreshToken(token.getRefreshToken().getValue());
        wlyyUserSimple.setUser(parameters.get("username"));
        String loginType = parameters.get("login_type");
        BaseLoginLogDO baseLoginLogDO = new BaseLoginLogDO();
        userDetailsService.setRolePhth(loginType, token, wlyyUserSimple.getId(), redisTemplate);
        baseLoginLogDO.setUserId(wlyyUserSimple.getId());
        baseLoginLogDO.setCreateTime(new Date());
        String userAgent = JSONObject.toJSONString(wlyyUserSimple);
        baseLoginLogDO.setUserAgent(userAgent);
        baseLoginLogDO.setLoginType(loginType);
        baseLoginLogService.save(baseLoginLogDO);
        map.put("WlyyUserSimple", wlyyUserSimple);
        map.remove("patient");
        return ObjEnvelop.getSuccess("success", map);
    }
    /**
     * 居民医保微信端授权登录
     */
    @RequestMapping(value = "/oauth/ybPatientCodeLogin", method = RequestMethod.POST)
    public ObjEnvelop ybPatientCodeLogin(String no,String code,String client_id, String login_type) throws Exception {
        if (StringUtils.isEmpty(client_id)) {
            throw new InvalidRequestException("client_id is null");
        }
        BasePatientDO patient =  healthCareNewService.updateUserInfo(no,code);
        Map<String, Object> map = new HashMap<>();
        ClientDetails authenticatedClient = clientDetailsService.loadClientByClientId(client_id);
        Map<String, String> parameters = new HashedMap();
        parameters.put("username", patient.getIdcard());
        parameters.put("grant_type", "ihealthCode");
        TokenRequest tokenRequest = oAuth2RequestFactory.createTokenRequest(parameters, authenticatedClient);
        if (authenticatedClient != null) {
            oAuth2RequestValidator.validateScope(tokenRequest, authenticatedClient);
        }
        OAuth2AccessToken token = getTokenGranter().grant(tokenRequest.getGrantType(), tokenRequest);
        if (token == null) {
            throw new UnsupportedGrantTypeException("Unsupported grant type: " + tokenRequest.getGrantType());
        }
        WlyyUserSimple wlyyUserSimple = userDetailsService.authSuccess(parameters.get("username"));
        wlyyUserSimple.setAccessToken(token.getValue());
        wlyyUserSimple.setTokenType(token.getTokenType());
        wlyyUserSimple.setExpiresIn(token.getExpiresIn());
        wlyyUserSimple.setRefreshToken(token.getRefreshToken().getValue());
        wlyyUserSimple.setUser(parameters.get("username"));
        String loginType = parameters.get("login_type");
        BaseLoginLogDO baseLoginLogDO = new BaseLoginLogDO();
        userDetailsService.setRolePhth(loginType, token, wlyyUserSimple.getId(), redisTemplate);
        baseLoginLogDO.setUserId(wlyyUserSimple.getId());
        baseLoginLogDO.setCreateTime(new Date());
        String userAgent = JSONObject.toJSONString(wlyyUserSimple);
        baseLoginLogDO.setUserAgent(userAgent);
        baseLoginLogDO.setLoginType(loginType);
        baseLoginLogService.save(baseLoginLogDO);
        map.put("patient",patient);
        map.put("WlyyUserSimple",wlyyUserSimple);
        return ObjEnvelop.getSuccess("success", map);
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/HealthCareNewService.java

@@ -0,0 +1,412 @@
package com.yihu.jw.security.service.healthCare;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.entity.hospital.consult.WlyyHospitalSysDictDO;
import com.yihu.jw.entity.hospital.family.WlyyPatientFamilyMemberDO;
import com.yihu.jw.entity.hospital.healthCare.*;
import com.yihu.jw.entity.hospital.httplog.YlzHttpLogDO;
import com.yihu.jw.security.dao.YlzHttpLogDao;
import com.yihu.jw.security.dao.YlzMedicalUserInfoDao;
import com.yihu.jw.security.dao.patient.BasePatientDao;
import com.yihu.jw.security.dao.patient.WlyyHospitalSysDictDao;
import com.yihu.jw.security.dao.patient.WlyyPatientFamilyMemberDao;
import com.yihu.jw.security.service.healthCare.utils.AES;
import com.yihu.jw.security.service.healthCare.utils.SafeUtil;
import com.yihu.jw.security.utils.ByteToInputStream;
import com.yihu.jw.util.common.QrcodeUtil;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.jw.util.encrypt.MD5;
import com.yihu.jw.util.http.HttpClientUtil;
import com.yihu.jw.util.idcard.IdCardUtil;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import javax.transaction.Transactional;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
 * 新版医保对接
 * Created by wangzhinan 20211002
 */
@Service
@Transactional
public class HealthCareNewService {
    private Logger logger = LoggerFactory.getLogger(HealthCareNewService.class);
    @Autowired
    private WlyyHospitalSysDictDao hospitalSysDictDao;
    @Autowired
    private HttpClientUtil httpClientUtil;
    @Autowired
    private YlzHttpLogDao ylzHttpLogDao;
    @Autowired
    private YlzMedicalUserInfoDao ylzMedicalUserInfoDao;
    @Autowired
    private BasePatientDao basePatientDao;
    @Autowired
    private WlyyPatientFamilyMemberDao familyMemberDao;
    private String ylzConfigUrl;
    private String ylzConfigAppid;
    private String ylzConfigAppSecret;
    private String ylzConfigEncryptKey;
    private String ylzConfigSignKey;
    private String ylzConfigOrgCode;
    public static String entranceHealthCareUrl = "http://127.0.0.1:10023/healthCare/";
    public void initConfig() throws Exception{
        logger.info("初始话参数！");
        List<WlyyHospitalSysDictDO> hospitalSysDictDOS = hospitalSysDictDao.findByDictName("ylzConfig");
        if (hospitalSysDictDOS==null||hospitalSysDictDOS.size()==0){
            throw new Exception("尚未添加配置参数");
        }else {
            for (WlyyHospitalSysDictDO hospitalSysDictDO:hospitalSysDictDOS){
                if (hospitalSysDictDO.getId().equalsIgnoreCase("ylzConfigUrl")){
                    ylzConfigUrl = hospitalSysDictDO.getDictValue();
                }
                if (hospitalSysDictDO.getId().equalsIgnoreCase("ylzConfigAppid")){
                    ylzConfigAppid = hospitalSysDictDO.getDictValue();
                }
                if (hospitalSysDictDO.getId().equalsIgnoreCase("ylzConfigAppSecret")){
                    ylzConfigAppSecret = hospitalSysDictDO.getDictValue();
                }
                if (hospitalSysDictDO.getId().equalsIgnoreCase("ylzConfigEncryptKey")){
                    ylzConfigEncryptKey = hospitalSysDictDO.getDictValue();
                }
                if (hospitalSysDictDO.getId().equalsIgnoreCase("ylzConfigSignKey")){
                    ylzConfigSignKey = hospitalSysDictDO.getDictValue();
                }
                if (hospitalSysDictDO.getId().equalsIgnoreCase("ylzConfigOrgCode")){
                    ylzConfigOrgCode = hospitalSysDictDO.getDictValue();
                }
            }
        }
    }
    public String getYlzToken() throws Exception {
        YlzHttpLogDO ylzHttpLogDO = new YlzHttpLogDO();
        String token = null;
        initConfig();
        String funid = "N00.00.00.01";
        JSONObject data = new JSONObject();
        data.put("appid",ylzConfigAppid);
        data.put("appsecret",ylzConfigAppSecret);
        data.put("grant_type","client_credentials");
        JSONObject object = new JSONObject();
        object.put("sign_type","md5");
        object.put("appid",ylzConfigAppid);
       /* String stringSignTemp ="appid="+ylzConfigAppid+"&appsecret="+ylzConfigAppSecret+"&data="+data+"&funid="+funid+"&sign_type=md5&key="+ylzConfigSignKey;
        String sign = MD5.md5(stringSignTemp).toUpperCase();*/
        object.put("data",data);
        object.put("funid",funid);
        String signResult = SafeUtil.sign(object.toJSONString(),ylzConfigSignKey);
        String obj = SafeUtil.encrypt(signResult,ylzConfigEncryptKey);
        JSONObject jsonObject = JSONObject.parseObject(obj);
        logger.info("请求前funid=="+funid+"data="+data);
        String response = httpClientUtil.postBody(ylzConfigUrl,jsonObject);
        ylzHttpLogDO.setResponseEncrpty(response);
        logger.info("请求后response=="+response);
        if (response!=null&&response!=""){
            JSONObject result = JSONObject.parseObject(response);
            if (result.getString("flag").equalsIgnoreCase("1")){
                String dataResult = result.getString("encrypt_data");
                result.remove("encrypt_data");
                if (dataResult!=null&&dataResult!=""){
                    String decryptResult = AES.aesDecrypt(dataResult,ylzConfigEncryptKey);
                    JSONObject dataObject = JSONObject.parseObject(decryptResult);
                    result.put("encrypt_data",dataObject);
                    response = result.toString();
                    token = dataObject.getString("access_token");
                }
            }
        }
        ylzHttpLogDO.setCode(funid);
        ylzHttpLogDO.setName("获取AccessToken");
        ylzHttpLogDO.setRequest(data.toJSONString());
        ylzHttpLogDO.setRequestEncrpty(obj);
        ylzHttpLogDO.setResponse(response);
        ylzHttpLogDO.setCreateTime(new Date());
        ylzHttpLogDao.save(ylzHttpLogDO);
        return token;
    }
    /**
     * 医保统一调用接口
     * @param data
     * @param funid
     * @param name
     * @return
     * @throws Exception
     */
    @org.springframework.transaction.annotation.Transactional(propagation= Propagation.NOT_SUPPORTED)
    public String requestYlz(JSONObject data,String funid,String name) throws Exception {
        String obj="";
        try {
            YlzHttpLogDO ylzHttpLogDO = new YlzHttpLogDO();
            initConfig();
            WlyyHospitalSysDictDO systemDict =  hospitalSysDictDao.findOneByDictNameAndDictCode("ylzConfig","testFlag");
            if (null!=systemDict&&"1".equalsIgnoreCase(systemDict.getDictValue())){//测试环境
                //N00.00.00.01接口外其他的接口在服务号前加个T就是测试
                funid ="N00.00.00.01".equalsIgnoreCase(funid)?funid:"T"+funid;
                System.out.println("funid="+funid);
            }
            JSONObject object = new JSONObject();
            object.put("sign_type","md5");
            object.put("appid",ylzConfigAppid);
            String accessToken = getYlzToken();
            if (accessToken==null){
                throw new Exception("token无效");
            }
            object.put("access_token",accessToken);
            object.put("funid",funid);
            data.put("appid",ylzConfigAppid);
            data.put("org_code",ylzConfigOrgCode);
            object.put("data",data);
            String signResult = SafeUtil.sign(object.toJSONString(),ylzConfigSignKey);
            obj = SafeUtil.encrypt(signResult,ylzConfigEncryptKey);
            JSONObject jsonObject = JSONObject.parseObject(obj);
          /*  obj = YibaoJiaMi.encryptData(object,ylzConfigSignKey,ylzConfigEncryptKey);
            JSONObject jsonObject = JSONObject.parseObject(obj);*/
            logger.info("请求前funid=="+funid+"data="+data.toJSONString());
            String response = httpClientUtil.postBody(ylzConfigUrl,jsonObject);
            ylzHttpLogDO.setResponseEncrpty(response);
            if (response!=null&&response!=""){
                JSONObject result = JSONObject.parseObject(response);
                if (result.getString("flag").equalsIgnoreCase("1")){
                    String dataResult = result.getString("encrypt_data");
                    result.remove("encrypt_data");
                    if (dataResult!=null&&dataResult!=""){
                        String decryptResult = AES.aesDecrypt(dataResult,ylzConfigEncryptKey);
                        JSONObject dataObject = JSONObject.parseObject(decryptResult);
                 /*       String decryptResult = YibaoJiaMi.decrypt(dataResult,ylzConfigEncryptKey);
                        JSONObject dataObject = JSONObject.parseObject(decryptResult);*/
                        result.put("encrypt_data",dataObject);
                        response = result.toJSONString();
                    }
                }
            }
            ylzHttpLogDO.setCode(funid);
            ylzHttpLogDO.setName(name);
            ylzHttpLogDO.setRequest(data.toJSONString());
            ylzHttpLogDO.setRequestEncrpty(obj);
            ylzHttpLogDO.setResponse(response);
            ylzHttpLogDO.setCreateTime(new Date());
            ylzHttpLogDao.save(ylzHttpLogDO);
            return response;
        }catch (Exception e){
            e.printStackTrace();
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);
            e.printStackTrace(pw);
            String error = sw.toString();
            YlzHttpLogDO ylzHttpLogDO = new YlzHttpLogDO();
            ylzHttpLogDO.setCode(funid);
            ylzHttpLogDO.setName(name);
            ylzHttpLogDO.setRequest(data.toJSONString());
            ylzHttpLogDO.setRequestEncrpty(obj);
            ylzHttpLogDO.setResponse(error);
            ylzHttpLogDO.setCreateTime(new Date());
            ylzHttpLogDao.save(ylzHttpLogDO);
            return null;
        }
    }
    public Boolean isHospitalFlag(){
        WlyyHospitalSysDictDO hospitalSysDictDO = hospitalSysDictDao.findById("medicalFlag").get();
        if (hospitalSysDictDO!=null){
            if (hospitalSysDictDO.getDictValue().equalsIgnoreCase("1")){
                return true;
            }else {
                return false;
            }
        }else {
            return false;
        }
    }
    /**
     * 获取用户信息（N03.00.05.16）
     *
     * 返回值
     *
     * @param code 用户信息临时串
     * @return
     * @throws Exception
     */
    public String getUserInfo(String code) throws Exception{
        String funid = "N03.00.05.16";
        JSONObject data = new JSONObject();
        data.put("code",code);//用户信息临时串
        logger.info("data"+data.toJSONString());
        String result = requestYlz(data,funid,"获取用户信息");
        if (result==null){
            throw new Exception("获取用户信息失败");
        }
        return result;
    }
    /**
     * 获取医保二维码
     *
     * @return
     * @throws UnsupportedEncodingException
     */
    public Map<String,Object> getYbImage() throws UnsupportedEncodingException {
        String no = UUID.randomUUID().toString().substring(0,30);
        YlzMedicalUserInfoDO ylzMedicalUserInfoDO = new YlzMedicalUserInfoDO();
        ylzMedicalUserInfoDO.setNo(no);
        String redirectUrl = "https://hlwyy.xmhcyy.com/hcyy/ims-wx/#/login?no="+no;
        String url = "https://service.ylbz.xm.gov.cn/xmyb/web-ixm/app/#/ecAuth?redirectUrl="+ URLEncoder.encode(redirectUrl, "UTF-8");
        ylzMedicalUserInfoDO.setUrl(url);
        ylzMedicalUserInfoDO.setCreateTime(new Date());
        ylzMedicalUserInfoDao.save(ylzMedicalUserInfoDO);
        ByteToInputStream byteToInputStream = new ByteToInputStream();
        InputStream qrcode = QrcodeUtil.createQrcode(url,300,"jpg");
        String QRCodeImg = byteToInputStream.getBase64FromInputStream(qrcode);
        Map<String,Object> map = new HashedMap();
        map.put("QRCodeImg","data:image/png;base64,"+ QRCodeImg);
        map.put("url",url);
        map.put("out_authorize_no",no);
        return map;
    }
    /**
     * 医保授权保存患者信息
     *
     * @param no
     * @param token
     * @return
     * @throws Exception
     */
    public BasePatientDO updateUserInfo(String no,String token) throws Exception {
        BasePatientDO patientDO = new BasePatientDO();
        YlzMedicalUserInfoDO ylzMedicalUserInfoDO = ylzMedicalUserInfoDao.findByNo(no);
        if (ylzMedicalUserInfoDO==null){
            ylzMedicalUserInfoDO = new YlzMedicalUserInfoDO();
            no = UUID.randomUUID().toString().substring(0,30);
            ylzMedicalUserInfoDO.setNo(no);
        }
        String result = getUserInfo(token);
        ylzMedicalUserInfoDO.setToken(token);
        ylzMedicalUserInfoDO.setJson(result);
        ylzMedicalUserInfoDO = ylzMedicalUserInfoDao.save(ylzMedicalUserInfoDO);
        JSONObject object = JSONObject.parseObject(result);
        logger.info(object.toJSONString());
        if (object.getString("flag").equalsIgnoreCase("1")){
            JSONObject data = object.getJSONObject("encrypt_data");
            String idcard = data.getString("idcard");
            String name = data.getString("name");
            String cardno = data.getString("cardno");
            String sex = data.getString("sex");
            ylzMedicalUserInfoDO.setIdcard(idcard);
            ylzMedicalUserInfoDO.setName(name);
            patientDO =  basePatientDao.findByIdcardAndDel(idcard,"1");
            if(StringUtils.isNotBlank(idcard)&&patientDO == null){
                BasePatientDO patient = new BasePatientDO();
                String salt = UUID.randomUUID().toString().substring(0,5);
                String pw = null;
                pw = idcard.substring(idcard.length()-6);
                patient.setIdcard(idcard);
                patient.setName(name);
                patient.setPassword(MD5.md5Hex(pw + "{" + salt + "}"));
                patient.setSalt(salt);
                patient.setDel("1");
                patient.setEnabled(1);
                patient.setLocked(0);
                patient.setSex(Integer.parseInt(IdCardUtil.getSexForIdcard_new(idcard)));
                patient.setCreateTime(new Date());
                patient.setUpdateTime(new Date());
                patient.setBirthday(DateUtil.strToDate(IdCardUtil.getBirthdayForIdcardStr(idcard),"yyyyMMdd"));
                patientDO = basePatientDao.save(patient);
                WlyyPatientFamilyMemberDO basePatientFamilyMemberDO = familyMemberDao.findFamilyMemberByPatientAndRelationCode(patientDO.getId(),"7");
                if (basePatientFamilyMemberDO==null){
                    basePatientFamilyMemberDO = new WlyyPatientFamilyMemberDO();
                    basePatientFamilyMemberDO.setPatient(patientDO.getId());
                    basePatientFamilyMemberDO.setFamilyRelation("7");
                    basePatientFamilyMemberDO.setFamilyRelationName("自己");
                    basePatientFamilyMemberDO.setCardType("身份证");
                    basePatientFamilyMemberDO.setCardNo(patientDO.getIdcard());
                    basePatientFamilyMemberDO.setCreateTime(new Date());
                    basePatientFamilyMemberDO.setUpdateTime(new Date());
                    basePatientFamilyMemberDO.setIsAuthorize(1);
                    basePatientFamilyMemberDO.setIsDel(1);
                    basePatientFamilyMemberDO.setFamilyMember(patientDO.getId());
                    familyMemberDao.save(basePatientFamilyMemberDO);
                }
            }else {
                basePatientDao.save(patientDO);
                WlyyPatientFamilyMemberDO basePatientFamilyMemberDO = familyMemberDao.findFamilyMemberByPatientAndRelationCode(patientDO.getId(), "7");
                if (basePatientFamilyMemberDO == null) {
                    basePatientFamilyMemberDO = new WlyyPatientFamilyMemberDO();
                    basePatientFamilyMemberDO.setPatient(patientDO.getId());
                    basePatientFamilyMemberDO.setFamilyRelation("7");
                    basePatientFamilyMemberDO.setFamilyRelationName("自己");
                    basePatientFamilyMemberDO.setCardType("身份证");
                    basePatientFamilyMemberDO.setCardNo(patientDO.getIdcard());
                    basePatientFamilyMemberDO.setCreateTime(new Date());
                    basePatientFamilyMemberDO.setUpdateTime(new Date());
                    basePatientFamilyMemberDO.setIsAuthorize(1);
                    basePatientFamilyMemberDO.setIsDel(1);
                    basePatientFamilyMemberDO.setFamilyMember(patientDO.getId());
                    familyMemberDao.save(basePatientFamilyMemberDO);
                }
            }
            logger.info("获取用户信息成功");
        }
        return patientDO;
    }
    /**
     * 验证医保凭证是否授权
     * @param authorizeNo
     * @return
     */
    public Map<String,Object> checkOauthQRCode(String authorizeNo) throws Exception {
        YlzMedicalUserInfoDO ylzMedicalUserInfoDO = ylzMedicalUserInfoDao.findByNo(authorizeNo);
        Map<String, Object> rsMap = new HashedMap();
        if (ylzMedicalUserInfoDO != null) {
            if (StringUtils.isNoneBlank(ylzMedicalUserInfoDO.getIdcard())) {
                BasePatientDO patientDO = new BasePatientDO();
                patientDO = basePatientDao.findByIdcardAndDel(ylzMedicalUserInfoDO.getIdcard(),"1");
                logger.info("获取用户信息成功");
                rsMap.put("sCode", "succ");
                rsMap.put("sMes", "success");
                rsMap.put("patient",patientDO);
            }else {
                rsMap.put("sCode", "ing");
                rsMap.put("sMes", "正在授权");
            }
        } else {
            rsMap.put("sCode", "ing");
            rsMap.put("sMes", "正在授权");
        }
        return rsMap;
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/AES.java

@@ -0,0 +1,92 @@
package com.yihu.jw.security.service.healthCare.utils;
import org.springframework.util.StringUtils;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
public class AES {
    public static final String KEY_ALGORITHM = "AES";
    public static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
    public AES() {
    }
    public static String base64Encode(byte[] bytes) {
        return (new BASE64Encoder()).encode(bytes);
    }
    public static byte[] base64Decode(String base64Code) throws Exception {
        return StringUtils.isEmpty(base64Code) ? null : (new BASE64Decoder()).decodeBuffer(base64Code);
    }
    private static Key toKey(byte[] key) {
        SecretKey secretKey = new SecretKeySpec(key, "AES");
        return secretKey;
    }
    public static byte[] decrypt(byte[] data, String password) {
        try {
            Key k = toKey(initKey(password));
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(2, k);
            return cipher.doFinal(data);
        } catch (Throwable var4) {
            var4.printStackTrace();
            return null;
        }
    }
    public static String aesDecrypt(String encryptStr, String decryptKey) throws Exception {
        return aesDecrypt(encryptStr, decryptKey, "utf-8");
    }
    public static String aesDecrypt(String encryptStr, String decryptKey, String encode) throws Exception {
        return StringUtils.isEmpty(encryptStr) ? null : new String(decrypt(base64Decode(encryptStr), decryptKey), encode);
    }
    public static byte[] encrypt(byte[] data, String password) {
        try {
            Key k = toKey(initKey(password));
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(1, k);
            return cipher.doFinal(data);
        } catch (Throwable var4) {
            var4.printStackTrace();
            return null;
        }
    }
    public static String aesEncrypt(String content, String encryptKey) throws Exception {
        return aesEncrypt(content, encryptKey, "utf-8");
    }
    public static String aesEncrypt(String content, String encryptKey, String encode) throws Exception {
        return base64Encode(encrypt(content.getBytes(encode), encryptKey));
    }
    private static byte[] initKey(String password) throws NoSuchAlgorithmException {
        KeyGenerator kg = KeyGenerator.getInstance("AES");
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        random.setSeed(password.getBytes());
        kg.init(128, random);
        SecretKey secretKey = kg.generateKey();
        return secretKey.getEncoded();
    }
    public static void main(String[] args) {
        try {
            System.out.println(base64Encode(aesEncrypt("jjjk", "zephyr").getBytes()));
        } catch (Exception var2) {
            var2.printStackTrace();
        }
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/ConvertUtils.java

@@ -0,0 +1,85 @@
package com.yihu.jw.security.service.healthCare.utils;
import java.math.BigDecimal;
import java.text.DecimalFormat;
/**
 * @Author: lcp
 * @Date: 2020/7/6 21:28
 */
public class ConvertUtils {
    private static String[] trueStrings = new String[]{"1", "true", "y", "on", "yes"};
    public ConvertUtils() {
    }
    public static String toString(Object obj, String defaults) {
        String rlt;
        try {
            rlt = obj.toString();
        } catch (Exception var4) {
            rlt = defaults;
        }
        return rlt;
    }
    public static String toString(Object obj) {
        return toString(obj, (String)null);
    }
    public static Integer toInt(Object obj, Integer defaults) {
        Integer rlt;
        try {
            rlt = Integer.parseInt(obj.toString());
        } catch (Exception var4) {
            rlt = defaults;
        }
        return rlt;
    }
    public static int toInt(Object obj) {
        return toInt(obj, 0);
    }
    public static Long toLong(Object obj, Long defaults) {
        Long rlt;
        try {
            rlt = Long.parseLong(obj.toString());
        } catch (Exception var4) {
            rlt = defaults;
        }
        return rlt;
    }
    public static long toLong(Object obj) {
        return toLong(obj, 0L);
    }
    public static Double toDouble(Object obj, Double defaults) {
        Double rlt;
        try {
            rlt = Double.parseDouble(obj.toString());
        } catch (Exception var4) {
            rlt = defaults;
        }
        return rlt;
    }
    public static double toDouble(Object obj) {
        return toDouble(obj, 0.0D);
    }
    public static BigDecimal formatDecimal(BigDecimal num, String format) {
        DecimalFormat df = new DecimalFormat(format);
        return new BigDecimal(df.format(num));
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/MD5.java

@@ -0,0 +1,44 @@
package com.yihu.jw.security.service.healthCare.utils;
import java.security.MessageDigest;
public class MD5 {
    public MD5() {
    }
    public static String md5(String str) {
        return md5(str, "utf-8");
    }
    public static String md5(String str, String charset) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(str.getBytes(charset));
            byte[] b = md.digest();
            StringBuffer buf = new StringBuffer("");
            for(int offset = 0; offset < b.length; ++offset) {
                int i = b[offset];
                if (i < 0) {
                    i += 256;
                }
                if (i < 16) {
                    buf.append("0");
                }
                buf.append(Integer.toHexString(i));
            }
            str = buf.toString();
        } catch (Exception var7) {
            var7.printStackTrace();
        }
        return str;
    }
    public static void main(String[] args) {
        System.out.println(md5("appid=test&appsecret=test1234&data={\"aid\":\"2\",\"bid\":\"1\"}&funid=ybjjtest&key=testkey").toUpperCase());
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/Pkcs7Encoder.java

@@ -0,0 +1,94 @@
package com.yihu.jw.security.service.healthCare.utils;//
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.Arrays;
import sun.misc.BASE64Encoder;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
public class Pkcs7Encoder {
    static final String KEY_ALGORITHM = "AES";
    static final String algorithmStr = "AES/CBC/PKCS7Padding";
    private static Key key;
    static byte[] iv = new byte[]{48, 49, 48, 50, 48, 51, 48, 52, 48, 53, 48, 54, 48, 55, 48, 56};
    public Pkcs7Encoder() {
    }
    private static Cipher init(byte[] keyBytes) {
        Cipher cipher = null;
        int base = 16;
        if (keyBytes.length % base != 0) {
            int groups = keyBytes.length / base + (keyBytes.length % base != 0 ? 1 : 0);
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte)0);
            System.arraycopy(keyBytes, 0, temp, 0, keyBytes.length);
            keyBytes = temp;
        }
        Security.addProvider(new BouncyCastleProvider());
        key = new SecretKeySpec(keyBytes, "AES");
        try {
            cipher = Cipher.getInstance("AES/CBC/PKCS7Padding", "BC");
        } catch (NoSuchAlgorithmException var5) {
            var5.printStackTrace();
        } catch (NoSuchPaddingException var6) {
            var6.printStackTrace();
        } catch (NoSuchProviderException var7) {
            var7.printStackTrace();
        }
        return cipher;
    }
    public static byte[] encrypt(byte[] content, byte[] keyBytes) {
        byte[] encryptedText = encryptOfDiyIV(content, keyBytes, iv);
        return encryptedText;
    }
    public static byte[] decrypt(byte[] encryptedData, byte[] keyBytes) {
        byte[] encryptedText = decryptOfDiyIV(encryptedData, keyBytes, iv);
        return encryptedText;
    }
    public static byte[] encryptOfDiyIV(byte[] content, byte[] keyBytes, byte[] ivs) {
        byte[] encryptedText = null;
        Cipher cipher = init(keyBytes);
        System.out.println("IV：" + new String(ivs));
        try {
            cipher.init(1, key, new IvParameterSpec(ivs));
            encryptedText = cipher.doFinal(content);
        } catch (Exception var6) {
            var6.printStackTrace();
        }
        return encryptedText;
    }
    public static byte[] decryptOfDiyIV(byte[] encryptedData, byte[] keyBytes, byte[] ivs) {
        byte[] encryptedText = null;
        Cipher cipher = init(keyBytes);
        System.out.println("IV：" + new String(ivs));
        try {
            cipher.init(2, key, new IvParameterSpec(ivs));
            encryptedText = cipher.doFinal(encryptedData);
        } catch (Exception var6) {
            var6.printStackTrace();
        }
        return encryptedText;
    }
    public static String base64Encode(byte[] bytes) {
        return (new BASE64Encoder()).encode(bytes);
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/ReqDto.java

@@ -0,0 +1,19 @@
package com.yihu.jw.security.service.healthCare.utils;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
/**
 *  //明文入参，json key必须包含 sign_type，encrypt_type，funid，data，access_token 这五个。顺序无所谓
 *
 * @Author: lcp
 * @Date: 2020/7/6 21:19
 */
@Data
public class ReqDto {
    private String funid;//接口id
    private JSONObject data;//数据
    private String encrypt_type="AES";//加密类型
    private String access_token;//有效凭证
    private String sign_type="MD5";//签名类型
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/SM4.java

@@ -0,0 +1,269 @@
package com.yihu.jw.security.service.healthCare.utils;
import org.apache.commons.lang3.ArrayUtils;
import java.io.IOException;
import java.util.Arrays;
/**
 * 国密算法SM4实现
 * @create 2019/8/7
 */
public class SM4 {
    public static final String key = "86C63180C2806ED1F47B859DE501215B";
	private static final int ENCRYPT=1;
	private static final int DECRYPT=0;
	public static final int ROUND=32;
	private static final int BLOCK=16;
    private static class SM4Holder{
        private static SM4 instance=new SM4();
    }
    public SM4(){
    }
    public static SM4 getInstance(){
        return SM4Holder.instance;
    }
	
	private byte[] Sbox={
			(byte) 0xd6,(byte) 0x90,(byte) 0xe9,(byte) 0xfe,(byte) 0xcc,(byte) 0xe1,0x3d,(byte) 0xb7,0x16,(byte) 0xb6,0x14,(byte) 0xc2,0x28,(byte) 0xfb,0x2c,0x05,
			0x2b,0x67,(byte) 0x9a,0x76,0x2a,(byte) 0xbe,0x04,(byte) 0xc3,(byte) 0xaa,0x44,0x13,0x26,0x49,(byte) 0x86,0x06,(byte) 0x99,
			(byte) 0x9c,0x42,0x50,(byte) 0xf4,(byte) 0x91,(byte) 0xef,(byte) 0x98,0x7a,0x33,0x54,0x0b,0x43,(byte) 0xed,(byte) 0xcf,(byte) 0xac,0x62,
			(byte) 0xe4,(byte) 0xb3,0x1c,(byte) 0xa9,(byte) 0xc9,0x08,(byte) 0xe8,(byte) 0x95,(byte) 0x80,(byte) 0xdf,(byte) 0x94,(byte) 0xfa,0x75,(byte) 0x8f,0x3f,(byte) 0xa6,
			0x47,0x07,(byte) 0xa7,(byte) 0xfc,(byte) 0xf3,0x73,0x17,(byte) 0xba,(byte) 0x83,0x59,0x3c,0x19,(byte) 0xe6,(byte) 0x85,0x4f,(byte) 0xa8,
			0x68,0x6b,(byte) 0x81,(byte) 0xb2,0x71,0x64,(byte) 0xda,(byte) 0x8b,(byte) 0xf8,(byte) 0xeb,0x0f,0x4b,0x70,0x56,(byte) 0x9d,0x35,
			0x1e,0x24,0x0e,0x5e,0x63,0x58,(byte) 0xd1,(byte) 0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,(byte) 0x87,
			(byte) 0xd4,0x00,0x46,0x57,(byte) 0x9f,(byte) 0xd3,0x27,0x52,0x4c,0x36,0x02,(byte) 0xe7,(byte) 0xa0,(byte) 0xc4,(byte) 0xc8,(byte) 0x9e,
			(byte) 0xea,(byte) 0xbf,(byte) 0x8a,(byte) 0xd2,0x40,(byte) 0xc7,0x38,(byte) 0xb5,(byte) 0xa3,(byte) 0xf7,(byte) 0xf2,(byte) 0xce,(byte) 0xf9,0x61,0x15,(byte) 0xa1,
			(byte) 0xe0,(byte) 0xae,0x5d,(byte) 0xa4,(byte) 0x9b,0x34,0x1a,0x55,(byte) 0xad,(byte) 0x93,0x32,0x30,(byte) 0xf5,(byte) 0x8c,(byte) 0xb1,(byte) 0xe3,
			0x1d,(byte) 0xf6,(byte) 0xe2,0x2e,(byte) 0x82,0x66,(byte) 0xca,0x60,(byte) 0xc0,0x29,0x23,(byte) 0xab,0x0d,0x53,0x4e,0x6f,
			(byte) 0xd5,(byte) 0xdb,0x37,0x45,(byte) 0xde,(byte) 0xfd,(byte) 0x8e,0x2f,0x03,(byte) 0xff,0x6a,0x72,0x6d,0x6c,0x5b,0x51,
			(byte) 0x8d,0x1b,(byte) 0xaf,(byte) 0x92,(byte) 0xbb,(byte) 0xdd,(byte) 0xbc,0x7f,0x11,(byte) 0xd9,0x5c,0x41,0x1f,0x10,0x5a,(byte) 0xd8,
			0x0a,(byte) 0xc1,0x31,(byte) 0x88,(byte) 0xa5,(byte) 0xcd,0x7b,(byte) 0xbd,0x2d,0x74,(byte) 0xd0,0x12,(byte) 0xb8,(byte) 0xe5,(byte) 0xb4,(byte) 0xb0,
			(byte) 0x89,0x69,(byte) 0x97,0x4a,0x0c,(byte) 0x96,0x77,0x7e,0x65,(byte) 0xb9,(byte) 0xf1,0x09,(byte) 0xc5,0x6e,(byte) 0xc6,(byte) 0x84,
			0x18,(byte) 0xf0,0x7d,(byte) 0xec,0x3a,(byte) 0xdc,0x4d,0x20,0x79,(byte) 0xee,0x5f,0x3e,(byte) 0xd7,(byte) 0xcb,0x39,0x48
	};
	
	private int[] CK={
			0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
			0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
			0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,
			0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,
			0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,
			0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,
			0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,
			0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279
	};
	
	private int Rotl(int x,int y)
	{
		return x<<y|x>>>(32-y);
	}
	
	private int ByteSub(int A)
	{
		return (Sbox[A>>>24&0xFF]&0xFF)<<24|(Sbox[A>>>16&0xFF]&0xFF)<<16|(Sbox[A>>>8&0xFF]&0xFF)<<8|(Sbox[A&0xFF]&0xFF);
	}
	private int L1(int B)
	{
		return B^Rotl(B,2)^Rotl(B,10)^Rotl(B,18)^Rotl(B,24);
	}
	
	private int L2(int B)
	{
		return B^Rotl(B,13)^Rotl(B,23);
	}
	
	
	void SMS4Crypt(byte[] Input,byte[] Output,int[] rk)
	{
		int r,mid,x0,x1,x2,x3;
		int[] x= new int[4];
		int[] tmp = new int[4];
		for(int i=0;i<4;i++)
		{
			tmp[0]=Input[0+4*i]&0xff;
			tmp[1]=Input[1+4*i]&0xff;
			tmp[2]=Input[2+4*i]&0xff;
			tmp[3]=Input[3+4*i]&0xff;
			x[i]=tmp[0]<<24|tmp[1]<<16|tmp[2]<<8|tmp[3];
		}
		for(r=0;r<32;r+=4)
		{
			mid=x[1]^x[2]^x[3]^rk[r+0];
			mid=ByteSub(mid);
			x[0]=x[0]^L1(mid);   //x4
			
			mid=x[2]^x[3]^x[0]^rk[r+1];
			mid=ByteSub(mid);
			x[1]=x[1]^L1(mid);	//x5
			
			mid=x[3]^x[0]^x[1]^rk[r+2];
			mid=ByteSub(mid);
			x[2]=x[2]^L1(mid);	//x6
			
			mid=x[0]^x[1]^x[2]^rk[r+3];
			mid=ByteSub(mid);
			x[3]=x[3]^L1(mid);	//x7
		}
		
		//Reverse
		for(int j=0;j<16;j+=4)
		{
			Output[j]  =(byte) (x[3-j/4]>>>24&0xFF);
			Output[j+1]=(byte) (x[3-j/4]>>>16&0xFF);
			Output[j+2]=(byte) (x[3-j/4]>>>8&0xFF);
			Output[j+3]=(byte) (x[3-j/4]&0xFF);
		}
	}
	
	private void SMS4KeyExt(byte[] Key,int[] rk,int CryptFlag)
	{
		int r,mid;
		int[] x= new int[4];
		int[] tmp =new int[4];
		for(int i=0;i<4;i++)
		{
			tmp[0]=Key[0+4*i]&0xFF;
			tmp[1]=Key[1+4*i]&0xff;
			tmp[2]=Key[2+4*i]&0xff;
			tmp[3]=Key[3+4*i]&0xff;
			x[i]=tmp[0]<<24|tmp[1]<<16|tmp[2]<<8|tmp[3];
		}
		x[0]^=0xa3b1bac6;
		x[1]^=0x56aa3350;
		x[2]^=0x677d9197;
		x[3]^=0xb27022dc;
		for(r=0;r<32;r+=4)
		{
			mid=x[1]^x[2]^x[3]^CK[r+0];
			mid=ByteSub(mid);
			rk[r+0]=x[0]^=L2(mid);		//rk0=K4
			
			mid=x[2]^x[3]^x[0]^CK[r+1];
			mid=ByteSub(mid);
			rk[r+1]=x[1]^=L2(mid);		//rk1=K5
			
			mid=x[3]^x[0]^x[1]^CK[r+2];
			mid=ByteSub(mid);
			rk[r+2]=x[2]^=L2(mid);		//rk2=K6
			
			mid=x[0]^x[1]^x[2]^CK[r+3];
			mid=ByteSub(mid);
			rk[r+3]=x[3]^=L2(mid);		//rk3=K7
		}
		
		if(CryptFlag==DECRYPT)
		{
			for(r=0;r<16;r++)
			{
				mid=rk[r];
				rk[r]=rk[31-r];
				rk[31-r]=mid;
			}
		}
	}
	
	public byte[] sms4(byte[] in,int inLen,byte[] key,int CryptFlag)
	{
		int point=0;
		int[] round_key=new int[ROUND]; 
		//int[] round_key={0};
		SMS4KeyExt(key,round_key,CryptFlag);
		byte[] input = new byte[16];
		byte[] output = new byte[16];
		byte[] out = new byte[16];
		while(inLen>=BLOCK)
		{
			input=Arrays.copyOfRange(in, point, point+16);
			SMS4Crypt(input,output,round_key);
			System.arraycopy(output, 0, out, point, BLOCK);
			inLen-=BLOCK;
			point+=BLOCK;
		}
		
		return out;
	}
	
	public String encode(String input,String key) throws IOException{
		byte[] b_input = input.getBytes("utf-8");
		byte[] b_key = new byte[16];
		byte[] bbs = key.getBytes("utf-8");
		if(bbs.length < 16){
			for(int i=0;i<bbs.length;i++){
				b_key[i] = bbs[i];
			}
		}else{
			b_key = bbs;
		}
		
		byte[] o = new byte[0];
		for(int i=0;i<b_input.length;i+=16){
			byte[] t = ArrayUtils.subarray(b_input, i, i+16);
			o = ArrayUtils.addAll(o, sms4(t,16,b_key,1));
		}
		return new sun.misc.BASE64Encoder().encode(o);
	}
	
	public String decode(String input,String key) throws IOException{
		byte[] b_input = new sun.misc.BASE64Decoder().decodeBuffer(input);
		byte[] b_key = new byte[16];
		byte[] bbs = key.getBytes("utf-8");
		
		if(bbs.length < 16){
			for(int i=0;i<bbs.length;i++){
				b_key[i] = bbs[i];
			}
		}else{
			b_key = bbs;
		}
		
		byte[] o = new byte[0];
		for(int i=0;i<b_input.length;i+=16){
			byte[] t = ArrayUtils.subarray(b_input, i, i+16);
			byte[] t1 = sms4(t,16,b_key,0);
			o = ArrayUtils.addAll(o,t1);
		}
		
		return new String(o,"utf-8").trim();
	}
	
	public static void main(String[] args) {
		String md5 = MD5.md5("ee8b43dde7c94f0384fcbf4b4e589c74");//对密钥进行MD5
		String xmlStr="<?xml version=\"1.0\" encoding=\"GB2312\"?>\n" +
				"<Case>\n" +
				"\t\t<data>\n" +
				"    <evaluation>\n" +
				"<!--评价信息UNID，用于关联评价整改反馈-->\n" +
				"        <evaluateUnid>评价信息唯一码（评价信息unid）</evaluateUnid>\n" +
				"        <apasInfoName>办件名称</apasInfoName>\n" +
				"<businessCode>省网事项编码</businessCode>\n" +
				"<serviceName>事项名称</serviceName>\n" +
				"<projectNo>办件申报号</ projectNo>\n" +
				"                <!-- 1：pc端，2：移动端，3：二维码，4：政务大厅平板电脑，5：政务大厅其他终端），6：电话，7：短信 -->\n" +
				"<pf>评价渠道</pf>\n" +
				"<contactName>评价人姓名</contactName>\n" +
				"<contactMobile>评价人手机号码</contactMobile>\n" +
				"\t            <isReceive>是否完成省网办办件汇聚</isReceive>\n" +
				"\t            <regionCode> 6位行政区划编码</regionCode>\n" +
				"                <!-- 第一次主动评价=1，追加评价=2 -->\n" +
				"\t            <evaluateType>评价类型</evaluateType>\n" +
				"<alternate>整体满意度</alternate>\n" +
				"<appraisald>评价详情</appraisald>\n" +
				"<writingevalua>文字评价</writingevalua>\n" +
				"<assesstime>评价时间</assesstime>\n" +
				"<nodeName>环节名称</nodeName>\n" +
				"</evaluation>\n" +
				"</data>\n" +
				"</Case>";
		try {
			String str = new SM4().encode(xmlStr, md5);//sm4对数据加密
			System.out.println("加密后："+str);
		} catch (Exception e) {
		}
	}
	
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/SM4Context.java

@@ -0,0 +1,14 @@
package com.yihu.jw.security.service.healthCare.utils;//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
public class SM4Context {
    public int mode = 1;
    public long[] sk = new long[32];
    public boolean isPadding = true;
    public SM4Context() {
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/SM4Util.java

@@ -0,0 +1,162 @@
package com.yihu.jw.security.service.healthCare.utils;//
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SM4Util {
    public static final String BM = "UTF-8";
    private String secretKey = "";
    private String iv = "1234567890ABCDEF";
    private final static char[] hexArray = "0123456789ABCDEF".toCharArray();
    public SM4Util() {
    }
    public SM4Util(String secretKey) {
        this.secretKey = secretKey;
    }
    public SM4Util(String secretKey, String iv) {
        this.secretKey = secretKey;
        this.iv = iv;
    }
    public String encryptDataECB(String plainText) throws Exception {
        return this.encryptDataECB(plainText.getBytes("UTF-8"));
    }
    public String encryptDataECB(byte[] content) throws Exception {
        SM4Context ctx = new SM4Context();
        ctx.isPadding = true;
        ctx.mode = 1;
        SM4New sm4 = new SM4New();
        byte[] keyBytes = getKey(this.secretKey);
        sm4.sm4_setkey_enc(ctx, keyBytes);
        byte[] encrypted = sm4.sm4_crypt_ecb(ctx, content);
        String cipherText = byteArrToHex(encrypted);
        if (cipherText != null && cipherText.trim().length() > 0) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(cipherText);
            cipherText = m.replaceAll("");
        }
        return cipherText.toUpperCase();
    }
    public String decryptDataECB(String encData) throws Exception {
        return new String(this.decryptDataECB(hexToByte(encData)));
    }
    public byte[] decryptDataECB(byte[] content) throws Exception {
        SM4Context ctx = new SM4Context();
        ctx.isPadding = true;
        ctx.mode = 0;
        SM4New sm4 = new SM4New();
        byte[] keyBytes = getKey(this.secretKey);
        sm4.sm4_setkey_dec(ctx, keyBytes);
        byte[] decrypted = sm4.sm4_crypt_ecb(ctx, content);
        return decrypted;
    }
    private static byte[] getKey(String strKey) throws Exception {
        byte[] arrBTmp = strKey.getBytes("UTF-8");
        byte[] arrB = new byte[16];
        for(int i = 0; i < arrBTmp.length && i < arrB.length; ++i) {
            arrB[i] = arrBTmp[i];
        }
        return arrB;
    }
    public String encryptDataCBC(String content) throws Exception {
        String encData = this.encryptDataCBC(content.getBytes("UTF-8"));
        return encData;
    }
    public String encryptDataCBC(byte[] content) throws Exception {
        SM4Context ctx = new SM4Context();
        ctx.isPadding = true;
        ctx.mode = 1;
        byte[] ivBytes = this.iv.getBytes("UTF-8");
        byte[] keyBytes = getKey(this.secretKey);
        SM4New sm4 = new SM4New();
        sm4.sm4_setkey_enc(ctx, keyBytes);
        byte[] encrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, content);
        String cipherText = byteArrToHex(encrypted);
        if (cipherText != null && cipherText.trim().length() > 0) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(cipherText);
            cipherText = m.replaceAll("");
        }
        return cipherText.toUpperCase();
    }
    public String decryptDataCBC(String content) throws Exception {
        String data = this.decryptDataCBC(hexToByte(content));
        return data;
    }
    public String decryptDataCBC(byte[] content) throws Exception {
        SM4Context ctx = new SM4Context();
        ctx.isPadding = true;
        ctx.mode = 0;
        byte[] ivBytes = this.iv.getBytes("UTF-8");
        byte[] keyBytes = getKey(this.secretKey);
        SM4New sm4 = new SM4New();
        sm4.sm4_setkey_dec(ctx, keyBytes);
        byte[] decrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, content);
        return new String(decrypted, "UTF-8");
    }
    public static String byteToHex(byte[] b) {
        if (b == null) {
            throw new IllegalArgumentException("Argument b ( byte array ) is null! ");
        } else {
            String hs = "";
            String stmp = "";
            for(int n = 0; n < b.length; ++n) {
                stmp = Integer.toHexString(b[n] & 255);
                if (stmp.length() == 1) {
                    hs = hs + "0" + stmp;
                } else {
                    hs = hs + stmp;
                }
            }
            return hs.toUpperCase();
        }
    }
    public static byte[] hexToByte(String hex) throws IllegalArgumentException {
        if (hex.length() % 2 != 0) {
            throw new IllegalArgumentException();
        } else {
            char[] arr = hex.toCharArray();
            byte[] b = new byte[hex.length() / 2];
            int i = 0;
            int j = 0;
            for(int l = hex.length(); i < l; ++j) {
                String swap = "" + arr[i++] + arr[i];
                int byteint = Integer.parseInt(swap, 16) & 255;
                b[j] = (new Integer(byteint)).byteValue();
                ++i;
            }
            return b;
        }
    }
    public static String byteArrToHex(byte... bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }
        return new String(hexChars);
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/SafeUtil.java

@@ -0,0 +1,97 @@
package com.yihu.jw.security.service.healthCare.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class SafeUtil {
    public static void main(String[] args) throws Exception {
        //String reqStr = "{\"funid\":\"N09.00.00.01\",\"data\":{\"idNo\":\"350823199201173123\",\"first\":\"022\",\"keyword1\":\"5\",\"keyword2\":\"通过审核\",\"keyword3\":\"20200706155415\"},\"access_token\":\"4f886faf22775ccc9c8add16268ca9cd\",\"sign_type\":\"MD5\",\"encrypt_type\":\"AES\"}";
        //solution(reqStr,"signBefore");
        System.out.println(AES.aesDecrypt("BUOL01yRhFPlT2J+6wTYzNc9Hv3aAwwjOGdqoU6NIe2wvR9MMg6p0Jv4h012uwDKrBv3HGIXu1t7xVStC/nX4QKmYDelbd+hUFl5QZQ6FX1f0LPXNki99HKcSV00aB+DDb9j9ocfr/z3G091yNHAo+VD/FxFo60agRdcv1vl7Hg=", "4bfb6947baf9df93"));
    }
    public static String  solution(String reqStr,String signKey,String type) throws Exception {
        if("beforeSign".equals(type)){
            //先签名再加密
            reqStr = sign(reqStr,signKey);
            reqStr = encrypt(reqStr,signKey);
        }else{
            //先加密再签名
            reqStr = encrypt(reqStr,signKey);
            reqStr = sign(reqStr,signKey);
        }
        System.out.println("最终请求数据消息体（签名加密后的）：" + reqStr);
        return reqStr;
    }
    private static String getSortSignTemp(JSONObject json) {
        String signTemp = "";
        String jsonStr = JSONObject.toJSONString(json, SerializerFeature.MapSortField);
        LinkedHashMap m = JSON.parseObject(jsonStr, LinkedHashMap.class);
        Iterator<Map.Entry> iterator = m.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = iterator.next();
            String strVal = "";
            if (entry.getValue() instanceof Map) {
                strVal = JSONObject.toJSONString(entry.getValue(), SerializerFeature.MapSortField);
            } else {
                strVal = ConvertUtils.toString(entry.getValue(), "");
            }
            signTemp += entry.getKey() + "=" + strVal + "&";
        }
        signTemp = StringUtils.trimEnd(signTemp, "&");
        return signTemp;
    }
    public static String sign(String reqStr,String signKey) {
        JSONObject md5Json = JSONObject.parseObject(reqStr);
        String sign = md5Json.getString("sign");
        md5Json.remove("sign");
        String signTemp = getSortSignTemp(md5Json) + "&key=" + signKey;
        System.out.println(signTemp);
        String md5Sign = MD5.md5(signTemp).toUpperCase();
        md5Json.put("sign", md5Sign);
        reqStr = JSON.toJSONString(md5Json);
        return reqStr;
    }
    public static   String encrypt(String reqStr,String decryptKey) {
        //key
        JSONObject encJson = JSONObject.parseObject(reqStr);
        JSONObject dataJson = encJson.getJSONObject("data");
        encJson.remove("data");
        String encData = "";
        try {
            encData = AES.aesEncrypt(JSON.toJSONString(dataJson), decryptKey);
        } catch (Exception e) {
            e.printStackTrace();
        }
        encJson.put("encrypt_data", encData);
        reqStr = JSON.toJSONString(encJson);
        reqStr = reqStr.replaceAll("\\\\r\\\\n", "");
        try {
            System.out.println("解密 : " + AES.aesDecrypt(encData, decryptKey));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return reqStr;
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/StringUtils.java

@@ -0,0 +1,55 @@
package com.yihu.jw.security.service.healthCare.utils;
/**
 * @Author: lcp
 * @Date: 2020/6/3 9:52
 */
public class StringUtils {
    public static String trimEnd(String str, String stripChars) {
        return trim(str, stripChars, 1);
    }
    private static String trim(String str, String stripChars, int mode) {
        if (str == null) {
            return null;
        } else {
            int length = str.length();
            int start = 0;
            int end = length;
            if (mode <= 0) {
                if (stripChars == null) {
                    while (start < end && Character.isWhitespace(str.charAt(start))) {
                        ++start;
                    }
                } else {
                    if (stripChars.length() == 0) {
                        return str;
                    }
                    while (start < end && stripChars.indexOf(str.charAt(start)) != -1) {
                        ++start;
                    }
                }
            }
            if (mode >= 0) {
                if (stripChars == null) {
                    while (start < end && Character.isWhitespace(str.charAt(end - 1))) {
                        --end;
                    }
                } else {
                    if (stripChars.length() == 0) {
                        return str;
                    }
                    while (start < end && stripChars.indexOf(str.charAt(end - 1)) != -1) {
                        --end;
                    }
                }
            }
            return start <= 0 && end >= length ? str : str.substring(start, end);
        }
    }
}

server/svr-authentication/src/main/java/com/yihu/jw/security/service/healthCare/utils/YibaoJiaMi.java

@@ -0,0 +1,292 @@
package com.yihu.jw.security.service.healthCare.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
/**
 * Created by Bing on 2022/12/16.
 */
public class YibaoJiaMi {
    public static String signType = "MD5";//MD5,SM3
    public static String encryptType = "PKCS7";//AES,SM4ECB,PKCS7
    public static String encryptDataSign(JSONObject plainJson,String signKey,String encryptKey){
        plainJson.put("chs_fjs_encrypt_type", encryptType);
        plainJson.put("chs_fjs_sign_type", signType);
        //签名
        {
            plainJson.remove("chs_fjs_sign");
            String signTemp = getSortSignTemp(plainJson, signKey);
            String sign = sign(signTemp, signType);
            plainJson.put("chs_fjs_sign", sign);
        }
        //加密
        {
            String context = plainJson.toJSONString();
            if (isNotBlank(context)) {
                String encryptData = encrypt(context, encryptKey, encryptType);
                plainJson.remove("data");
                plainJson.put("chs_fjs_encdata", encryptData);
            }
        }
        System.out.println("最终请求报文：" + plainJson.toJSONString());
        return plainJson.toJSONString();
    }
    public static String encryptData(JSONObject plainJson,String signKey,String encryptKey){
        plainJson.put("encrypt_type", encryptType);
        plainJson.put("sign_type", signType);
        //签名
        {
            plainJson.remove("sign");
            String signTemp = getSortSignTemp(plainJson, signKey);
            String sign = sign(signTemp, signType);
            plainJson.put("sign", sign);
        }
        //加密
        {
            String context = plainJson.getString("data");
            if (isNotBlank(context)) {
                String encryptData = encrypt(context, encryptKey, encryptType);
                plainJson.remove("data");
                plainJson.put("encrypt_data", encryptData);
            }
        }
        System.out.println("最终请求报文：" + plainJson.toJSONString());
        return plainJson.toJSONString();
    }
    public static void main(String[] args) {
        String ylzConfigAppid = "cloudxmjw";
        String ylzConfigAppSecret = "f0ce9e957371bef58735de4abe1fa274";
        String ylzConfigSignKey = "2156B331D45F53B02BFF05C3942E60D8";
        String ylzConfigEncryptKey = "3716B331D45F53B02BFF05C3942E60D8";
        JSONObject object = new JSONObject();
        JSONObject data = new JSONObject();
        String funid = "N00.00.00.01";
        data.put("appid", ylzConfigAppid);
        data.put("appsecret", ylzConfigAppSecret);
        data.put("grant_type","client_credentials");
        object.put("sign_type","md5");
        object.put("chs_fjs_appid", ylzConfigAppid);
        object.put("data",data);
        object.put("chs_fjs_funid",funid);
        String ss = encryptData(object,ylzConfigSignKey,ylzConfigEncryptKey);
        System.out.println(ss);
        System.out.println();
    }
    /**
     * 获取待签名字符串
     *
     * @param json
     * @return
     */
    public static String getSortSignTemp(JSONObject json, String key) {
        System.out.println("需要签名的报文：" + json.toJSONString());
        String signTemp = "";
        String jsonStr = JSONObject.toJSONString(json, SerializerFeature.MapSortField);
        LinkedHashMap m = JSON.parseObject(jsonStr, LinkedHashMap.class);
        Iterator<Map.Entry> iterator = m.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = iterator.next();
            String strVal = "";
            if (entry.getValue() instanceof Map) {
                strVal = JSONObject.toJSONString(entry.getValue(), SerializerFeature.MapSortField);
            } else {
                if (null == entry.getValue()) {
                    strVal = "";
                } else {
                    strVal = String.valueOf(entry.getValue());
                }
            }
            signTemp += entry.getKey() + "=" + strVal + "&";
        }
        signTemp=signTemp.substring(0,signTemp.length()-1);
        signTemp = signTemp + "&key=" + key;
        System.out.println("待签名字符串：" + signTemp);
        return signTemp;
    }
    public static String sign(String signTemp, String signType) {
        switch (signType) {
            case "MD5":
                return signByMd5(signTemp);
            default:
                return null;
        }
    }
    public static String signByMd5(String signTemp) {
        System.out.println("签名类型：MD5");
        String sign = md5(signTemp, "utf-8").toUpperCase();//计算signStr的MD5值，并对结果转为大写
        System.out.println("签名结果：" + sign);
        return sign;
    }
    /**
     * MD5
     *
     * @param str
     * @param charset
     * @return
     */
    public static String md5(String str, String charset) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(str.getBytes(charset));
            byte[] b = md.digest();
            StringBuffer buf = new StringBuffer("");
            for (int offset = 0; offset < b.length; ++offset) {
                int i = b[offset];
                if (i < 0) {
                    i += 256;
                }
                if (i < 16) {
                    buf.append("0");
                }
                buf.append(Integer.toHexString(i));
            }
            str = buf.toString();
        } catch (Exception var7) {
            var7.printStackTrace();
        }
        return str;
    }
    public static String encrypt(String context, String key, String encryptType) {
        try {
            switch (encryptType) {
                case "PKCS7":
                    return encryptByPKCS7(context, key);
                case "SM4ECB":
                    return encryptBySM4ECB(context, key);
                case "AES":
                    return AES.aesEncrypt(context, key);
                default:
                    return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static String encryptByPKCS7(String context, String key) {
        System.out.println("加密模式：PKCS7");
        System.out.println("加密前：" + context);
        String encode = null;
        try {
            BASE64Encoder base64Encoder=new BASE64Encoder();
            encode=base64Encoder.encode(Pkcs7Encoder.encrypt(context.getBytes("UTF-8"), key.getBytes()));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println("加密结果：" + encode);
        return encode;
    }
    /**
     * SM4ECB加密
     *
     * @param context
     * @param key
     * @return
     */
    public static String encryptBySM4ECB(String context, String key) {
        SM4Util sm4 = new SM4Util(key, "");
        System.out.println("加密模式：SM4ECB");
        System.out.println("加密前：" + context);
        String cipherText = null;
        try {
            cipherText = sm4.encryptDataECB(context);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("加密结果：" + cipherText);
        return cipherText;
    }
    public static String decrypt(String encryptData, String key) {
        try {
            switch (encryptType) {
                case "PKCS7":
                    return decryptByPKCS7(encryptData, key);
                case "SM4ECB":
                    return decryptBySM4ECB(encryptData, key);
                case "AES":
                    return  AES.aesDecrypt(encryptData, key);
                default:
                    return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static String decryptBySM4ECB(String encryptData, String key) {
        SM4Util sm4 = new SM4Util(key, "");
        System.out.println("解密模式：SM4ECB");
        System.out.println("解密前：" + encryptData);
        String cipherText = null;
        try {
            cipherText = sm4.decryptDataECB(encryptData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("解密结果：" + cipherText);
        return cipherText;
    }
    public static String decryptByPKCS7(String context, String key) {
        try {
            BASE64Decoder base64Decoder=new BASE64Decoder();
            String aes7Str = new String(Pkcs7Encoder.decrypt(base64Decoder.decodeBuffer(context), key.getBytes()), "UTF-8");
            return aes7Str;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static boolean isNotBlank(String str) {
        return !isBlank(str);
    }
    public static boolean isBlank(String str) {
        int strLen;
        if (str != null && (strLen = str.length()) != 0) {
            for(int i = 0; i < strLen; ++i) {
                if (!Character.isWhitespace(str.charAt(i))) {
                    return false;
                }
            }
            return true;
        } else {
            return true;
        }
    }
}