WxPay/src/main/java/com/ynxbd/common/action/HealthCardAction.java

package com.ynxbd.common.action;

import com.alibaba.fastjson.JSONObject;
import com.ynxbd.common.action.base.BaseAction;
import com.ynxbd.common.bean.Patient;
import com.ynxbd.common.bean.enums.HCardTypeEnum;
import com.ynxbd.common.bean.enums.HealthCardSceneEnum;
import com.ynxbd.common.config.interceptor.AesDecode;
import com.ynxbd.common.helper.HealthCardHelper;
import com.ynxbd.common.helper.common.DateHelper;
import com.ynxbd.common.helper.common.ValidHelper;
import com.ynxbd.common.result.Result;
import com.ynxbd.common.result.ResultEnum;
import com.ynxbd.common.service.PatientService;
import com.ynxbd.wx.wxfactory.AesWxHelper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;

@Slf4j
@Namespace("/health_card")
public class HealthCardAction extends BaseAction {

    /**
     * [电子健康卡]绑卡验证授权
     */
    @Action("registerHealthCardPreAuth")
    public Result registerHealthCardPreAuth(Boolean isMiniApp, @AesDecode String openid, Integer patientType, String wechatCode, String enHisPatientId) {
        try {
            log.info("[电子健康卡]绑卡验证授权 isMiniApp={}, openid={}, patientType={}, wechatCode={}, enHisPatientId={}", isMiniApp, openid, patientType, wechatCode, enHisPatientId);
            if (wechatCode == null || openid == null) {
                return Result.error(ResultEnum.PARAM_IS_DEFECT);
            }
            if (!ObjectUtils.isEmpty(enHisPatientId)) {
                String hisPatientId = AesWxHelper.decode(enHisPatientId);
                if (ObjectUtils.isEmpty(hisPatientId)) {
                    return Result.error(ResultEnum.PARAM_IS_INVALID);
                }
            }
            JSONObject result = HealthCardHelper.registerHealthCardPreAuth(isMiniApp, isHttpsWithProxy(), openid, false, patientType, wechatCode, enHisPatientId);
            return Result.success(result);
        } catch (Exception e) {
            return Result.error(e);
        }
    }


    /**
     * [电子健康卡]验证注册/绑卡接口
     */
    @Action("registerHealthCardPreFill")
    public Result registerHealthCardPreFill(Boolean isMiniApp, @AesDecode String openid, String authCode, String name, String gender, String nation, String birthday, String idNumber, String phone) {
        log.info("[电子健康卡]验证注册/绑卡接口 isMiniApp={}, openid={}, authCode={}, name={}", isMiniApp, openid, authCode, name);
        if (openid == null || authCode == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }

        if (name == null || gender == null || nation == null || birthday == null || idNumber == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }
        JSONObject result = HealthCardHelper.registerHealthCardPreFill(isMiniApp, isHttpsWithProxy(), openid, authCode, name, gender, nation, birthday, idNumber, HCardTypeEnum._01, phone);
        if (result == null) {
            return Result.error();
        }
        return Result.success(result);
    }

    /**
     * [电子健康卡]健康卡授权码获取健康卡信息
     */
    @Action("getHealthCardByHealthCode")
    public Result getHealthCardByHealthCode(Boolean isMiniApp, @AesDecode String openid, String healthCode) {
        try {
            log.info("[电子健康卡]健康卡授权码获取健康卡信息 isMiniApp={}, openid={}, 健康卡授权码={}", isMiniApp, openid, healthCode);
            Patient patient = HealthCardHelper.getHealthCardByHealthCode(isMiniApp, openid, healthCode);
            return Result.success(patient);
        } catch (Exception e) {
            return Result.error(e);
        }
    }

    /**
     * [电子健康卡]获取建档信息接口
     */
    @Action("getRegInfoByCode")
    public Result getRegInfoByCode(Boolean isMiniApp, @AesDecode String openid, String regInfoCode) {
        try {
            log.info("[电子健康卡]获取建档信息接口 isMiniApp={}, openid={}, 建档授权码={}", isMiniApp, openid, regInfoCode);
            Patient patient = HealthCardHelper.getRegInfoByCode(isMiniApp, openid, regInfoCode);
            return Result.success(patient);
        } catch (Exception e) {
            return Result.error(e);
        }
    }

