yuncai-scm/ruoyi-admin/src/main/java/com/ruoyi/web/controller/opt/OptController.java

package com.ruoyi.web.controller.opt;

import com.alibaba.druid.support.json.JSONUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.Rwww;
import com.ruoyi.common.json.JSONObject;
import com.ruoyi.common.request.PayInfomBo;
import com.ruoyi.common.request.ProcessInfoReq;
import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.common.utils.http.HttpsUtil;
import com.ruoyi.opt.domain.CompanyInfo;
import com.ruoyi.opt.domain.ProcessInfo;
import com.ruoyi.opt.service.ICompanyInfoService;
import com.ruoyi.opt.service.IProcessInfoService;
import com.ruoyi.opt.service.IProjectInfoService;
import com.ruoyi.opt.service.ISysInfoConfigService;
import com.ruoyi.web.controller.demo.domain.CoverBo;
import com.ruoyi.web.controller.demo.domain.ProcessBo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.*;

/**
 * @Author : wangming
 * @CreateTime : 2022-09-06
 * @Desc : 订单类
 */
@Controller
@RequestMapping("/process/operation")
@Slf4j
public class OptController {

    @Value("${testHttps}")
    private String testHttps;
    @Value("${prodHttps}")
    private String prodHttps;
    //订单信息请求接口
    @Value("${processUrl}")
    private String processUrl;

    @Value("${zUrl}")
    private String zeUrl;

    @Value("${coverUrl}")
    private String coverUrl;
    @Value("${appId}")
    private String appId;
    @Value("${sign}")
    private String sign;


    @Autowired
    private ISysInfoConfigService sysInfoConfigService;
    @Autowired
    private IProcessInfoService processInfoService;
    @Autowired
    private ICompanyInfoService companyInfoService;
    @Autowired
    private IProjectInfoService projectInfoService;


