java-insagent-pc/src/main/java/com/ydtech/modules/ttqf/service/impl/TtqfServiceImpl.java

package com.ydtech.modules.ttqf.service.impl;

import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ipaynow.jiaxin.domain.QueryPresignResultModel;
import com.ipaynow.jiaxin.response.BillDownloadResponse;
import com.ipaynow.jiaxin.response.ReceiptlDownloadResponse;
import com.ydtech.core.page.HttpResult;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.admin.constants.ManagementSource;
import com.ydtech.modules.admin.dao.SysAmountAuditingMapper;
import com.ydtech.modules.admin.dao.SysUserAccountHistoryMapper;
import com.ydtech.modules.admin.dao.SysUserBankCardMapper;
import com.ydtech.modules.admin.model.SysUser;
import com.ydtech.modules.admin.model.po.SysAmountAuditingEntity;
import com.ydtech.modules.admin.model.po.SysAmountAuditingHistory;
import com.ydtech.modules.admin.model.po.SysUserAccount;
import com.ydtech.modules.admin.model.po.SysUserAccountHistory;
import com.ydtech.modules.admin.model.vo.SysAmountAuditingVo;
import com.ydtech.modules.admin.service.*;
import com.ydtech.modules.lg.model.PushLgEntity;
import com.ydtech.modules.lg.service.PushLgEntityService;
import com.ydtech.modules.ttqf.LgInformationPush;
import com.ydtech.modules.ttqf.PayConstantStatus;
import com.ydtech.modules.ttqf.RetrieveTTQFApi;
import com.ydtech.modules.ttqf.TtqfDecrypt;
import com.ydtech.modules.ttqf.dao.PaySignCallbackMapper;
import com.ydtech.modules.ttqf.dao.PayTtqfLogMapper;
import com.ydtech.modules.ttqf.dao.PaymentNoticeMapper;
import com.ydtech.modules.ttqf.entity.PaySignCallback;
import com.ydtech.modules.ttqf.entity.PayTtqfLog;
import com.ydtech.modules.ttqf.entity.PayUserSign;
import com.ydtech.modules.ttqf.entity.PaymentNoticeEntity;
import com.ydtech.modules.ttqf.entity.response.TtqfResponse;
import com.ydtech.modules.ttqf.entity.vo.UserWithdrawal;
import com.ydtech.modules.ttqf.entity.vo.WithdrawalFRes;
import com.ydtech.modules.ttqf.service.PayUserSignService;
import com.ydtech.modules.ttqf.service.TtqfService;
import com.ydtech.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.Date;
import java.util.Objects;


@Slf4j
@Service
public class TtqfServiceImpl implements TtqfService {

    @Autowired
    private PayTtqfLogMapper logMapper;

    @Autowired
    private SysSwitchConfigService sysSwitchConfigService;

    @Autowired
    private PayUserSignService userSignService;

    @Autowired
    private SysAmountAuditingService sysAmountAuditingService;

    @Autowired
    private PaySignCallbackMapper signCallbackMapper;

    @Autowired
    private PaymentNoticeMapper noticeMapper;

    @Autowired
    private  PayUserSignService signService;

    @Autowired
    private SysAmountAuditingHistoryService sysAmountAuditingHistoryService;

    @Autowired
    private SysUserAccountService sysUserAccountService;

    @Autowired
    private SysUserAccountHistoryMapper sysUserAccountHistoryMapper;

    @Autowired
    private SysAmountAuditingMapper amountAuditingMapper;

    @Autowired
    private PushLgEntityService pushLgEntityService;

    @Autowired
    private SysUserService userService;

    @Override
    public Object getUserPay(String userId) {

        QueryWrapper<PayTtqfLog> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("lo.mch_batch_no,\n" +
                "\tlo.mch_order_no,\n" +
                "\tlo.amount,\n" +
                "\tlo.fee_amount,\n" +
                "\tn.`status`,\n" +
                "\tn.message,\n" +
                "\tn.pay_time ").eq("user_id",userId);


        return new Object();
    }

