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

package com.ynxbd.common.action;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ynxbd.common.action.base.BaseAction;
import com.ynxbd.common.bean.Patient;
import com.ynxbd.common.bean.User;
import com.ynxbd.common.bean.enums.HCardTypeEnum;
import com.ynxbd.common.bean.enums.HealthCardEnum;
import com.ynxbd.common.bean.enums.HealthCardRespCodeEnum;
import com.ynxbd.common.config.interceptor.AesDecode;
import com.ynxbd.common.dao.PatientDao;
import com.ynxbd.common.dao.his.HisPatientDao;
import com.ynxbd.common.helper.common.*;
import com.ynxbd.common.result.Result;
import com.ynxbd.common.result.ResultEnum;
import com.ynxbd.common.service.HCodeService;
import com.ynxbd.common.service.PatientService;
import com.ynxbd.wx.config.WeChatConfig;
import com.ynxbd.wx.wxfactory.AesWxHelper;
import com.ynxbd.wx.wxfactory.WxCacheHelper;
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;
import org.ehcache.Cache;

import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

/**
 * @Author wsq
 * @Date 2020/9/24 18:00
 * @Copyright @ 2020 云南新八达科技有限公司 All rights reserved.
 */
@Slf4j
@Namespace("/healthCode")
public class HealthCodeAction extends BaseAction {

    /**
     * [患者]查询信息
     */
    @Action("getPatientByIdCardNo")
    public Result getPatientByIdCardNo(@AesDecode String openid, @AesDecode String idCardNo) {
        log.info("[电子健康卡]根据身份证和openId查询患者信息 openid={}, idCardNo={}", openid, idCardNo);
        if (openid == null || idCardNo == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }

        Patient patient = new PatientDao().selectByIdCardNo(openid, idCardNo);
        return Result.success(patient);
    }

    /**
     * [电子健康卡]查询患者集
     */
    @Action("getHealthCardList")
    public Result getHealthCardList(@AesDecode String openid) {
        log.info("[电子健康卡]查询患者集 openid={}", openid);
        if (openid == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }
        List<Patient> patients = new PatientDao().selectHealthCardListByOpenid(openid);
        return Result.success(patients);
    }


    //    @Action("appBindHealthCard")
//    public Result appBindHealthCard(String openid, String healthCode) {
//        log.info("[新版电子健康卡]H5嵌入链接绑卡-通过healthCode获取健康卡数据 healthCode={}, openid={}", healthCode, openid);
//        if (healthCode == null || openid == null) return Result.error(ResultEnum.PARAM_IS_DEFECT); // 参数为空
//
//        Patient patient = HCodeService.appBindHealthCard(healthCode); // 通过健康卡授权码获取健康卡的用户信息
//        if (patient == null) {
//            log.info("[新版电子健康卡]H5嵌入链接绑卡 获取用户信息失败");
//            return Result.error("[新版电子健康卡]H5嵌入链接绑卡 获取用户信息失败");
//        }
//        return Result.success(patient);
//    }

    /**
     * 获取HIS地区编码信息
     */
    @Action("getArea")
    public Result getArea(Integer level, String areaCode) {
        try {
            return Result.success(new HisPatientDao().getArea(level, areaCode));
        } catch (Exception e) {
            return Result.error(e);
        }
    }

    /**
     * 获取token，用于绑卡
     */
    @Action("getAppToken")
    public Result getAppToken(Boolean isMiniApp) {
        String appToken = HCodeService.getAppToken(isMiniApp, true);
        return appToken == null ? Result.error() : Result.success();
    }


    /**
     * [电子健康卡]通过二维码获取健康卡数据
     *
     * @param qrCode 二维码
     */
    @Action("getHealthCardByQrCode")
    public Result getHealthCardByQrCode(Boolean isMiniApp, String qrCode) {
        log.info("[电子健康卡]通过二维码获取健康卡数据 isMiniApp={}, qrCode={}", isMiniApp, qrCode);
        if (qrCode == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }

        Patient patient = HCodeService.getHealthCardByQrCode(isMiniApp, qrCode);
        return patient == null ? Result.error() : Result.success(patient);
    }


