yuncai-scm/ruoyi-system/src/main/java/com/ruoyi/opt/service/impl/ProcessInfoServiceImpl.java

package com.ruoyi.opt.service.impl;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.json.JSONObject;
import com.ruoyi.common.request.CheckInformBo;
import com.ruoyi.common.request.PayInfomBo;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.common.utils.http.HttpsUtil;
import com.ruoyi.opt.domain.CompanyInfo;
import com.ruoyi.opt.mapper.CompanyInfoMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.ruoyi.opt.mapper.ProcessInfoMapper;
import com.ruoyi.opt.domain.ProcessInfo;
import com.ruoyi.opt.service.IProcessInfoService;
import com.ruoyi.common.core.text.Convert;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

/**
 * 保函订单Service业务层处理
 * 
 * @author chengpan
 * @date 2022-09-06
 */
@Service
@EnableTransactionManagement
@Slf4j
public class ProcessInfoServiceImpl /*extends ServiceImpl<ProcessInfoMapper, ProcessInfo>*/ implements IProcessInfoService
{
    @Autowired
    private ProcessInfoMapper processInfoMapper;
    @Autowired
    private CompanyInfoMapper companyInfoMapper;
    @Value("${testHttps}")
    private String testHttps;
    @Value("${prodHttps}")
    private String prodHttps;
    //审核通知接口
    @Value("${checkUrl}")
    private String checklUrl;
    //支付通知接口
    @Value("${payUrl}")
    private String payUrl;
    //填充
    @Value("${templateUrl}")
    private String templateUrl;

    @Override
    public int updateProcessInfoByProcessId(ProcessInfo processInfo) {
        int i = processInfoMapper.updateProcessInfoByProcessId(processInfo);
        return i;
    }

    /**
     * 查询保函订单
     * 
     * @param pId 保函订单主键
     * @return 保函订单
     */
    @Override
    public ProcessInfo selectProcessInfoByPId(Long pId)
    {
        return processInfoMapper.selectProcessInfoByPId(pId);
    }

    /**
     * 查询保函订单列表
     * 
     * @param processInfo 保函订单
     * @return 保函订单
     */
    @Override
    public List<ProcessInfo> selectProcessInfoList(ProcessInfo processInfo)
    {
        return processInfoMapper.selectProcessInfoList(processInfo);
    }

    /**
     * 新增保函订单
     * 
     * @param processInfo 保函订单
     * @return 结果
     */
    @Override
    public int insertProcessInfo(ProcessInfo processInfo)
    {
        return processInfoMapper.insertProcessInfo(processInfo);
    }