    @Override
    public TtqfResponse userSign(String obj) {
        try {
            String parse = TtqfDecrypt.parse(obj);
            if (!StringUtils.isEmpty(parse)){
                //保存签约回调信息
                PaySignCallback paySignCallback = JSONObject.parseObject(parse, PaySignCallback.class);
                paySignCallback.setCreateTime(new Date());
                int insert = signCallbackMapper.insert(paySignCallback);
                if (0 < insert){
                    //用户签约回调成功之后更新为签约状态并支持线上打款  签约成功更新状态
                    userSignService.updateUserSign(paySignCallback);
                    SpringUtil.getBean(LgInformationPush.class).push(paySignCallback);
                }
            }
        }catch (Exception r){
            log.info("接收签约通知回调保存失败 + PaySignCallback ================={}", r.getMessage());
        }
        return TtqfResponse.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public TtqfResponse paymentNotice(String obj) {
        String parse = TtqfDecrypt.parse(obj);
        if (!StringUtils.isEmpty(parse)){
            PaymentNoticeEntity noticeEntity = JSONObject.parseObject(parse, PaymentNoticeEntity.class);
            if (null != noticeEntity){
                LambdaQueryWrapper<PaymentNoticeEntity> paymentNoticeEntityLambdaQueryWrapper = new LambdaQueryWrapper<>();
                paymentNoticeEntityLambdaQueryWrapper.eq(PaymentNoticeEntity::getMchOrderNo, noticeEntity.getMchOrderNo());
                PaymentNoticeEntity notice = noticeMapper.selectOne(paymentNoticeEntityLambdaQueryWrapper);
                if (null == notice){
                    noticeEntity.setCreateTime(new Date());
                    noticeMapper.insert(noticeEntity);
                }
            }
            LambdaQueryWrapper<PayTtqfLog> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(PayTtqfLog::getMchOrderNo, noticeEntity.getMchOrderNo());
            PayTtqfLog ttqfLog = logMapper.selectOne(wrapper);
            SysAmountAuditingVo amountAuditingVo = new SysAmountAuditingVo();
            amountAuditingVo.setAmount(noticeEntity.getAmount());
            amountAuditingVo.setUserId(ttqfLog.getUserId());
            writeRecord(amountAuditingVo,ttqfLog.getSysAmountAuditingId(),noticeEntity.getFeeAmount());
        }
        log.info("接收打款通知回调 + paymentNotice ================={}", parse);
        return TtqfResponse.ok();
    }


    public void writeRecord(SysAmountAuditingVo sysAmountAuditingVo,String id,BigDecimal feeAmount){
        SysAmountAuditingEntity sysAmountAuditingEntity = sysAmountAuditingService.getById(id);
        if (ObjectUtils.isEmpty(sysAmountAuditingEntity)){
            return;
        }
        sysAmountAuditingVo.setId(sysAmountAuditingEntity.getId());
        //提现审核金额
        BigDecimal amount = sysAmountAuditingVo.getAmount();
        //提现人
        String userId = sysAmountAuditingVo.getUserId();
        //      用户扣减金额
        if (StringUtils.isNotEmpty(userId)) {
            //提现人账户
            SysUserAccount sysUserAccount = sysUserAccountService.getById(userId);
            if (ObjectUtils.isNotEmpty(sysUserAccount)) {
                //已到账金额 =  原先的到账金额+ 已到账的金额
                sysUserAccount.setSumAmountAccount((sysUserAccount.getSumAmountAccount() == null ? BigDecimal.ZERO : sysUserAccount.getSumAmountAccount()).add(amount));
                //支付中的金额 = 原先的支付金额 -去提现的金额
                sysUserAccount.setSumAmountPayment((sysUserAccount.getSumAmountPayment() == null ? BigDecimal.ZERO : sysUserAccount.getSumAmountPayment()).subtract(amount));
                sysUserAccountService.updateById(sysUserAccount);
            }
            sysAmountAuditingVo.setAuditingStatus("3");
            sysAmountAuditingVo.setAuditingTime(new Date());
            sysAmountAuditingVo.setBankNumber(sysAmountAuditingEntity.getBankNumber());
            sysAmountAuditingVo.setUserName(userService.getByUserId(sysAmountAuditingEntity.getUserId()).getName());
            sysAmountAuditingVo.setUserId(sysAmountAuditingEntity.getUserId());
            BeanUtils.copyProperties(sysAmountAuditingVo, sysAmountAuditingEntity);
            sysAmountAuditingEntity.setCreateTime(null);
            amountAuditingMapper.updateById(sysAmountAuditingEntity);
            //通过审核表id查询历史记录表
            LambdaQueryWrapper<SysUserAccountHistory> lqw = new LambdaQueryWrapper<>();
            lqw.eq(SysUserAccountHistory::getAuditiingId, sysAmountAuditingEntity.getId());
            lqw.eq(SysUserAccountHistory::getUserId, userId);
            //插入轨迹表审核成功数据
            SysUserAccountHistory sysUserAccountHistory = sysUserAccountHistoryMapper.selectOne(lqw);
            //插入轨迹表
            SysAmountAuditingHistory sysAmountAuditingHistory = new SysAmountAuditingHistory(null, sysAmountAuditingEntity.getId(), amount, userId, new Date(), "4", "1", sysUserAccountHistory.getId());
            sysAmountAuditingHistoryService.save(sysAmountAuditingHistory);
            sendCollect(sysAmountAuditingEntity,sysAmountAuditingHistory.getAuditingStatus(),feeAmount);
        }
    }


    @Override
    public HttpResult billDownload(Integer type, String date) {
        BillDownloadResponse response = RetrieveTTQFApi.billDownload(type, date);
        if (PayConstantStatus.BIZ_CODE.equals(response.getBizCode())){
            return HttpResult.ok(response.getResultModel().getBillUrl());
        }
        return HttpResult.error(response.getBizMsg());
    }

    @Override
    public HttpResult receiptDownload(String mchOrderNo, String orderNo) {
        ReceiptlDownloadResponse response = RetrieveTTQFApi.receiptDownload(mchOrderNo,orderNo);
        if (PayConstantStatus.BIZ_CODE.equals(response.getBizCode())){
            return HttpResult.ok(response.getResultModel().getReceiptUrl());
        }
        return HttpResult.error(response.getBizMsg());
    }

    @Override
    public HttpResult queryPressing(UserWithdrawal withdrawal) {
        if (!sysSwitchConfigService.getBalanceExtractStatus()){
            return HttpResult.ok(WithdrawalFRes.builder().bizCode("0").msg("").url("").build());
        }
        SysUser sysUser = SpringUtil.getBean(SysUserBankCardMapper.class).selectByIdPay(withdrawal.getUserId());
        if (Objects.isNull(sysUser)){
            return HttpResult.error("用户不存在，请检查");
        }
        if (StringUtils.isEmpty(sysUser.getIdentity())){
            return HttpResult.error("用户身份证号不存在，请检查");
        }
        if (!ManagementSource.MS_02.getCode().equals(sysUser.getManagementSource())){
            return HttpResult.ok(WithdrawalFRes.builder().bizCode("0").msg("").url("").build());
        }
        PayUserSign payUserSign = signService.selectOne(sysUser.getIdentity(),sysUser.getId());
        if (!Objects.isNull(payUserSign)){
            String signUrl = RetrieveTTQFApi.contractH5(sysUser.getIdentity());
            if (Objects.equals(PayConstantStatus.SIGN_STATUS,payUserSign.getSign()) &&
                    Objects.equals(PayConstantStatus.AUTH_STATUS,payUserSign.getAuthStatus())){

                return HttpResult.ok(WithdrawalFRes.builder().bizCode("3").msg("已签约").url(signUrl).build());
            }
            return HttpResult.ok(WithdrawalFRes.builder().bizCode("2").msg("签约中").url(signUrl).build());
        }
        try {
            boolean sign = false;
            QueryPresignResultModel resultModel = RetrieveTTQFApi.queryPressing(sysUser.getIdentity());
            if (Objects.equals(PayConstantStatus.SIGN_STATUS,resultModel.getSignStatus()) &&
                    Objects.equals(PayConstantStatus.AUTH_STATUS,resultModel.getAuthStatus())){
                sign = true;
            }
            return HttpResult.ok(WithdrawalFRes.builder().bizCode(sign ? "3" : "1").url("").msg(sign ? "已签约" : "未签约").build());
        }catch (Exception e){
            log.info("查询签约状态异常：{}", e.getMessage());
            return HttpResult.error();
        }
    }

    @Override
    public HttpResult signingAddress(UserWithdrawal withdrawal) {
        try {
            SysUser sysUser = SpringUtil.getBean(SysUserBankCardMapper.class).selectByIdPay(withdrawal.getUserId());
            if (Objects.isNull(sysUser)){
                return HttpResult.error("用户不存在，请检查");
            }
            if (StringUtils.isEmpty(sysUser.getIdentity())){
                return HttpResult.error("用户身份证号不存在，请检查");
            }
            String pres = RetrieveTTQFApi.pres(sysUser, withdrawal);
            if (!StringUtils.isEmpty(pres)){
                signService.saveUserSign(sysUser.getIdentity(),sysUser.getId());
            }
            return HttpResult.ok(WithdrawalFRes.builder().bizCode("").url(pres).msg("").build());
        }catch (Exception e){
            log.error("获取用户签约信息异常{}",e.getMessage());
            throw new SystemException("提现申请提交失败");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public HttpResult userCashOut(UserWithdrawal withdrawal) {
        try {
            SysUser sysUser = SpringUtil.getBean(SysUserBankCardMapper.class).selectByIdPay(withdrawal.getUserId());
            if (Objects.isNull(sysUser)){
                return HttpResult.error("用户不存在，请检查");
            }
            if (StringUtils.isEmpty(sysUser.getIdentity())){
                return HttpResult.error("用户身份证号不存在，请检查");
            }
            if (!ManagementSource.MS_02.getCode().equals(sysUser.getManagementSource())){
                return HttpResult.error("用户不是个代，请线下申请提现");
            }
            boolean balance = RetrieveTTQFApi.extractBalance(sysUser, withdrawal);
            return HttpResult.ok(balance);
        }catch (Exception e){
            log.error("提现申请提交失败{}",e.getMessage());
            throw new RuntimeException("提现申请提交失败");
        }
    }


    public void sendCollect(SysAmountAuditingEntity sysAmountAuditingEntity,String auditingStatus,BigDecimal feeAmount ){
        PushLgEntity lgEntity = new PushLgEntity();
        lgEntity.setApplicationTime(new Date());
        lgEntity.setBusinessUmber(sysAmountAuditingEntity.getId());
        lgEntity.setPayee(sysAmountAuditingEntity.getUserName());
        lgEntity.setPayeeId(sysAmountAuditingEntity.getUserId());
        lgEntity.setReceivingAccount(sysAmountAuditingEntity.getBankNumber());
        lgEntity.setExtractMoney(sysAmountAuditingEntity.getAmount());
        lgEntity.setServiceCharge(feeAmount);
        lgEntity.setExtractStatus(auditingStatus);
        pushLgEntityService.sendLgData(lgEntity);
    }



}