caimei365-manager/src/main/java/com/caimei/modules/order/service/SplitAccountService.java

package com.caimei.modules.order.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.caimei.modules.order.dao.NewOrderDao;
import com.caimei.modules.order.dao.NewShopOrderDao;
import com.caimei.modules.order.entity.*;
import com.caimei.modules.order.utils.Disguiser;
import com.caimei.redis.RedisService;
import com.caimei.utils.MathUtil;
import com.thinkgem.jeesite.common.service.BaseService;
import okhttp3.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.IOException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;


@Service
@Transactional(readOnly = true)
public class SplitAccountService extends BaseService {

    public static OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(3, TimeUnit.SECONDS)
            .readTimeout(20, TimeUnit.SECONDS)
            .build();

    @Resource
    private NewOrderDao newOrderDao;
    @Resource
    private RedisService redisService;
    @Resource
    private NewShopOrderDao newShopOrderDao;

    @Transactional(readOnly = false, rollbackFor = Exception.class)
    public void SplitAccount(String shopOrderIds) {
        logger.info("【手动分账开始】>>>>>>>>>>手动分账");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String currentTime = format.format(calendar.getTime());
        // 查询未分账已支付收款
        List<OrderReceiptRelationPo> orderRelations = newOrderDao.getUndividedPaidReceipt(currentTime, shopOrderIds);
        if (null != orderRelations && orderRelations.size() > 0) {
            for (OrderReceiptRelationPo orderRelation : orderRelations) {
                logger.info("【分账】>>>>>>>>>>子订单id:" + orderRelation.getShopOrderId() + "进入分账");
                // 收款对应的订单信息
                ShopOrderVo shopOrder = newOrderDao.getShopOrderListByOrderId(orderRelation.getShopOrderId());
                PayParamBo payParam = new PayParamBo();
                //支付金额
                payParam.setAllPay(orderRelation.getAssociateAmount());
                if (12 == orderRelation.getPayType()) {
                    // 网银支付
                    payParam.setPayWay("UNIONPAY");
                }
                if (17 == orderRelation.getPayType()) {
                    //b2c网银
                    payParam.setPayWay("B2C");
                }
                //微信0.65%手续费
                if (8 == orderRelation.getPayType() || 13 == orderRelation.getPayType() || 15 == orderRelation.getPayType()) {
                    payParam.setPayWay("WX");
                }
                //快捷支付 借记卡支付28，贷记卡支付29
                if (28 == orderRelation.getPayType()) {
                    payParam.setPayWay("DEBIT");
                }
                if (29 == orderRelation.getPayType()) {
                    payParam.setPayWay("CREDIT");
                }
                List<SplitAccountPo> splitBillDetail = setSplitAccountDetail(shopOrder, payParam);
                HashMap<String, BigDecimal> sbm = new HashMap<>();
                for (SplitAccountPo splitAccountPo : splitBillDetail) {
                    String subUserNo = splitAccountPo.getSubUserNo();
                    if (sbm.containsKey(subUserNo)) {
                        BigDecimal v = MathUtil.add(sbm.get(subUserNo), splitAccountPo.getSplitAccount());
                        sbm.put(subUserNo, v);
                    } else {
                        sbm.put(subUserNo, BigDecimal.valueOf(splitAccountPo.getSplitAccount()));
                    }
                    // splitcode相同的收款的时候已经是成本已分帐
                    if (subUserNo.equals(shopOrder.getSplitCode())) {
                        splitAccountPo.setMbOrderId(orderRelation.getMbOrderId());
                        splitAccountPo.setOrderRequestNo(orderRelation.getOrderRequestNo());
                        splitAccountPo.setPayStatus(1);
                        // 保存分账详情
                        newOrderDao.insertSplitAccount(splitAccountPo);
                    }
                }
                ArrayList<AccountPayOrder.AccountPayOrderExt.SplitBillRule> splitBillRules = new ArrayList<>();
                sbm.forEach((key, value) -> {
                    // 不是自己的splitcode分走，是自己的不动
                    if (!key.equals(shopOrder.getSplitCode())) {
                        //佣金
                        AccountPayOrder.AccountPayOrderExt.SplitBillRule splitBillRule = new AccountPayOrder.AccountPayOrderExt.SplitBillRule();
                        splitBillRule.setSplitBillAmount(value);
                        splitBillRule.setSplitBillMerchantNo(key);
                        splitBillRules.add(splitBillRule);
                    } else {
                        // 成本分账处理
                        // 子订单的splitcode和分账对象的splitcode一样的是留在账户里的钱，实际在付款完成后，付款状态就为已付款，分账状态就为已分账
                        // 为维持业务完整性，保持原来的分账流程不变
                        List<SplitAccountPo> splitAccountList = newOrderDao.getSplitAccountList(orderRelation.getMbOrderId());
                        if (splitAccountList != null && splitAccountList.size() > 0) {
                            Integer orderId = splitAccountList.get(0).getOrderId();
                            List<ShopOrderVo> shopOrderList = newOrderDao.getShopOrderByOrderId(orderId);
                            Integer shopOrderId = null;
                            String shopOrderNo = "";
                            for (SplitAccountPo account : splitAccountList) {
                                // 本次付供应商金额(分账金额)
                                Double splitAmount = account.getSplitAccount();
                                orderId = account.getOrderId();
                                Integer shopId = account.getShopId();
                                for (ShopOrderVo shop : shopOrderList) {
                                    if (shopId.equals(shop.getShopId())) {
                                        shopOrderId = shop.getShopOrderId();
                                        shopOrderNo = shop.getShopOrderNo();
                                        // 已付供应商金额
                                        Double paidAmount = newOrderDao.getPaidShopAmount(shopOrderId);
                                        Double paidShop = MathUtil.add(paidAmount, splitAmount).doubleValue();
                                        shopOrder.setPayedShopAmount(paidShop);
                                        if (MathUtil.compare(shopOrder.getShouldPayShopAmount(), paidShop) == 0) {
                                            shopOrder.setPayStatus(3);
                                        } else {
                                            shopOrder.setPayStatus(2);
                                        }
                                        // 修改子订单付款状态及付款金额
                                        newOrderDao.updateShopOrderByPayStatus(shopOrderId, paidShop, shopOrder.getPayStatus());
                                    }
                                }
                                SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                String currentTime2 = format2.format(new Date());
                                // 保存付款单表
                                PayShopPo payShop = new PayShopPo();
                                payShop.setShopId(shopId);
                                payShop.setName("线上支付分账");
                                payShop.setTotalAmount(splitAmount);
                                payShop.setWipePayment(0d);
                                payShop.setPayType(6);
                                payShop.setStatus(1);
                                payShop.setDelFlag(0);
                                payShop.setApplyTime(currentTime2);
                                payShop.setReviewTime(currentTime2);
                                payShop.setPayTime(currentTime2);
                                newOrderDao.insertPayShop(payShop);
                                // 保存 付供应商记录
                                PayShopRecordPo shopRecord = new PayShopRecordPo();
                                shopRecord.setShopId(shopId);
                                shopRecord.setShopOrderId(shopOrderId);
                                shopRecord.setShopOrderNo(shopOrderNo);
                                shopRecord.setPayAmount(splitAmount);
                                shopRecord.setWipePayment(0d);
                                shopRecord.setPayType(6);
                                shopRecord.setPayTime(currentTime2);
                                shopRecord.setPayShopId(payShop.getId());
                                shopRecord.setStatus(1);
                                shopRecord.setDelFlag(0);
                                newOrderDao.insertPayShopRecord(shopRecord);
                            }
                            // 子订单是否全部付款
                            List<String> payStatus = newShopOrderDao.findPayStatusByOrderID(orderRelation.getOrderId());
                            boolean isPay = true;
                            for (String shops : payStatus) {
                                if (!"3".equals(shops)) {
                                    isPay = false;
                                    break;
                                }
                            }
                            // 修改主订单付款状态
                            if (isPay) {
                                newOrderDao.updateOrderByPayStatus(orderId, 3);
                            } else {
                                newOrderDao.updateOrderByPayStatus(orderId, 2);
                            }
                        }
                    }
                });
                splitBillDetail.removeIf(s -> s.getSubUserNo().equals(shopOrder.getSplitCode()));
                if (null != splitBillRules && splitBillRules.size() > 0) {
                    //第三方分账接口
                    try {
                        AccountPayOrder accountPayOrder = new AccountPayOrder();
                        accountPayOrder.setP1_bizType("AccountPaySub");
                        accountPayOrder.setP2_signType("MD5");
                        String format1 = new SimpleDateFormat("yyyy-MM-dd_HH:mm:ss.SSS").format(new Date());
                        accountPayOrder.setP3_timestamp(format1);
                        String substring = format1.substring(20);
                        // fz+当前微秒时间+原唯一订单号
                        accountPayOrder.setP4_orderId("FZ" + substring + orderRelation.getOrderRequestNo());
                        //付款账户子订单绑定商户号
                        accountPayOrder.setP5_customerNumber(shopOrder.getSplitCode());
                        AccountPayOrder.AccountPayOrderExt accountPayOrderExt = new AccountPayOrder.AccountPayOrderExt();
                        //收款账户商编  填写splitBillRules时候不填写MerchantNo，Amount并且即使填写这两个参数不生效！！
//                    accountPayOrderExt.setInMerchantNo(splitMoneyVo.getName());
                        accountPayOrderExt.setOrderType(AccountPayOrderType.TRANSFER);
//                    accountPayOrderExt.setAmount(splitMoneyVo.getSplitMoney());
                        accountPayOrderExt.setServerCallbackUrl(Constant.prodSplit);
                        accountPayOrderExt.setGoodsName("分账");
                        if (null != splitBillRules && splitBillRules.size() > 0) {
                            accountPayOrderExt.setSplitBillRules(splitBillRules);
                        }
                        String ext = JSON.toJSONString(accountPayOrderExt);
                        logger.info("分账规则串json串：" + ext);
                        accountPayOrder.setP6_ext(ext);
                        // 生成签名
                        StringBuilder builder = new StringBuilder();
                        builder.append(Constant.SPLIT)
                                .append(accountPayOrder.getP1_bizType()).append(Constant.SPLIT)
                                .append(accountPayOrder.getP2_signType()).append(Constant.SPLIT)
                                .append(accountPayOrder.getP3_timestamp()).append(Constant.SPLIT)
                                .append(accountPayOrder.getP4_orderId()).append(Constant.SPLIT)
                                .append(accountPayOrder.getP5_customerNumber()).append(Constant.SPLIT)
                                .append(accountPayOrder.getP6_ext()).append(Constant.SPLIT)
                                .append(Constant.XUNI);
                        String sign = Disguiser.disguiseMD5(builder.toString().trim());
                        Map<String, String> bean = convertBean(accountPayOrder);
                        logger.info("--------------------> 发送分账参数：  " + bean);
                        Map<String, String> map = postForm(bean, Constant.FZ, sign, Map.class);
                        logger.info("----------------分账返回数据: " + map.toString());
                        if (map != null) {
                            String code = map.get("rt5_retCode");
                            if (!"0000".equals(code)) {
                                String msg = map.get("rt6_retMsg");
                                logger.info("【手动分账】>>>>>>>>>>手动分账失败>>>>>>>msg:" + msg);
                            } else {
                                for (SplitAccountPo splitAccount : splitBillDetail) {
                                    splitAccount.setMbOrderId(orderRelation.getMbOrderId());
                                    splitAccount.setOrderRequestNo(orderRelation.getOrderRequestNo());
                                    splitAccount.setPayStatus(1);
                                    // 保存分账详情
                                    newOrderDao.insertSplitAccount(splitAccount);
                                }
                                redisService.remove("XSFZMDS");
                                logger.info("【手动分账】>>>>>>>>>>此订单分账结束");
                            }
                        }
                    } catch (Exception e) {
                        logger.error("【手动分账】>>>>>>>>>>错误信息", e);
                    }
                } else {
                    // 没有佣金分账，全是成本，本笔交易已分帐
                    newOrderDao.updateBySplitStatus(orderRelation.getMbOrderId());
                    //没有佣金分账也解锁
                    redisService.remove("XSFZMDS");
                }
            }
        }
    }