    /**
     * [电子健康卡]身份证识别
     */
    @Action("orcInfo")
    public Result orcInfo(@AesDecode String openid, String image) {
        try {
            System.out.println("[电子健康卡]身份证识别...");
            if (image == null) {
                return Result.error(ResultEnum.PARAM_IS_DEFECT);
            }
            Patient patient = HealthCardHelper.orcInfo(openid, image);
            return Result.success(patient);
        } catch (Exception e) {
            return Result.error(e);
        }
    }


    /**
     * 获取健康卡二维码
     *
     * @param isMiniApp    isMiniApp
     * @param idCardNo     证件号码
     * @param healthCardId 健康卡ID
     */
    @Action("getDynamicQRCode")
    public Result getDynamicQRCode(Boolean isMiniApp, @AesDecode String openid, @AesDecode String idCardNo, String healthCardId) {
        try {
            log.info("[电子健康卡]获取二维码 isMiniApp={}, openid={}, healthCardId={}", isMiniApp, openid, healthCardId);

            JSONObject result = HealthCardHelper.getDynamicQRCode(isMiniApp, openid, healthCardId, idCardNo, "0");
            return Result.success(result);
        } catch (Exception e) {
            return Result.error(e);
        }
    }

    /**
     * 身份绑定-医共体【敏感数据加密传输】
     */
    @Action("bindCardGmc")
    public Result bindCardGmc(String enOpenId, @AesDecode String healthCardId, String address, String areaCode, String areaAddress, @AesDecode String tel, String sex, String name, String nation, String birthday, @AesDecode String idCardNo, String cardType, String enUnionId, String enGmcOpenId, String hospAppId) {
        if (idCardNo == null || tel == null) {
            return Result.error(ResultEnum.PARAM_IS_INVALID);
        }
        return bindCard(false, false, enOpenId, healthCardId, address, areaCode, areaAddress, tel, sex, name, nation, birthday, idCardNo, cardType, enUnionId, enGmcOpenId);
    }

    /**
     * [电子健康卡]身份绑定（成人）
     */
    @Action("bindCard")
    public Result bindCard(Boolean isEnableHC, boolean isAreaCode, String enOpenId, String healthCardId, String address, String areaCode, String areaAddress, String tel, String sex, String name, String nation, String birthday, String idCardNo, String cardType, String enUnionId, String enGmcOpenId) {
        log.info("[电子健康卡]身份绑定 enOpenId={}, isEnableHC={} healthCardId={}, name={}, sex={}, nation={}, birthday={}, tel={}, address={}, areaCode={}, areaAddress={}, cardType={}, enUnionId={}, enGmcOpenId={}",
                enOpenId, isEnableHC, healthCardId, name, sex, nation, birthday, tel, address, areaCode, areaAddress, cardType, enUnionId, enGmcOpenId);
        if (enOpenId == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }
        String openid = AesWxHelper.decode(enOpenId);
        if (openid == null) {
            return Result.error(ResultEnum.PARAM_IS_INVALID);
        }

        if (tel == null || sex == null || birthday == null || name == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }

        if (address == null || areaCode == null) {
            log.info("[电子健康卡]地址参数缺失 areaCode={}, address={}", areaCode, address);
            return Result.error(ResultEnum.PARAM_ADDRESS_ERROR);
        }

        HCardTypeEnum cardTypeEnum = HCardTypeEnum.findByWxCode(cardType, HCardTypeEnum._01);
        if (cardTypeEnum == null) {
            return Result.error(ResultEnum.CARD_TYPE_NOT_FOUNT);
        }

        if (!ValidHelper.isValidTel(tel)) {
            log.info("[电子健康卡]电话号码错误 name={}, tel={}, idCardNo={}", name, tel, idCardNo);
            return Result.error(ResultEnum.TEL_ERROR);
        }

        if (!ValidHelper.isValidIdCard(idCardNo)) {
            log.info("[电子健康卡]身份证错误 name={}, tel={}, idCardNo={}", name, tel, idCardNo);
            return Result.error(ResultEnum.ID_CARD_ERROR);
        }

        if (!ValidHelper.isValidNation(nation)) {
            return Result.error(ResultEnum.NATION_ERROR);
        }

        if (!DateHelper.isValidDate(birthday)) { // 生日异常
            return Result.error(ResultEnum.PARAM_DATE_ERROR);
        }

        Patient info = new Patient();
        info.setOpenid(openid);
        info.setHealthCardId(healthCardId);
        info.setName(name);
        info.setSex(sex);
        info.setIdCardNo(idCardNo);
        info.setCardTypeEnum(cardTypeEnum);
        info.setTel(tel);
        info.setBirthday(birthday);
        info.setNation(nation);
        info.setAddress(address);
        info.setAreaCode(areaCode);
        info.setAreaAddress(areaAddress);
        //
        info.setEnOpenId(enOpenId);
        info.setEnUnionId(enUnionId);
        info.setEnGmcOpenId(enGmcOpenId);
        return new PatientService().bindCard(request, false, true, isAreaCode,true, info);
    }