    /**
    * @desc : 此接口用来接收订单推送服务，只用来判断是否成功,,入库操作
    * @author : wangming
    * @createTime : 2022/9/6 11:04
    * @param : [processId 订单id]
    * @return : com.ruoyi.common.core.domain.AjaxResult
    */
    @ResponseBody
    @PostMapping("/put_in_storage")
    public Rwww chargeOrderNotice(@RequestBody ProcessBo processBo){
        log.info("订单信息请求参数信息：" + processBo);
        try {
            //先验证参数
            if (StringUtils.isEmpty(processBo.getProcessId()) || StringUtils.isEmpty(processBo.getAppId()) || StringUtils.isEmpty(processBo.getSign())){
                //返回接收失败
                return Rwww.paramNull("参数不可为空！");
            }
            //参数确认没问题以后去请求www服务进行订单信息获取
            HashMap<String, String> process = new HashMap<>();
            process.put("processId", processBo.getProcessId());
            process.put("appId", appId);
            process.put("sign", sign);
//            String string = JSONObject.valueAsStr(process);
            String string = JSON.toJSONString(process);
            log.error("调用www订单信息请求接口传参参数：" + string);
            String testProcessUrl = testHttps + processUrl;
            String prodProcessUrl = processUrl + processUrl;
            String zUrl = zeUrl + processUrl;
            log.info("订单信息请求中的ip和url是：" + testProcessUrl);
            String processResult = HttpUtils.JSONdoPost(testProcessUrl, string);
            log.info("订单信息请求返回的json信息是：" + processResult);
            //拿到解析结果，进行解析
            Map<String, Object> resultMap = JSON.parseObject(processResult, Map.class);
            String resultData = resultMap.get("data").toString();
            if (!"0".equals(resultMap.get("code"))){
                ProcessInfoReq processInfoReq = JSON.parseObject(resultData, ProcessInfoReq.class);
                String premiumAmtNum = getPremiumAmtNum(processInfoReq.getLoanAmt());
                processInfoReq.setPremium(premiumAmtNum);
                if (StringUtils.isNotEmpty(processInfoReq.getProcessId())){
                    //入本地企业信息库
                    companyInfoService.insertCompanyInfoByWww(processInfoReq);
                } else {
                    log.info("订单数据为空，请求失败,请求id为：" + processBo.getProcessId());
                    return Rwww.failwww("aaa");
                }
            } else {
                log.info("订单数据为空，请求失败,请求id为：" + processBo.getProcessId());
                return Rwww.failwww("订单数据请求错误，接收失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("订单接收出错:" + e.getLocalizedMessage());
            return Rwww.failwww("订单接收时程序出错");
        }
        return Rwww.okwww();
    }

    /**
    * @desc : 计算保费
    * @author : wangming
    * @createTime : 2022/9/9 15:27
    * @param : [loanAmt]
    * @return : java.lang.String
    */
    public String getPremiumAmtNum(String loanAmt){
        if (StringUtils.isNotEmpty(loanAmt)){
            double amt = Double.parseDouble(loanAmt);
            double v = amt * 0.005;
            if (v > 500){
                return String.valueOf(v);
            } else {
                return "500";
            }
        } else {
            return null;
        }
    }

    /**
    * @desc : 承保回调接口
    * @author : wangming
    * @createTime : 2022/9/8 9:43
    * @param : []
    * @return : void
    */
    @ResponseBody
    @PostMapping("/cover_callback")
    public R coverTheCallback(@RequestBody CoverBo coverBo){
        try {
            //接到消息开始拆解参数
            log.info("承保回调接口开始，请求参数是：" + coverBo);
            if (!ObjectUtils.allNotNull(coverBo)){
                return R.paramNull("参数不可为空！");
            }
            //拿到参数开始入库修改
            /*LambdaUpdateWrapper<ProcessInfo> updateWrapper = new UpdateWrapper<ProcessInfo>().lambda();
            updateWrapper.eq(ProcessInfo::getProcessId, coverBo.getProcessId())
                    .set(ProcessInfo::getPolicyDlUrl, coverBo.getPolicyDlUrl())
                    .set(ProcessInfo::getProcessStsCd, coverBo.getStatus());
            boolean update = processInfoService.update(null, updateWrapper);*/
            ProcessInfo processInfo1 = new ProcessInfo();
            processInfo1.setProcessId(coverBo.getProcessId());
            processInfo1.setPolicyDlUrl(coverBo.getPolicyDlUrl());
            processInfo1.setProcessStsCd(coverBo.getStatus());
            processInfoService.updateProcessInfoByProcessId(processInfo1);
            log.info("承保回调接口中拿到保函下载地址，修改库成功");
            //修改成功，去调www承保回调接口    组装参数
            ProcessBo processBo = new ProcessBo();
            processBo.setProcessId(coverBo.getProcessId());
            processBo.setAppId(appId);
            processBo.setSign(sign);
            //查出来保单信息
            processBo.setPolicyUrl(coverBo.getPolicyDlUrl());
            processBo.setPolicyNo("");
            processBo.setApplyPolicyNo("");
            processBo.setInvoiceUrl("");

            String coverParam = JSON.toJSONString(processBo);
            log.info("承保回调接口中调用www服务的入参是：" + coverParam);
            String coverHttpUrl = testHttps + coverUrl;
            log.info("承保回调接口调用url：" + coverHttpUrl);
            String coverResult = HttpUtils.JSONdoPost(coverHttpUrl, coverParam);
            log.info("承保回调接口调用www返回的参数：" + coverResult);
            //拿到解析结果，进行解析
            Map<String, Object> resultMap = JSON.parseObject(coverResult, Map.class);
            String code = resultMap.get("code").toString();
            if ("0000".equals(code)){
                return R.ok();
            } else {
                return R.failwww("推送www消息失败！");
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("承保回调错误，请检查：" + coverBo.getProcessId());
            return R.fail("承保回调错误");
        }
    }

    @ResponseBody
    @PostMapping("/test")
    public List<ProcessInfo> getaaa(){
        LambdaQueryWrapper<ProcessInfo> queryWrapper = new QueryWrapper<ProcessInfo>().lambda();
        queryWrapper.eq(ProcessInfo::getProcessId, "12423302203");
        List<ProcessInfo> list = processInfoService.list(queryWrapper);
        return list;
    }



}