    public List<SplitAccountPo> setSplitAccountDetail(ShopOrderVo shopOrder, PayParamBo payParam) {
        List<SplitAccountPo> list = new ArrayList<>();
        // 本次支付金额,单位/元
        double payAmount = payParam.getAllPay();
        // 待分账总金额
        double splitAmount = payAmount;
        // 总手续费
        double procedureFee;
        if ("UNIONPAY".equals(payParam.getPayWay())) {
            procedureFee = 10.00;
        } else if ("B2C".equals(payParam.getPayWay())) {
            //b2c 0.2%
            procedureFee = MathUtil.mul(payAmount, 0.002, 2).doubleValue();
            //b2c最低手续费0.1
            if (procedureFee < 0.1) {
                procedureFee = 0.1;
            }
        } else if ("WX".equals(payParam.getPayWay())) {
            //微信0.65%
            procedureFee = MathUtil.mul(payAmount, 0.0065, 2).doubleValue();
        } else if ("DEBIT".equals(payParam.getPayWay())) {
            procedureFee = MathUtil.mul(payAmount, 0.003, 2).doubleValue();
            if (procedureFee < 0.1) {
                procedureFee = 0.1;
            }
        } else if ("CREDIT".equals(payParam.getPayWay())) {
            procedureFee = MathUtil.mul(payAmount, 0.006, 2).doubleValue();
            if (procedureFee < 0.1) {
                procedureFee = 0.1;
            }
        } else {
            //手续费 其他0.25%
            procedureFee = MathUtil.mul(payAmount, 0.0025, 2).doubleValue();
        }
        if (MathUtil.compare(procedureFee, 0.01) <= 0) {
            procedureFee = 0.01;
        }
        //手续费承担方 线上支付手续费：默认1采美承担，2供应商承担
        Integer supportFlag = newOrderDao.findSupport(shopOrder.getShopOrderId());
        //减去收款手续费
        splitAmount = MathUtil.sub(splitAmount, procedureFee).doubleValue();

        // 商品数据
        List<OrderProductVo> orderProductList = newOrderDao.getOrderProductByShopOrderId(shopOrder.getShopOrderId());

        for (OrderProductVo orderProduct : orderProductList) {
            //成本价*数量
            double costPrice = MathUtil.mul(orderProduct.getCostPrice(), orderProduct.getNum()).doubleValue();
            if (2 == supportFlag) {
                //供应商自己承担手续费
                costPrice = MathUtil.sub(costPrice, procedureFee).doubleValue();
            }
            // 不含税能开发票
            if (Integer.valueOf(0).equals(orderProduct.getIncludedTax()) && !Integer.valueOf(3).equals(orderProduct.getInvoiceType())) {
                //应付总税费
                Double payableTax = MathUtil.mul(orderProduct.getSingleShouldPayTotalTax(), orderProduct.getNum()).doubleValue();
                //成本+税费
                costPrice = MathUtil.add(costPrice, payableTax).doubleValue();
            }
            // 判断是否支付过
            Double paidAmount = newOrderDao.getOrderProductPaidAmount(orderProduct.getOrderProductId());
            // 支付过金额大于0
            //有已付
            if (null != paidAmount && MathUtil.compare(paidAmount, 0) > 0) {
                //已付>0，成本-已付
                costPrice = MathUtil.sub(costPrice, paidAmount).doubleValue();
            }
            // 待分账金额>成本
            if (MathUtil.compare(splitAmount, costPrice) > 0) {
                // 待分账金额-成本
                splitAmount = MathUtil.sub(splitAmount, costPrice).doubleValue();
            } else {
                costPrice = splitAmount;
                splitAmount = 0.00;
            }
            if (costPrice > 0) {
                SplitAccountPo splitAccount = new SplitAccountPo();
                splitAccount.setShopOrderId(shopOrder.getShopOrderId());
                splitAccount.setOrderId(shopOrder.getOrderId());
                splitAccount.setOrderProductId(orderProduct.getOrderProductId());
                splitAccount.setShopId(orderProduct.getShopId());
                splitAccount.setSplitAccount(costPrice);
                splitAccount.setProductType(1);
                // 该商品设置了商户号
                splitAccount.setType(4);
                splitAccount.setSubUserNo(shopOrder.getSplitCode());
                logger.info("成本分账参数------------->" + splitAccount.toString());
                list.add(splitAccount);
            }
            if (MathUtil.compare(splitAmount, 0) == 0) {
                break;
            }
        }
        // 还有钱就付供应商运费
        // 付供应商运费,是以供应商为单位的
        if (MathUtil.compare(splitAmount, 0) > 0) {
            // 运费
            Double shopPostFee = shopOrder.getShopPostFee();
            if (MathUtil.compare(shopPostFee, 0) > 0) {
                // 查询已支付运费
                Double shipping = newOrderDao.getPaidShipping(shopOrder.getOrderId(), shopOrder.getShopId());
                shopPostFee = MathUtil.sub(shopPostFee, shipping).doubleValue();
                if (MathUtil.compare(splitAmount, shopPostFee) > -1) {
                    splitAmount = MathUtil.sub(splitAmount, shopPostFee).doubleValue();
                } else {
                    shopPostFee = splitAmount;
                    splitAmount = 0.00;
                }
                SplitAccountPo splitAccount = new SplitAccountPo();
                splitAccount.setOrderId(shopOrder.getOrderId());
                splitAccount.setShopId(shopOrder.getShopId());
                splitAccount.setSplitAccount(shopPostFee);
                splitAccount.setProductType(2);
                //供应商拥有子商户号
                splitAccount.setType(4);
                splitAccount.setSubUserNo(shopOrder.getSplitCode());
                logger.info("付供应商运费分账参数------------->" + splitAccount);
                list.add(splitAccount);
            }
        }
        // 如果还有钱则为佣金,分到信息
        if (MathUtil.compare(splitAmount, 0) > 0) {
            //分账手续费0.1%采美承担,佣金扣除0.1%
            Double amount = Math.max(MathUtil.mul(splitAmount, 0.001, 2).doubleValue(), 0.01);
            splitAmount = MathUtil.sub(splitAmount, amount).doubleValue();
            SplitAccountPo splitAccount = new SplitAccountPo();
            splitAccount.setOrderId(shopOrder.getOrderId());
            splitAccount.setShopOrderId(shopOrder.getShopOrderId());
            splitAccount.setSplitAccount(splitAmount);
            splitAccount.setProductType(3);
            splitAccount.setType(5);
            splitAccount.setSubUserNo(Constant.CUSTOMERNUM2);
            logger.info("佣金分账参数------------->" + splitAccount);
            list.add(splitAccount);
        }
        return list;
    }

