签约解约控制器接口

/**
 * @ Filename SignApiController.java
 * @ Description
 * @ Version 1.0
 */
@RestController
@RequestMapping(path="/sign",produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
@Api(value = "签约控制器接口",tags="签约控制器接口-SignApiController",description = "签约控制器接口",produces="application/json")
public class SignApiController extends BaseApiController {


    @Autowired
    private UnsignService unSignService;

    @Autowired
    private SignService signService;

    /**
     * 解约
     * @param request 解约请求入参
     * @return 解约结果返回
     */
    @RequestMapping("unsign")
    @ApiOperation(value = "解约请求接口",httpMethod = "POST")
    PayCoreResult unsign(@RequestBody UnsignRequest request) {
        return unSignService.unsign(request);
    }

    /**
     * 条件查询签约信息
     * @param request 查询其阿奴额入参
     * @return 查询结果返回
     */
    @RequestMapping("query")
    @ApiOperation(value = "条件查询签约信息",httpMethod = "POST")
    PayCoreResult query(@RequestBody QuerySignRequest request) {
        return signService.query(request);
    }

    /**
     *协议签约接口
     * @param request
     * @return
     */
    @RequestMapping("sign")
    @MethodRequired
    @ApiOperation(value = "协议签约接口",httpMethod = "POST")
    public PayCoreResult sign(@RequestBody SignRequest request){
        return signService.sign(request);
    }

    /**
     * 协议签约确认接口
     * @param request
     * @return
     */
    @RequestMapping("signConfirm")
    @ApiOperation(value = "协议签约确认接口",httpMethod = "POST")
    PayCoreResult signConfirm(@RequestBody SignConfirmRequest request){
        return signService.signConfirm(request);
    }

    /**
     * 校验是否需要签约
     * @param request
     * @return
     */
    @RequestMapping("checkSign")
    @ApiOperation(value = "校验是否需要签约",httpMethod = "POST")
    PayCoreResult checkSign(@RequestBody SignCheckRequest request){
        return signService.signCheck(request);
    }
}




/**
 * @ Filename UnsignService.java
 * @ Description
 * @ Version 1.0
 */
public interface UnsignService {

    /**
     * 解约
     * @param request
     * @return
     */
    PayCoreResult<BaseResultVo> unsign(UnsignRequest request);


    /**
     * 接收支付核心MQ消息进行解约
     * @param responseBody
     * @return
     */
    boolean unsignAck(CoreBaseResponseBody responseBody);

    boolean unsignRecvGw(MessageEntity<BaseResponseBody> messageEntity) throws PayCoreException;

}




/**
 * @ Filename UnsignServiceImpl.java
 * @ Description 解约服务实现
 * @ Version 1.0
 */
@Service
public class UnsignServiceImpl extends ServiceBase implements UnsignService {

    private Logger logger = LoggerFactory.getLogger(UnsignServiceImpl.class);

    @Autowired
    private MonitorService monitorService;

    @Autowired
    private UnsignDomainFactory unsignDomainFactory;

    @Autowired
    private UnsignCardCommandChain unsignCardCommandChain;

    @Autowired
    private UnsignWapCommandChain unsignWapCommandChain;

    @Autowired
    private UnsignCardCommand unsignCardCommand;

    @Autowired
    private UnsignWapCommand unsignWapCommand;

    @Autowired
    private UnsignDetailRepository unsignDetailRepository;

    @Autowired
    private UnsignOrderRepository unsignOrderRepository;

    @Autowired
    private UnsignNotifyBizCommand unsignNotifyBizCommand;

    @Autowired
    private WapSignDetailRepository wapSignDetailRepository;

    @Autowired
    private WapSignOrderRepository wapSignOrderRepository;

    @Autowired
    private UnsignDomainRepository unsignDomainRepository;

    @Autowired
    private WapSignNotifyBizCommand wapSignNotifyBizCommand;


    /**
     * 解约
     *
     * @param request 解约参数
     * @return 解约返回结果
     */
    @Override
    public PayCoreResult<BaseResultVo> unsign(UnsignRequest request) {
        return serviceTemplate.execute(new ServiceCallback<Domain, PayCoreResult>() {
            @Override
            public Domain beforeProcess() throws PayCoreException {
                //参数校验
                AssertUtils.isNotNull(request, SystemErrorCode.BIZ_PARAM_NULL);
                request.check();

                return unsignDomainFactory.createDomain(request);
            }

            @Override
            public void execute(Domain domain) throws PayCoreException {
                UnsignDomain unsignDomain = (UnsignDomain) domain;
                if (StringUtils.equals(unsignDomain.getUnsignOrder().getSignType(), SignTypeEnum.CARD.code())) {
                    unsignCardCommandChain.execute(domain);//银行卡解约
                } else {
                    unsignWapCommandChain.execute(domain);//网关解约
                }
            }

            @Override
            public PayCoreResult resultProcess(Domain domain) {
                UnsignDomain unsignDomain = (UnsignDomain) domain;
                return new PayCoreResult(new BaseResultVo(unsignDomain.getUnsignOrder().getBizStatus(),
                        unsignDomain.getUnsignOrder().getRespCode(), unsignDomain.getUnsignOrder().getRespMsg()));
            }
        });
    }


    @Override
    public boolean unsignAck(CoreBaseResponseBody responseBody) {
        UnsignDomain domain = new UnsignDomain();
        //幂等性校验
        UnsignDetail detail = unsignDetailRepository.findByPayOrderNo(responseBody.getPayOrderNo());
        if (detail != null) {
            logger.info("解约订单已经存在，不需要继续发起解约，订单号payOrderNo：{}", responseBody.getPayOrderNo());
            return true;
        }
        //状态校验
        UnsignOrder unsignOrder = unsignOrderRepository.findByPayOrderNo(responseBody.getPayOrderNo());
        if (unsignOrder == null
                || StringUtils.equals(BizStatus.FAILED.code(), unsignOrder.getBizStatus())
                || StringUtils.equals(BizStatus.SUCCESS.code(), unsignOrder.getBizStatus())) {
            return true;
        }
        domain.setUnsignOrder(unsignOrder);

        if (StringUtils.equals(unsignOrder.getSignType(), SignTypeEnum.CARD.code())) {
            unsignCardCommand.execute(domain);//银行卡解约
        } else {
            //查找解约对应的网关签约信息
            unsignDomainRepository.findSignInfo(domain, unsignOrder.getAcctNo());
            unsignWapCommand.execute(domain);//网关解约
        }

        return true;
    }

    @Override
    public boolean unsignRecvGw(MessageEntity<BaseResponseBody> messageEntity) throws PayCoreException {
        //对象解析
        Header header = messageEntity.getHeader();
        BaseResponseBody responseBody = messageEntity.getBody();
        String paySerialNo = header.getChannelTransNo();

        //网关状态校验
        if (ProcessStatus.GW_DOING.getGwStatus().equals(responseBody.getTransStatus())) {
            return true;
        }

        UnsignDomain domain = new UnsignDomain();

        //查询解约明细，如不存在，再查询签约明细
        UnsignDetail detail = unsignDetailRepository.findByPaySerialNo(paySerialNo);
        if (detail == null) {
            logger.info("paySerialNo={}解约数据不存在，查找网关签约数据", paySerialNo);

            //解约数据不存在，paygw会根据签约表里的channelTransNo进行异步通知，所以此处查询签约明细
            WapSignDetail wapSignDetail = wapSignDetailRepository.findByPaySerialNo(paySerialNo);
            AssertUtils.isNotNull(wapSignDetail, SystemErrorCode.DATA_NOT_EXIST, "签约明细不存在paySerialNo:" + paySerialNo);
            WapSignOrder wapSignOrder = wapSignOrderRepository.findByPayOrderNo(wapSignDetail.getPayOrderNo());
            AssertUtils.isNotNull(wapSignOrder, SystemErrorCode.DATA_NOT_EXIST, "签约订单不存在");

            domain.setWapSignDetail(wapSignDetail);
            domain.setWapSignOrder(wapSignOrder);
            domain.setExistUnsign(false);
            domain.setSignType(SignTypeEnum.WAP.code());
        } else {
            UnsignOrder unsignOrder = unsignOrderRepository.findByPayOrderNo(detail.getPayOrderNo());
            if (unsignOrder == null) {
                LoggerUtil.info(logger, "payOrderNo={}解约订单不存在", detail.getPayOrderNo());
                return true;
            }
            //终态校验，解约订单状态已经终态（成功/失败）直接返回true，ack消息
            if (BizStatus.SUCCESS.getCode().equals(unsignOrder.getBizStatus())
                    || BizStatus.FAILED.getCode().equals(unsignOrder.getBizStatus())) {
                LoggerUtil.info(logger, "payOrderNo={}解约订单状态已经终态", detail.getPayOrderNo());
                return true;
            }

            domain.setUnsignOrder(unsignOrder);
            domain.setUnsignDetail(detail);
            domain.setExistUnsign(true);
            domain.setSignType(unsignOrder.getSignType());

        }

        try {
            domain = findAndSave(responseBody, domain);
        } catch (PayCoreException payCoreException) {
            //TODO SystemErrorCode.ORDER_STATUS_ERR此校验表示数据已终态,可返回true,不再消费
            if (StringUtils.equals(payCoreException.getErrorCode().getCode(),
                    SystemErrorCode.ORDER_STATUS_ERR.code())) {
                LoggerUtil.error(logger, "订单已是终态,不需要重新处理");
                return true;
            }
            LoggerUtil.error(logger, "解约异步回执事务更新异常", payCoreException);
            return false;
        } catch (Exception e) {
            LoggerUtil.error(logger, "解约UnsignDetail回执事务更新异常，参数paySerialNo：{}", paySerialNo, e);
            return false;
        }

        //异步通知业务系统
        unsignNotifyBizCommand.execute(domain);

        return true;
    }

    private UnsignDomain findAndSave(final BaseResponseBody responseBody, UnsignDomain domain) throws PayCoreException{
        return transactionTemplate.execute((TransactionStatus status)->{

            if (domain.isExistUnsign()) {
                /* 存在解约数据 */
                UnsignOrder unsignOrder = domain.getUnsignOrder();
                UnsignDetail unsignDetail = domain.getUnsignDetail();
                //用id加锁查询
                UnsignDetail localUnsignDetail = unsignDetailRepository.getDetailByIdForUpdate(unsignDetail.getId());

                //**二判：2.判断状态是否已经终态，如果是终态（数据库状态不为处理中）抛出异常;*/
                //AssertUtils.isTrue(ProcessStatus.GW_DOING.getCode().equals(localUnsignDetail.getProcessStatus()), SystemErrorCode.ORDER_STATUS_ERR, "明细状态不为处理中");
                //TODO 防止终态数据同时更新
                if (ProcessStatus.GW_SUCCESS.getCode().equals(localUnsignDetail.getProcessStatus())
                        || ProcessStatus.GW_FAILED.getCode().equals(localUnsignDetail.getProcessStatus())) {
                    throw new PayCoreException(SystemErrorCode.ORDER_STATUS_ERR);
                }
                //更新明细表
                localUnsignDetail.setProcessStatus(responseBody.getTransStatus());
                localUnsignDetail.setGwTransNo(responseBody.getTransNo());
                localUnsignDetail.setGwTransDate(responseBody.getTransDateTime());
                localUnsignDetail.setGwRespCode(responseBody.getRespCode());
                localUnsignDetail.setGwRespMsg(responseBody.getRespMsg());
                localUnsignDetail.setUpdateTime(DateUtil.getCurrentDate());

                unsignOrder.setRespCode(localUnsignDetail.getGwRespCode());
                unsignOrder.setRespMsg(localUnsignDetail.getGwRespMsg());
                unsignOrder.setBizStatus(BizStatus.getByGwCode(responseBody.getTransStatus()).code());
                unsignOrder.setUpdateTime(DateUtil.getCurrentDate());

                //更新解约数据
                domain.setUnsignOrder(unsignOrderRepository.save(unsignOrder));
                domain.setUnsignDetail(unsignDetailRepository.save(localUnsignDetail));

                //更新其余处理中解约数据
                unsignDomainRepository.storeUnsignInfo(domain);
            }

            return domain;
        });
    }

}