    /**
     * 获取健康卡二维码
     *
     * @param isMiniApp    isMiniApp
     * @param idCardNo     证件号码
     * @param healthCardId 健康卡ID
     * @return result
     */
    @Action("getDynamicQRCode")
    public Result getDynamicQRCode(Boolean isMiniApp, String idCardNo, String healthCardId) {
        log.info("[电子健康卡]获取二维码 healthCardId={}, idCardNo={}", healthCardId, idCardNo);
        if (healthCardId == null || idCardNo == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT); // 参数缺失
        }

        JSONObject result = HCodeService.getDynamicQRCode(isMiniApp, healthCardId, idCardNo, "0");
        return result == null ? Result.error() : Result.success(result);
    }

    /**
     * 获取卡包订单ID
     */
    @Action("getCardOrderId")
    public Result getCardOrderId(Boolean isMiniApp, String idCardNo, String healthCardId) {
        log.info("[电子健康卡]获取卡包订单ID healthCardId={}, idCardNo={}", healthCardId, idCardNo);
        if (healthCardId == null || idCardNo == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT); // 参数缺失
        }

        String qrCodeText = HCodeService.getQRCodeText(isMiniApp, healthCardId, idCardNo);
        if (qrCodeText == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT); // qrCodeText参数缺失
        }
        JSONObject result = HCodeService.getCardOrderId(isMiniApp, qrCodeText);
        return result == null ? Result.error() : Result.success(result);
    }


    /**
     * 健康卡[上报数据]
     *
     * @param scene        上报类型编码
     * @param openid       openid -->1.前端可以利用openid来操作是否上报， 2.防止非法调用
     * @param idCardNo     身份证
     * @param healthCardId 健康卡id
     */
    @Action("reportHISData")
    public Result reportHISData(String scene, String openid, @AesDecode String idCardNo, String healthCardId) {
        if (scene == null || openid == null || healthCardId == null || idCardNo == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }

        String qrCodeText = HCodeService.getQRCodeText(false, healthCardId, idCardNo);
        if (qrCodeText == null) {
            return Result.error(ResultEnum.INTERFACE_OUTER_INVOKE_ERROR);
        }

        JSONObject jsonObject = HCodeService.reportHISData(qrCodeText, null, scene, HealthCardEnum.CARD_TYPE_HEALTH_CARD.STATUS, null);
        if (jsonObject == null) {
            return Result.error();
        }
        return Result.success();
    }


    /**
     * [电子健康卡]患者绑定（成人）
     */
    @Action("bind")
    public Result bind(Boolean isMiniApp, boolean isAreaCode, boolean isFace, String orderId, String registerOrderId, String address, String areaCode, String areaAddress, String openid, String tel, String sex, String name, String nation, String birthday, String idCardNo, String cardType, Boolean isHealthCard, String healthCardId, String wechatCode, String enOpenId, String enUnionId, String enGmcOpenId, String enHospAppId) {
        log.info("[电子健康卡]身份绑定 name={}, address={}, areaCode={}, areaAddress={}, nation={}, sex={}, birthday={}, tel={}, healthCardId={}, cardType={}, enUnionId={}, openId={}, enOpenId={}, enGmcOpenId={}, enChildAppId={}",
                name, address, areaCode, areaAddress, nation, sex, birthday, tel, healthCardId, cardType, enUnionId, openid, enOpenId, enGmcOpenId, enHospAppId);
        if (isHealthCard == null || openid == null || tel == null || sex == null || birthday == null || name == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }

        if (!openid.equals(AesWxHelper.decode(enOpenId))) {
            log.info("[绑定]参数无效 openId={}, enOpenId={}", openid, AesWxHelper.decode(enOpenId));
            return Result.error(ResultEnum.PARAM_IS_INVALID);
        }

        if (isHealthCard && isFace) { // 实名认证
            if (!HCodeService.checkUniformVerifyResult(isMiniApp, orderId, registerOrderId)) {
                return Result.error(ResultEnum.FACE_VERIFY_ERROR);
            }
        }

        if (cardType == null) cardType = HCardTypeEnum._01.WX_CODE;
        HCardTypeEnum cardTypeEnum = HCardTypeEnum.toTypeByWxCode(cardType);
        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 (nation.equals("未知")) {
            nation = "";
        }

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

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

        String uuid = null;
        if (HCodeService.isEnableHCode() && isHealthCard && healthCardId == null) { // 没有禁用电子健康卡
            log.info("[电子健康卡]绑定 wechatCode={}", wechatCode);
            if (wechatCode == null) {
                return Result.error(ResultEnum.PARAM_IS_DEFECT);
            }

            // 先注册，后修改-->先获取健康卡ID
            JSONObject respObj = HCodeService.registerHealthCard(isMiniApp, null, wechatCode, birthday, cardTypeEnum, address, areaAddress, sex, nation, name, idCardNo, tel);
            if (respObj == null) {
                log.info("[电子健康卡]注册健康卡失败,响应内容为空");

            } else {
                healthCardId = respObj.getString("healthCardId");
                if (ObjectUtils.isEmpty(healthCardId)) {
                    healthCardId = null; // 防止后续绑定院内关系失败
                    log.info("[电子健康卡]注册失败 healthCardId为空");
                    // 响应处理
                    String errMsg = respObj.getString("errMsg");
                    String resultCode = respObj.getString("resultCode");
                    HealthCardRespCodeEnum healthCardRespCodeEnum = HealthCardRespCodeEnum.findEnumByResultCode(resultCode);
                    log.info("[电子健康卡] 绑定失败原因 resultCode={}, errMsg={}, statusMsg={}", resultCode, errMsg, healthCardRespCodeEnum.MESSAGE);
                    if (!healthCardRespCodeEnum.IS_CONTINUE) { // 不继续执行
                        if (!healthCardRespCodeEnum.equals(HealthCardRespCodeEnum._10060)) { // 姓名和身份证不一致
                            return Result.error(healthCardRespCodeEnum.MESSAGE);
                        }

                        // 判断出生日期是否大于半年前-->婴儿
                        Boolean isOverDateByToday = DateHelper.isTodayMoveDateOverDate(birthday, -180);
                        if (isOverDateByToday == null || isOverDateByToday) {
                            return Result.error(healthCardRespCodeEnum.MESSAGE);
                        }
                        uuid = HCardTypeEnum.BABY.WX_CODE;
                    }
                }
            }
        }

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


    /**
     * 获取健康卡用户信息
     *
     * @param openid     openid
     * @param healthCode 健康卡授权码-->用来获取健康卡用户信息
     */
    @Action("getHealthCardInfo")
    public Result getHealthCardInfo(Boolean isMiniApp, String openid, String healthCode) {
        log.info("[电子健康卡]获取健康卡用户信息 healthCode={}, openid={}", healthCode, openid);
        if (healthCode == null || openid == null) return Result.error(ResultEnum.PARAM_IS_DEFECT);

        Patient patient = HCodeService.getHealthCardByHealthCode(isMiniApp, healthCode);
        if (patient == null) {
            log.info("[电子健康卡]获取健康卡用户信息-失败");
            return Result.error("[电子健康卡]获取健康卡用户信息-失败");
        }
        return Result.success(patient);
    }


    /**
     * [升级绑定]-->已在HIS绑定-->注册健康卡
     *
     * @param wechatCode wechatCode
     * @param id         id
     * @param idCardNo   idCardNo
     * @param cardType   cardType
     * @param openid     openid
     * @param tel        tel
     * @param name       name
     * @param nation     nation
     * @param patientId  patientId
     * @param address    address
     */
    @Action("upBind")
    public Result upBind(String wechatCode, Integer id, @AesDecode String idCardNo, @AesDecode String patientId, String cardType, String openid, String tel, String name, String nation, String address) {
        log.info("[电子健康卡]升级绑定 id={}, name={}, address={}, nation={}, patientId={}, tel={}, idType={}, wechatCode={}", id, name, address, nation, patientId, tel, cardType, wechatCode);
        if (wechatCode == null || openid == null || patientId == null || name == null || idCardNo == null || tel == null || address == null || nation == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }

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

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

        String sex = IDNumberHelper.getSex(idCardNo);
        String birthday = IDNumberHelper.getBirthday(idCardNo);
        if (sex == null || birthday == null) { // 身份证解析数据错误
            log.info("[电子健康卡]升级绑失败，身份证解析数据错误 sex={} birthday={}", sex, birthday);
            return Result.error(ResultEnum.PARAM_TYPE_ERROR);
        }

        // 先注册，后修改-->先获取健康卡ID
        JSONObject rspObj = HCodeService.registerHealthCard(false, patientId, wechatCode, birthday, cardTypeEnum, address, null, sex, nation, name, idCardNo, tel);
        if (rspObj == null) {
            log.info("[电子健康卡]升级绑定失败, 响应内容为空");
            return Result.error("[电子健康卡]升级绑定失败, 响应内容为空");
        }

        String healthCardId = rspObj.getString("healthCardId");
        if (healthCardId == null) {
            // 响应处理
            String errMsg = rspObj.getString("errMsg");
            String resultCode = rspObj.getString("resultCode");
            HealthCardRespCodeEnum healthCardRespCodeEnum = HealthCardRespCodeEnum.findEnumByResultCode(resultCode);

            log.info("[电子健康卡]升级绑定失败原因 resultCode={}, errMsg={}, statusMsg={}", resultCode, errMsg, healthCardRespCodeEnum.MESSAGE);
            return Result.error(healthCardRespCodeEnum.MESSAGE);
        }

        Patient bindInfo = new Patient();
        bindInfo.setOpenid(openid);
        bindInfo.setPatientId(patientId);
        bindInfo.setIdCardNo(idCardNo);
        bindInfo.setHealthCardId(healthCardId);
        bindInfo.setName(name);
        bindInfo.setNation(nation);
        bindInfo.setTel(tel);
        bindInfo.setAddress(address);

        boolean isUpdate = new PatientDao().updateInfo(bindInfo, id);
        if (isUpdate) {
            Cache<String, User> cache = WxCacheHelper.getUserCacheManager();
            cache.remove(openid);
            return Result.success();
        }
        return Result.error();
    }


    /**
     * 身份证识别
     */
    @Action("orcInfo")
    public Result orcInfo(Boolean isMiniApp, String image) {
        log.info("身份证识别");
        if (image == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT);
        }
        Patient patient = HCodeService.orcInfo(isMiniApp, image);
        return Result.success(patient);
    }


    /**
     * 实人认证生成orderId
     *
     * @param idCardNo   idCardNo
     * @param name       name
     * @param wechatCode wechatCode
     */
    @Action("registerUniformVerifyOrder")
    public Result registerUniformVerifyOrder(String idCardNo, String name, String wechatCode) {
        log.info("[电子健康卡]实人认证生成orderId idCardNo={}, name={}", idCardNo, name);
        if (idCardNo == null || name == null || wechatCode == null) {
            return Result.error(ResultEnum.PARAM_IS_DEFECT); // 参数为空
        }
        String orderId = HCodeService.bindUniformVerifyOrder(idCardNo, name, wechatCode);
        return ObjectUtils.isEmpty(orderId) ? Result.error() : Result.success(orderId);
    }

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


    @Action("batchUpdate")
    public void batchUpdate() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            public void run() {
                log.info("开始执行批量领卡定时任务");
                List<Patient> lstPatient = new PatientDao().selectPatient4BatchUpdateHealthCard();
                JSONArray jsonArray = null;
                try {
                    jsonArray = HCodeService.batchUpdate(lstPatient);
                } catch (Exception e) {
                    log.error(e.getMessage());
                }

                if (jsonArray == null) return;

                for (int i = 0; i < jsonArray.size(); i++) {
                    new PatientDao().updateCallFlag(jsonArray.getJSONObject(i).get("idNumber").toString());
                    if (!"".equals(jsonArray.getJSONObject(i).get("healthCardId").toString()) && !"".equals(jsonArray.getJSONObject(i).get("idNumber").toString()))
                        new PatientDao().updateHealthCard(jsonArray.getJSONObject(i).get("healthCardId").toString(),
                                jsonArray.getJSONObject(i).get("idNumber").toString());
                }
            }
        }, 2 * 1000, 30 * 1000);
    }


    /**
     * [电子健康卡]绑卡验证授权
     */
    @Action("registerHealthCardPreAuth")
    public Result registerHealthCardPreAuth(Boolean isMiniApp, String wechatCode, String healthCode, String openId) {
        log.info("[电子健康卡]绑卡验证授权 isMiniApp={}, wechatCode={}, healthCode={}, openId={}", isMiniApp, wechatCode, healthCode, openId);
        JSONObject result = HCodeService.registerHealthCardPreAuth(isMiniApp, WeChatConfig.getDomain(true), wechatCode, healthCode, openId);
        return Result.success(result);
    }

}