    public <T> T postForm(Map<String, String> params, String url, String sign, Class<T> clazz) {
        FormBody.Builder builder = new FormBody.Builder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            builder.add(entry.getKey(), entry.getValue());
        }
        builder.add("sign", sign);

        Request request = new Request.Builder() // okHttp post
                .url(url)
                .post(builder.build())
                .build();

        Response response = null;
        try {
            response = client.newCall(request).execute();
        } catch (IOException e) {
            throw new IllegalStateException("请求出错", e);
        }
        if (!response.isSuccessful()) {
            try {
                logger.info(response.body().string());
            } catch (IOException e) {
                e.printStackTrace();
            }
            throw new RuntimeException("请求失败了: http response code: " + response.code());
        }

        ResponseBody body = response.body();
        String content = null;
        try {
            content = body.string();
        } catch (IOException e) {
            throw new IllegalStateException("IO异常", e);
        }
        JSONObject res = JSON.parseObject(content);
        if (!res.getBooleanValue("rt4_success")) {
            logger.error("error: " + res.getString("rt6_retMsg"));
        }
        /** rt4_success 为 true，需验签  **/
        return res.toJavaObject(clazz);
    }

    public Map<String, String> convertBean(Object bean) {
        Class clazz = bean.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field f : fields) {
            f.setAccessible(true);
        }
        try {
            Map<String, String> retMap = new LinkedHashMap<>();
            for (Field f : fields) {
                String key = f.toString().substring(f.toString().lastIndexOf(".") + 1);
                Object value = f.get(bean);
                if (value == null) {
                    value = "";
                }
                retMap.put(key, (String) value);
            }
            return retMap;
        } catch (Exception e) {
            logger.info("分账", e);
            throw new IllegalStateException("分账异常", e);
        }
    }
}