    @Action("getCardOrderId")
    public Result getCardOrderId(Boolean isMiniApp, @AesDecode String openid, @AesDecode String idCardNo, String healthCardId) {
        try {
            log.info("[电子健康卡]获取卡包订单ID openid={}, healthCardId={}, idCardNo={}", openid, healthCardId, idCardNo);
            String qrCodeText = HealthCardHelper.getQRCodeText(isMiniApp, openid, healthCardId, idCardNo);
            JSONObject result = HealthCardHelper.getOrderIdByOutAppId(isMiniApp, openid, qrCodeText);
            return Result.success(result);
        } catch (Exception e) {
            return Result.error(e);
        }
    }


    @Action("registerUniformVerifyOrder")
    public Result registerUniformVerifyOrder(Boolean isMiniApp, @AesDecode String openid, String wechatCode, String sceneCode, String name, String idCardNo, String redirectPage, String redirectHash) {
        try {
            log.info("[电子健康卡]实人认证生成orderId isMiniApp={}, openid={}, wechatCode={}, sceneCode={}, name={}, idCardNo={}, redirectPage={}, redirectHash={}", isMiniApp, openid, wechatCode, sceneCode, name, idCardNo, redirectPage, redirectHash);
            if (wechatCode == null || name == null || idCardNo == null) {
                return Result.error(ResultEnum.PARAM_IS_DEFECT); // 参数为空
            }
            HealthCardSceneEnum sceneEnum = HealthCardSceneEnum.findEnum(sceneCode);
            if (sceneEnum == null) {
                return Result.error(ResultEnum.PARAM_IS_INVALID);
            }

            JSONObject dataJson = HealthCardHelper.registerUniformVerifyOrder(isMiniApp, isHttpsWithProxy(), openid, wechatCode, sceneEnum, name, idCardNo, redirectPage, redirectHash);
            return Result.success(dataJson);
        } catch (Exception e) {
            return Result.error(e);
        }
    }

    @Action("checkUniformVerifyResult")
    public Result checkUniformVerifyResult(Boolean isMiniApp, @AesDecode String openid, String orderId, String registerOrderId) {
        log.info("[电子健康卡]实人认证结果查询 isMiniApp={}, openid={}, orderId={}, registerOrderId={}", isMiniApp, openid, orderId, registerOrderId);
        if (openid == null || orderId == null || registerOrderId == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT); // 参数为空
        }
        return Result.isOK(HealthCardHelper.checkUniformVerifyResult(isMiniApp, openid, orderId, registerOrderId));
    }

    /**
     * 健康卡[上报数据]
     *
     * @param scene        上报类型编码
     * @param openid       openid
     * @param idCardNo     身份证
     * @param healthCardId 健康卡id
     */
    @Action("reportHISData")
    public Result reportHISData(@AesDecode String openid, @AesDecode String idCardNo, String healthCardId, String scene, String deptName) {
        JSONObject dataJson = HealthCardHelper.reportHISData(openid, healthCardId, idCardNo, scene, deptName, null);
        if (dataJson == null) {
            return Result.error();
        }
        return Result.success();
    }

}