    /**
     * 修改保函订单
     * 
     * @param processInfo 保函订单
     * @return 结果
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED,rollbackFor=Exception.class)
    public AjaxResult updateProcessInfo(ProcessInfo processInfoParam)
    {
        log.info(String.valueOf(processInfoParam));
        //先去查询一下订单信息
        ProcessInfo processInfo = processInfoMapper.selectProcessInfoByPId(processInfoParam.getpId());
        processInfo.setProcessStsCd(processInfoParam.getProcessStsCd());
        try {
            String status = processInfo.getProcessStsCd();
            processInfo.setUpdateTime(DateUtils.getNowDate());
            //判断是什么操作，如果是03 04表示是审核操作   05表示已支付操作
            if ("03".equals(status) || "04".equals(status)){
                String checkResult = getCheckInform(processInfo);
                //解析json结果
                Map<String, Object> resultMap = JSON.parseObject(checkResult, Map.class);
                if ("0000".equals(resultMap.get("code").toString())){
                    int i = processInfoMapper.updateProcessInfo(processInfo);
                    return AjaxResult.success();
                } else {
                    return AjaxResult.error(resultMap.get("message").toString());
                }
            } else if ("05".equals(processInfo.getProcessStsCd())){
                try {
                    byte[] doGet = HttpsUtil.doGet(templateUrl + processInfo.getProcessId() + "&bankId=ZLTX");
                    String url = doGet.toString();
                    //存入processInfo库中
                    processInfo.setPolicySignUrl(url);
                    String payResult = getPayInform(processInfo);
                    //解析json结果
                    Map<String, Object> resultMap = JSON.parseObject(payResult, Map.class);
                    if ("0000".equals(resultMap.get("code").toString())){
                        //成功
                        int i = processInfoMapper.updateProcessInfo(processInfo);
                        return AjaxResult.success();
                    } else {
                        return AjaxResult.error(resultMap.get("message").toString());
                    }
                }catch (Exception e){
                    return AjaxResult.error(e.getMessage());
                }
            } else {
                int i = processInfoMapper.updateProcessInfo(processInfo);
                return AjaxResult.success();
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("修改错误，订单号为：" + processInfo.getProcessId());
            return AjaxResult.error("订单修改失败，未知错误，请联系相关人员！");
        }
    }
    
    
    /**
    * @desc : 封装审核参数并返回
    * @author : wangming
    * @createTime : 2022/9/8 9:12
    * @param : [pIds]
    * @return : int
    */
    private String getCheckInform(ProcessInfo processInfoParam){
        //开始组装参数
        Long pid = processInfoParam.getpId();   //拿到主键id
        String status = processInfoParam.getProcessStsCd();  //状态
        //查询订单表信息
        ProcessInfo processInfo = processInfoMapper.selectProcessInfoByPId(pid);
        //查询企业信息
        CompanyInfo companyInfo = companyInfoMapper.selectCompanyInfoByCompanyId(processInfo.getCompanyId());
        //审核操作,先组装参数
        CheckInformBo checkInformBo = new CheckInformBo();
        if ("04".equals(status)){   //审核通过
            checkInformBo.setCode("01");
        } else {   //审核不通过
            checkInformBo.setCode("02");
            checkInformBo.setMessage(processInfo.getRejectReason());   //拒绝原因
        }
        checkInformBo.setProcessId(processInfo.getProcessId());
        checkInformBo.setApplyPolicyNo(null);    //投保单号
        checkInformBo.setPremium(processInfo.getPremiumAmt());    //保费
        checkInformBo.setTotalAmt(processInfo.getLoanAmt());       //保额
        //开户行
        if (!ObjectUtils.isEmpty(companyInfo)){
            checkInformBo.setSkKHH(companyInfo.getBasicAccountBank());    //收款开户行
            checkInformBo.setSkAccount(companyInfo.getBasicAccountNo());   //收款账号
        }
        checkInformBo.setPostscript(processInfo.getPostscript());
//        String string = JSONUtils.toJSONString(process);
        String checkJsonString = JSON.toJSONString(checkInformBo);
//        String checkJsonString = JSONObject.valueAsStr(checkInformBo);
        //http请求调用
        String testCheckUrl = testHttps + checklUrl;
        String prodCheckUrl = prodHttps + checklUrl;
        String checkResult = HttpUtils.sendPost(testCheckUrl, checkJsonString);
        return checkResult;
    }

    /**
    * @desc : 封装支付参数并返回
    * @author : wangming
    * @createTime : 2022/9/8 9:38
    * @param : []
    * @return : java.lang.String
    */
    private String getPayInform(ProcessInfo processInfoParam){
        //开始组装参数
        Long pid = processInfoParam.getpId();   //拿到主键id
        String status = processInfoParam.getProcessStsCd();  //状态
        //查询订单表信息
        ProcessInfo processInfo = processInfoMapper.selectProcessInfoByPId(pid);
        //查询企业信息
        CompanyInfo companyInfo = companyInfoMapper.selectCompanyInfoByCompanyId(processInfo.getCompanyId());
        //已支付操作   开始组装参数
        PayInfomBo payInfomBo = new PayInfomBo();
        payInfomBo.setProcessId(processInfo.getProcessId());
        payInfomBo.setApplyPolicyNo(null);    //投保单号
        if (!ObjectUtils.isEmpty(companyInfo)){
            payInfomBo.setCompanyName(companyInfo.getCompanyNm());
            payInfomBo.setCompanySocialNo(companyInfo.getCompanySocialNo());
            payInfomBo.setPayAccountName(null);
            payInfomBo.setPayBank(companyInfo.getBasicAccountBank());
            payInfomBo.setPayAccount(companyInfo.getBasicAccountNo());
        }
        payInfomBo.setCost(null);
        String payJsonString = JSON.toJSONString(payInfomBo);
        //http请求调用
        String testPayUrl = testHttps + payUrl;
        String prodPayUrl = prodHttps + payUrl;
        String payResult = HttpUtils.sendPost(testPayUrl, payJsonString);
        return payResult;
    }

    /**
     * 批量删除保函订单
     * 
     * @param pIds 需要删除的保函订单主键
     * @return 结果
     */
    @Override
    public int deleteProcessInfoByPIds(String pIds)
    {
        return processInfoMapper.deleteProcessInfoByPIds(Convert.toStrArray(pIds));
    }

    /**
     * 删除保函订单信息
     * 
     * @param pId 保函订单主键
     * @return 结果
     */
    @Override
    public int deleteProcessInfoByPId(Long pId)
    {
        return processInfoMapper.deleteProcessInfoByPId(pId);
    }
}