//    //正式
////    public static final String callUrl = "https://core.caimei365.com/order/pay/delay/split/callback";
//    //测试
//    public static final String callUrl = "https://core-b.caimei365.com/order/pay/delay/split/callback";

//    @Transactional(readOnly = false)
//    public void SplitAccount() {
//        logger.info("【手动分账开始】>>>>>>>>>>手动分账");
//        Calendar calendar = Calendar.getInstance();
//        calendar.setTime(new Date());
//        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        String currentTime = format.format(calendar.getTime());
//        // 查询未分账已支付收款
//        List<OrderReceiptRelationPo> orderRelations = newOrderDao.getUndividedPaidReceipt(currentTime);
//        if (null != orderRelations && orderRelations.size() > 0) {
//            for (OrderReceiptRelationPo orderRelation : orderRelations) {
//                logger.info("【手动分账】>>>>>>>>>>订单id:" + orderRelation.getOrderId() + ",进入手动分账");
//                // 收款对应的订单信息
//                OrderVo order = newOrderDao.getOrderByOrderId(orderRelation.getOrderId());
//                PayParamBo payParam = new PayParamBo();
//                payParam.setPayAmount(MathUtil.mul(orderRelation.getAssociateAmount(), 100).intValue());
//                if (12 == orderRelation.getPayType()) {
//                    // 网银支付
//                    payParam.setPayWay("UNIONPAY");
//                }
//                if (20 == orderRelation.getPayType()) {
//                    payParam.setPayWay("TRANSFER");
//                }
//                List<SplitAccountPo> splitBillDetail = setSplitAccountDetail(order, payParam);
//                List<Map<String, String>> maps = new ArrayList<>();
//                //供应商子商户金额
//                for (SplitAccountPo account : splitBillDetail) {
//                    if (null != account.getType() && 4 == account.getType()) {
//                        //每个有供应商子商户的分账给对应供应商子商户
//                        addMaps(maps, account.getSplitAccount(), account.getSubUserNo());
//                    }
//                }
//                //公账-专票总金额,私账-无票总金额,公账-普票总金额
//                //佣金进网络
//                double totalAmount1 = 0.00;
//                double totalAmount2 = 0.00;
//                double totalAmount3 = 0.00;
//                double totalAmount4 = 0.00;
//                for (SplitAccountPo account : splitBillDetail) {
//                    if (1 == account.getType()) {
//                        totalAmount1 = MathUtil.add(totalAmount1, account.getSplitAccount()).doubleValue();
//                    } else if (2 == account.getType()) {
//                        totalAmount2 = MathUtil.add(totalAmount2, account.getSplitAccount()).doubleValue();
//                    } else if (3 == account.getType()) {
//                        totalAmount3 = MathUtil.add(totalAmount3, account.getSplitAccount()).doubleValue();
//                    } else if (5 == account.getType()) {
//                        totalAmount4 = MathUtil.add(totalAmount4, account.getSplitAccount()).doubleValue();
//                    }
//                }
//                addMaps(maps, totalAmount1, PayUtil.publicAccountNo);
//                addMaps(maps, totalAmount2, PayUtil.privateAccountNo);
//                addMaps(maps, totalAmount3, PayUtil.commonInvoiceNo);
//                // 网络
//                addMaps(maps, totalAmount4, PayUtil.brokerage);
////                addMaps(maps, totalAmount4, PayUtil.publicAccountNo);
//                String parameters = JSON.toJSONString(maps);
//                logger.info("【手动分账】>>>>>>>>>>分账参数: " + parameters);
//
//                //第三方分账接口
//                JSONObject result = null;
//                try {
//                    // 时间戳
//                    long time = System.currentTimeMillis() / 1000;
//                    JSONObject json = new JSONObject();
//                    json.put("merAccount", PayUtil.merAccount);
//                    json.put("orderId", orderRelation.getOrderRequestNo());
//                    json.put("requestNo", orderRelation.getOrderRequestNo());
//                    json.put("mbOrderId", orderRelation.getMbOrderId());
//                    json.put("time", time);
//                    json.put("splitBillDetail", parameters);
//                    json.put("notifyUrl", callUrl);
//                    logger.info("回调接口>>>" + callUrl);
//                    String sign = PayUtil.getPaySign(json, PayUtil.merKey);
//                    json.put("sign", sign);
//                    logger.info("发送参数json----->" + json);
//                    String data = PayUtil.privateKeyEncrypt(json, PayUtil.merKey);
//                    result = PayUtil.httpGet("https://platform.mhxxkj.com/paygateway/mbpay/splitOrder/v1", PayUtil.merAccount, data);
//                } catch (Exception e) {
//                    logger.error("【手动分账】>>>>>>>>>>错误信息", e);
//                }
//                if (result != null) {
//                    String code = result.getString("code");
//                    if (!"000000".equals(code)) {
//                        String msg = result.getString("msg");
//                        logger.info("【手动分账】>>>>>>>>>>第三方延迟分账失败>>>>>>>msg:" + msg);
//                    } else {
//                        for (SplitAccountPo splitAccount : splitBillDetail) {
//                            splitAccount.setMbOrderId(orderRelation.getMbOrderId());
//                            splitAccount.setOrderRequestNo(orderRelation.getOrderRequestNo());
//                            splitAccount.setPayStatus(1);
//                            // 保存分账详情
//                            newOrderDao.insertSplitAccount(splitAccount);
//                            redisService.remove("XSFZMDS");
//                        }
//                        logger.info("【手动分账】>>>>>>>>>>此订单分账结束");
//                    }
//                }
//            }
//        }
//    }
//
//
//    /**
//     * 分账参数添加
//     */
//    private void addMaps(List<Map<String, String>> maps, Double shopTotalAmount, String subUserNo) {
//        if (MathUtil.compare(shopTotalAmount, 0) > 0) {
//            Map<String, String> map = new HashMap<>(3);
//            map.put("subUserNo", subUserNo);
//            map.put("splitBillType", "2");
//            map.put("splitBillValue", MathUtil.mul(shopTotalAmount, 100).toString());
//            maps.add(map);
//        }
//    }
//
//    /**
//     * 分账详情
//     */
//    private List<SplitAccountPo> setSplitAccountDetail(OrderVo order, PayParamBo payParam) {
//        List<SplitAccountPo> list = new ArrayList<>();
//        // 本次支付金额,单位/元
//        double payAmount = MathUtil.div(payParam.getPayAmount(), 100).doubleValue();
//        // 待分账总金额
//        double splitAmount = payAmount;
//        // 总手续费
//        double procedureFee;
//        if ("UNIONPAY".equals(payParam.getPayWay())) {
//            procedureFee = 8.00;
//        } else {
//            //手续费
//            procedureFee = MathUtil.mul(payAmount, 0.0038, 2).doubleValue();
//            if (MathUtil.compare(procedureFee, 0) == 0) {
//                procedureFee = 0.01;
//            }
//        }
//        splitAmount = MathUtil.sub(splitAmount, procedureFee).doubleValue();
//        // 商品数据
//        List<OrderProductVo> orderProductList = newOrderDao.getOrderProductByOrderId(order.getOrderId());
//        for (OrderProductVo orderProduct : orderProductList) {
//            double costPrice = MathUtil.mul(orderProduct.getCostPrice(), orderProduct.getNum()).doubleValue();
//            // 不含税能开发票
//            if (Integer.valueOf(0).equals(orderProduct.getIncludedTax()) && !Integer.valueOf(3).equals(orderProduct.getInvoiceType())) {
//                //应付总税费
//                Double payableTax = MathUtil.mul(orderProduct.getSingleShouldPayTotalTax(), orderProduct.getNum()).doubleValue();
//                costPrice = MathUtil.add(costPrice, payableTax).doubleValue();
//            }
//            // 判断是否支付过
//            Double paidAmount = newOrderDao.getOrderProductPaidAmount(orderProduct.getOrderProductId());
//            //有已付
//            if (null != paidAmount  && MathUtil.compare(paidAmount, 0) > 0) {
//                //已付>0，成本-已付
//                costPrice = MathUtil.sub(costPrice, paidAmount).doubleValue();
//            }
//            // 待分账金额>成本
//            if (MathUtil.compare(splitAmount, costPrice) > 0) {
//                // 待分账金额-成本
//                splitAmount = MathUtil.sub(splitAmount, costPrice).doubleValue();
//            } else {
//                costPrice = splitAmount;
//                splitAmount = 0.00;
//            }
//            if (costPrice > 0) {
//                SplitAccountPo splitAccount = new SplitAccountPo();
//                splitAccount.setOrderId(order.getOrderId());
//                splitAccount.setOrderProductId(orderProduct.getOrderProductId());
//                splitAccount.setShopId(orderProduct.getShopId());
//                splitAccount.setSplitAccount(costPrice);
//                splitAccount.setProductType(1);
//                if (StringUtils.isNotBlank(orderProduct.getSplitCode())) {
//                    // 该商品设置了商户号
//                    splitAccount.setType(4);
//                    splitAccount.setSubUserNo(orderProduct.getSplitCode());
//                }
//                logger.info("成本分账参数------------->" + splitAccount.toString());
//                list.add(splitAccount);
//            }
//            if (MathUtil.compare(splitAmount, 0) == 0) {
//                break;
//            }
//        }
//        // 付供应商运费,是以供应商为单位的
//        if (MathUtil.compare(splitAmount, 0) > 0) {
//            List<ShopOrderVo> shopOrderList = newOrderDao.getShopOrderListByOrderId(order.getOrderId());
//            for (ShopOrderVo shopOrder : shopOrderList) {
//                // 运费
//                Double shopPostFee = shopOrder.getShopPostFee();
//                if (MathUtil.compare(shopPostFee, 0) > 0) {
//                    // 查询已支付运费
//                    Double shipping = newOrderDao.getPaidShipping(order.getOrderId(), shopOrder.getShopId());
//                    shopPostFee = MathUtil.sub(shopPostFee, shipping).doubleValue();
//                    if (MathUtil.compare(splitAmount, shopPostFee) > -1) {
//                        splitAmount = MathUtil.sub(splitAmount, shopPostFee).doubleValue();
//                    } else {
//                        shopPostFee = splitAmount;
//                        splitAmount = 0.00;
//                    }
//                    String commercialCode = newOrderDao.getShopCommercialCode(shopOrder.getShopId());
//                    SplitAccountPo splitAccount = new SplitAccountPo();
//                    splitAccount.setOrderId(order.getOrderId());
//                    splitAccount.setShopId(shopOrder.getShopId());
//                    splitAccount.setSplitAccount(shopPostFee);
//                    splitAccount.setProductType(2);
//                    if (StringUtils.isNotBlank(commercialCode)) {
//                        //供应商拥有子商户号
//                        splitAccount.setType(4);
//                        splitAccount.setSubUserNo(commercialCode);
//                    }
//                    logger.info("付供应商运费分账参数------------->" + splitAccount);
//                    list.add(splitAccount);
//                }
//            }
//        }
//        //佣金,公账
//        if (MathUtil.compare(splitAmount, 0) > 0) {
//            SplitAccountPo splitAccount = new SplitAccountPo();
//            splitAccount.setOrderId(order.getOrderId());
//            splitAccount.setSplitAccount(splitAmount);
//            splitAccount.setProductType(3);
//            splitAccount.setType(5);
//            //佣金进采美网络
//            splitAccount.setSubUserNo(PayUtil.brokerage);
//            logger.info("佣金分账参数------------->" + splitAccount);
//            list.add(splitAccount);
//        }
//        return list;
//    }