DAL-DAZHOU-BMSTRUCK-API/src/main/java/com/steerinfo/dil/service/impl/BmstruckDetailsOrderServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.AmsFeign;
import com.steerinfo.dil.feign.JoinApiFeign;
import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.mapper.AmsContractTransportPriceMapper;
import com.steerinfo.dil.mapper.BmstruckDetailsOrderMapper;
import com.steerinfo.dil.mapper.OmstruckOrderMapper;
import com.steerinfo.dil.model.AmsContractTransportPrice;
import com.steerinfo.dil.model.BmstruckDetailsOrder;
import com.steerinfo.dil.model.OmstruckOrder;
import com.steerinfo.dil.service.IBmstruckDetailsOrderService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.util.EASUtil;
import com.steerinfo.dil.util.NoUtil;
import com.steerinfo.dil.util.SaleLogUtil;
import io.swagger.models.auth.In;
import org.apache.shiro.crypto.hash.Hash;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Description:
 * @Author:HuJianGuo
 * @GreateTime:2021/9/24 17:34
 * @Version:V2.0
 */
@Service
public class BmstruckDetailsOrderServiceImpl implements IBmstruckDetailsOrderService {

    @Autowired
    BmstruckDetailsOrderMapper bmstruckDetailsOrderMapper;
    @Autowired
    BmstruckFormulaServiceImpl bmstruckFormulaService;
    @Autowired
    NoUtil noUtil;
    @Autowired
    JoinApiFeign joinApiFeign;
    @Autowired
    EASUtil easUtil;
    @Autowired
    OmstruckOrderMapper omstruckOrderMapper;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    AmsFeign amsFeign;

    @Autowired
    SaleLogUtil saleLogUtil;

    @Autowired
    AmsContractTransportPriceMapper amsContractTransportPriceMapper;

    //以下订单类型是需要算计量实绩的
    final private List<Integer>  inwardTypeList = Arrays.asList(10,11,15,16,23,24,20,25);
    //以下订单类型是需要根据线路去匹配承运起止范围以及物资
    final private List<Integer>  toLineAndMaterial = Arrays.asList(10,20,23,24);
    //以下订单类型是需要去根据固定承运起止范围以及物资
    final private List<Integer>  fixLineList = Arrays.asList(15,16);
    //以下订单类型是钢材
    final private List<Integer> steelTypeList = Arrays.asList(25);

    /**
     * 展示汽运详单列表
     * @param mapVal
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckDetailsOrderList(Map<String, Object> mapVal) {
        Integer orderType = (Integer) mapVal.get("orderType");
        List<Map<String, Object>> truckDetailsOrderList;
        if (orderType <= 3 && orderType >= 1) {
            truckDetailsOrderList = bmstruckDetailsOrderMapper.getSaleTruckDetailsOrderList(mapVal);
        }
        else {
            truckDetailsOrderList = bmstruckDetailsOrderMapper.getTruckDetailsOrderList(mapVal);
        }
        return truckDetailsOrderList;
    }

    /**
     * 新增详单
     * @param orderId
     * @return
     */
    @Override
    public synchronized int insertSelective(BigDecimal orderId) throws Exception {
        System.out.println(orderId + "生成计费详单");
        List<Map<String,Object>> weightTaskResultIdList = bmstruckDetailsOrderMapper.getSteelWeightTaskResultId(orderId);
        //根据该id寻找相同的订单号
        List<BigDecimal> orderIds = bmstruckDetailsOrderMapper.getOrderIds(orderId);
        for (BigDecimal orderId1 : orderIds) {
            weightTaskResultIdList.addAll(bmstruckDetailsOrderMapper.getSteelWeightTaskResultId(orderId1));
        }
        Map<String,Object> priceMap = getPriceId(orderId);
        if (priceMap == null || priceMap.size() == 0) {
            return 0;
        }
        BigDecimal priceId = (BigDecimal) priceMap.get("priceId");
        if (priceId.intValue() == 0) {
            return 0;
        }
        int result = 0;
        //优先根据计量批次新增详单
        List<Map<String,Object>> batchIdList = bmstruckDetailsOrderMapper.getWeightBatchIds(orderId);
        if(batchIdList.size()>0){
            for(Map<String, Object> map : batchIdList){
                if(map == null) {
                    System.out.println("空Map,释放");
                    continue;
                }
                BigDecimal weightBatchId = DataChange.dataToBigDecimal(map.get("weightBatchId"));
                //判断该批次有没有结算数据
                if(bmstruckDetailsOrderMapper.getIsHaveDetailsOrderByBatch(weightBatchId) > 0 ){
                    continue;
                }
                try {
                    BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
                    BigDecimal priceValue = getPriceValue(priceId);
                    BigDecimal netWeight = DataChange.dataToBigDecimal(map.get("netWeight"));
                    // 得到计费公式
                    String formula_string = null;
                    if (orderType.intValue() == 3) {
                        // 得到采购汽运计费公式
                        formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(8));
                        // 替换采购汽运运计算公式
                        formula_string = formula_string.replace("到厂计量湿吨",netWeight.toString())
                                .replace("单价",priceValue.toString());
                    }
                    if (orderType.intValue() >= 1 && orderType.intValue() <= 3) {
                        // 得到销售10km差距内的汽运计费公式
                        formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
                        // 替换采购汽运运计算公式
                        formula_string = formula_string.replace("运输单价",priceValue.toString())
                                .replace("物资净重",netWeight.toString());
                    }
                    String s = toSufExpr(formula_string);
                    BigDecimal  detailsAmountOld = calSufExpr(s);
                    Double amount = detailsAmountOld.doubleValue();
                    BigDecimal detailsAmount = new BigDecimal(amount).setScale(2,RoundingMode.HALF_UP);
                    BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
                    if (orderType.intValue() == 3) {
                        BigDecimal purchaseOrderId = getFormulaMembers(orderId);
                        bmstruckDetailsOrder.setPurchaseOrderId(purchaseOrderId);
                    }
                    if (orderType.intValue() == 2 || orderType.intValue() == 1) {
                        bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
                    }
                    // 得到最大id
                    BigDecimal detailsId = selectMaxId();
                    String detailsNo = noUtil.setResultNo("QYXD", detailsId);
                    bmstruckDetailsOrder.setDetailsId(detailsId);
                    bmstruckDetailsOrder.setWeightBatchId(weightBatchId);
                    bmstruckDetailsOrder.setOrderId(orderId);
                    bmstruckDetailsOrder.setDetailsNo(detailsNo);
                    bmstruckDetailsOrder.setPriceId(priceId);
                    bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
                    bmstruckDetailsOrder.setDetailsTime(new Date());
                    // 设置常规字段
                    bmstruckDetailsOrder.setInsertTime(new Date());
                    bmstruckDetailsOrder.setUpdateTime(new Date());
                    bmstruckDetailsOrder.setInsertUsername("admin");
                    bmstruckDetailsOrder.setUpdateUsername("admin");
                    bmstruckDetailsOrder.setInsertUpdateRemark("无");
                    result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
                }catch (Exception e){
                    //不打印给控制台（有可能是正常情况）
                    e.printStackTrace();
                }
            }
            return result;
        }
        //根据计量实绩新增详单
        for (Map<String, Object> map : weightTaskResultIdList) {
            if(map == null) {
                System.out.println("空Map,释放");
                continue;
            }
            BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
            if(weightTaskResultId == null) {
                System.out.println("计量实绩Id为空,释放");
                continue;
            }
            //判断该计量实绩有没有结算数据
            if(bmstruckDetailsOrderMapper.getIsHaveDetailsOrder(weightTaskResultId) > 0 ){
                continue;
            }
            BigDecimal netWeightIsNull = bmstruckDetailsOrderMapper.getNetWeight(weightTaskResultId);
            if (netWeightIsNull == null) {
                System.out.println("没有计量实绩,不生成结算数据:" + orderId);
                continue;
            }
            //BigDecimal detailsAmountOld=new BigDecimal(0);
            try {
                BigDecimal  detailsAmountOld = generateTruckFees(orderId, weightTaskResultId);
                Double amount = detailsAmountOld.doubleValue();
                BigDecimal detailsAmount = new BigDecimal(amount).setScale(2,RoundingMode.HALF_UP);
                BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
                BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
                if (orderType.intValue() == 3) {
                    BigDecimal purchaseOrderId = getFormulaMembers(orderId);
                    bmstruckDetailsOrder.setPurchaseOrderId(purchaseOrderId);
                }
                if (orderType.intValue() == 2 || orderType.intValue() == 1) {
                    bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
                }
                // 得到最大id
                BigDecimal detailsId = selectMaxId();
                String detailsNo = noUtil.setResultNo("QYXD", detailsId);
                bmstruckDetailsOrder.setDetailsId(detailsId);
                bmstruckDetailsOrder.setWeightTaskResultId(weightTaskResultId);
                bmstruckDetailsOrder.setOrderId(orderId);
                bmstruckDetailsOrder.setDetailsNo(detailsNo);
                bmstruckDetailsOrder.setPriceId(priceId);
                bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
                bmstruckDetailsOrder.setDetailsTime(new Date());
                // 设置常规字段
                bmstruckDetailsOrder.setInsertTime(new Date());
                bmstruckDetailsOrder.setUpdateTime(new Date());
                bmstruckDetailsOrder.setInsertUsername("admin");
                bmstruckDetailsOrder.setUpdateUsername("admin");
                bmstruckDetailsOrder.setInsertUpdateRemark("无");
                result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
            }catch (Exception e){
                //不打印给控制台（有可能是正常情况）
                e.printStackTrace();
            }
        }
        return result;
    }


    /**
     * 新增详单(只为计费详单修改数据时才使用)
     * @param orderId
     * @return
     */
    @Override
    public synchronized int insertSelectiveNew(BigDecimal orderId,BigDecimal priceId) throws Exception {
        List<Map<String,Object>> weightTaskResultIdList = bmstruckDetailsOrderMapper.getSteelWeightTaskResultId(orderId);
        System.out.println("根据运单查询到的计量实绩数据为," + weightTaskResultIdList);
        if(priceId == null) {
            return 0;
        }
        if (priceId.intValue() == 0) {
            return 0;
        }
        int result = 0;
        //优先根据计量批次新增详单
        List<Map<String,Object>> batchIdList = bmstruckDetailsOrderMapper.getWeightBatchIds(orderId);
        if(batchIdList.size()>0){
            for(Map<String, Object> map : batchIdList){
                if(map == null) {
                    System.out.println("空Map,释放");
                    continue;
                }
                BigDecimal weightBatchId = DataChange.dataToBigDecimal(map.get("weightBatchId"));
                //判断该批次有没有结算数据
                if(bmstruckDetailsOrderMapper.getIsHaveDetailsOrderByBatch(weightBatchId) > 0 ){
                    continue;
                }
                try {
                    BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
                    BigDecimal priceValue = getPriceValue(priceId);
                    BigDecimal netWeight = DataChange.dataToBigDecimal(map.get("netWeight"));
                    // 得到计费公式
                    String formula_string = null;
                    if (orderType.intValue() == 3) {
                        // 得到采购汽运计费公式
                        formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(8));
                        // 替换采购汽运运计算公式
                        formula_string = formula_string.replace("到厂计量湿吨",netWeight.toString())
                                .replace("单价",priceValue.toString());
                    }
                    if (orderType.intValue() >= 1 && orderType.intValue() <= 3) {
                        // 得到销售10km差距内的汽运计费公式
                        formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
                        // 替换采购汽运运计算公式
                        formula_string = formula_string.replace("运输单价",priceValue.toString())
                                .replace("物资净重",netWeight.toString());
                    }
                    String s = toSufExpr(formula_string);
                    BigDecimal  detailsAmountOld = calSufExpr(s);
                    Double amount = detailsAmountOld.doubleValue();
                    BigDecimal detailsAmount = new BigDecimal(amount).setScale(2,RoundingMode.HALF_UP);
                    BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
                    if (orderType.intValue() == 3) {
                        BigDecimal purchaseOrderId = getFormulaMembers(orderId);
                        bmstruckDetailsOrder.setPurchaseOrderId(purchaseOrderId);
                    }
                    if (orderType.intValue() == 2 || orderType.intValue() == 1) {
                        bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
                    }
                    // 得到最大id
                    BigDecimal detailsId = selectMaxId();
                    String detailsNo = noUtil.setResultNo("QYXD", detailsId);
                    bmstruckDetailsOrder.setDetailsId(detailsId);
                    bmstruckDetailsOrder.setWeightBatchId(weightBatchId);
                    bmstruckDetailsOrder.setOrderId(orderId);
                    bmstruckDetailsOrder.setDetailsNo(detailsNo);
                    bmstruckDetailsOrder.setPriceId(priceId);
                    bmstruckDetailsOrder.setPriceValue(priceValue);
                    bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
                    bmstruckDetailsOrder.setDetailsTime(new Date());
                    // 设置常规字段
                    bmstruckDetailsOrder.setInsertTime(new Date());
                    bmstruckDetailsOrder.setUpdateTime(new Date());
                    bmstruckDetailsOrder.setInsertUsername("admin");
                    bmstruckDetailsOrder.setUpdateUsername("admin");
                    bmstruckDetailsOrder.setInsertUpdateRemark("无");
                    result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
                }catch (Exception e){
                    //不打印给控制台（有可能是正常情况）
                    e.printStackTrace();
                }
            }
            return result;
        }
        for (Map<String, Object> map : weightTaskResultIdList) {
            if(map == null) {
                System.out.println("map为空");
                continue;
            }
            BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
            if (weightTaskResultId == null) {
                System.out.println("计量实绩Id为空");
                continue;
            }
            //判断该计量实绩有没有结算数据
            if(bmstruckDetailsOrderMapper.getIsHaveDetailsOrder(weightTaskResultId) > 0 ){
                continue;
            }
            BigDecimal netWeightIsNull = bmstruckDetailsOrderMapper.getNetWeight(weightTaskResultId);
            if (netWeightIsNull == null) {
                System.out.println("没有计量实绩,不生成结算数据:" + orderId);
                continue;
            }
            //BigDecimal detailsAmountOld=new BigDecimal(0);
            try {
                BigDecimal  detailsAmountOld = generateTruckFeesNew(orderId, weightTaskResultId);
                Double amount = detailsAmountOld.doubleValue();
                BigDecimal detailsAmount = new BigDecimal(amount).setScale(2,RoundingMode.HALF_UP);
                BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
                BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
                if (orderType.intValue() == 3) {
                    BigDecimal purchaseOrderId = getFormulaMembers(orderId);
                    bmstruckDetailsOrder.setPurchaseOrderId(purchaseOrderId);
                }
                if (orderType.intValue() == 2 || orderType.intValue() == 1) {
                    bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
                }
                // 得到最大id
                BigDecimal detailsId = selectMaxId();
                String detailsNo = noUtil.setResultNo("QYXD", detailsId);
                bmstruckDetailsOrder.setDetailsId(detailsId);
                bmstruckDetailsOrder.setWeightTaskResultId(weightTaskResultId);
                bmstruckDetailsOrder.setOrderId(orderId);
                bmstruckDetailsOrder.setDetailsNo(detailsNo);
                bmstruckDetailsOrder.setPriceId(priceId);
                bmstruckDetailsOrder.setPriceValue();
                bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
                bmstruckDetailsOrder.setDetailsTime(new Date());
                // 设置常规字段
                bmstruckDetailsOrder.setInsertTime(new Date());
                bmstruckDetailsOrder.setUpdateTime(new Date());
                bmstruckDetailsOrder.setInsertUsername("admin");
                bmstruckDetailsOrder.setUpdateUsername("admin");
                bmstruckDetailsOrder.setInsertUpdateRemark("无");
                result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
                System.out.println("订单生成了结算单据" + orderId);
            }catch (Exception e){
                //不打印给控制台（有可能是正常情况）
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 查询最大id
     * @return
     */
    @Override
    public BigDecimal selectMaxId() {
        return  bmstruckDetailsOrderMapper.selectDetailsId();
    }

    /**
     * 展示汽运实绩列表
     * @param mapVal
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckResultList(Map<String, Object> mapVal) {
        BigDecimal orderId = (BigDecimal) mapVal.get("orderId") ;
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        List<Map<String,Object>> mapList;
        if (orderType.intValue() <= 3 && orderType.intValue() >= 1) {
            mapList = bmstruckDetailsOrderMapper.getSaleTruckResultList(mapVal);
        }
        else {
            mapList = bmstruckDetailsOrderMapper.getTruckResultList(mapVal);
        }
        return mapList;
    }

    /**
     * 得到计算因子
     * @param orderId
     * @return
     */
    @Override
    public BigDecimal getFormulaMembers(BigDecimal orderId) {
        return bmstruckDetailsOrderMapper.getFormulaMembers(orderId);
    }

    /**
     * 得到价格id
     * @return
     */
    @Override
    public Map<String, Object> getPriceId(BigDecimal orderId) {
        return bmstruckDetailsOrderMapper.getPriceId(orderId);
    }

    /**
     * 得到单价
     * @param priceId
     * @return
     */
    @Override
    public BigDecimal getPriceValue(BigDecimal priceId) {
        return bmstruckDetailsOrderMapper.getPriceValue(priceId);
    }

    /**
     * 得到到厂湿重
     * @param weightTaskResultId
     * @return
     */
    @Override
    public BigDecimal getNetWeight(BigDecimal weightTaskResultId) {
        return bmstruckDetailsOrderMapper.getNetWeight(weightTaskResultId);
    }

    /**
     * 展示未转成销售账单的销售详单
     * @param mapVal
     * @param orderType
     * @return
     */
    @Override
    public List<Map<String, Object>> getUnFinishedTruckDetailsOrderList(Map<String, Object> mapVal, Integer orderType) {
        if (mapVal == null) {
            mapVal = new HashMap<>();
        }
        mapVal.put("orderType",new BigDecimal(orderType));
        return bmstruckDetailsOrderMapper.getUnFinishedTruckDetailsOrderList(mapVal);
    }
    //通过不同的值，查询未生成账单的计费详单
    @Override
    public List<Map<String, Object>> getUnFinishedConvertedTruckDetailsOrderList(Map<String, Object> mapVal, Integer orderType) {
        //orderType:1:计时,2:计数，3：计重，4：包月
        if(orderType==1){
            return bmstruckDetailsOrderMapper.getUnFinishedTimeTruckDetailsOrderList(mapVal);
        }
        else if(orderType==2){
            return bmstruckDetailsOrderMapper.getUnFinishedNumTruckDetailsOrderList(mapVal);
        }
        else if(orderType==3){
            return bmstruckDetailsOrderMapper.getUnFinishedWeightTruckDetailsOrderList(mapVal);
        }
        else if(orderType==4){
            return bmstruckDetailsOrderMapper.getUnFinishedMonthTruckDetailsOrderList(mapVal);
        }
        return null;
    }



    /**
     * 替换汽运费公式并进行计算
     * @param orderId
     * @return
     * @throws Exception
     */
    public BigDecimal generateTruckFees(BigDecimal orderId,BigDecimal weightTaskResultId) throws Exception {
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        Map<String, Object> priceMap = getPriceId(orderId);
        BigDecimal priceId = (BigDecimal) priceMap.get("priceId");
        BigDecimal priceValue = getPriceValue(priceId);
        BigDecimal netWeight = getNetWeight(weightTaskResultId);
        //用于给单价id为2400的生成详单
//        if (priceValue==null||priceValue.compareTo(BigDecimal.ZERO)==0){
//            //该值为任意给的值
//            priceValue=BigDecimal.TEN;
//        }
        // 得到计费公式
        String formula_string = null;
        if (orderType.intValue() == 3) {
            // 得到采购汽运计费公式
            formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(8));
            // 替换采购汽运运计算公式
            formula_string = formula_string.replace("到厂计量湿吨",netWeight.toString())
                    .replace("单价",priceValue.toString());
        }
        if (orderType.intValue() >= 1 && orderType.intValue() <= 3) {
//            BigDecimal distance = new BigDecimal(101);
            // 得到销售汽运计费公式
//            if (distance.intValue() >= 91 || distance.intValue() <= 109) {
                // 得到销售10km差距内的汽运计费公式
                formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
                // 替换采购汽运运计算公式
                formula_string = formula_string.replace("运输单价",priceValue.toString())
                        .replace("物资净重",netWeight.toString());
//            }
//            else {
//                // 得到销售10km差距外的汽运计费公式
//                formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(11));
//                // 替换采购汽运运计算公式
//                formula_string = formula_string.replace("运输单价",priceValue.toString())
//                        .replace("运输距离",distance.toString())
//                        .replace("物资净重",netWeight.toString());
//            }
        }
        String s = toSufExpr(formula_string);
        return calSufExpr(s);
    }

    /**
     * 钢材直接修改计算运费
     * @param priceValue
     * @param weightTaskResultId
     * @return
     * @throws Exception
     */
    public BigDecimal generateTruckFeesForDirect(BigDecimal priceValue,BigDecimal weightTaskResultId) throws Exception {
        BigDecimal netWeight = getNetWeight(weightTaskResultId);
        // 得到计费公式
        String formula_string = null;
        formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
        // 替换采购汽运运计算公式
        formula_string = formula_string.replace("运输单价",priceValue.toString())
                .replace("物资净重",netWeight.toString());
        String s = toSufExpr(formula_string);
        return calSufExpr(s);
    }

    /**
     * 替换汽运费公式并进行计算(专为计费详单服务)
     * @param orderId
     * @return
     * @throws Exception
     */
    public BigDecimal generateTruckFeesNew (BigDecimal orderId,BigDecimal weightTaskResultId) throws Exception {
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        Map<String, Object> priceMap = getPriceId(orderId);
        BigDecimal priceId = (BigDecimal) priceMap.get("priceId");
        BigDecimal priceValue = getPriceValue(priceId);
        BigDecimal netWeight = getNetWeight(weightTaskResultId);
        //用于给单价id为2400的生成详单
        if (priceValue==null||priceValue.compareTo(BigDecimal.ZERO)==0){
            //该值为任意给的值
            priceValue=BigDecimal.TEN;
        }
        // 得到计费公式
        String formula_string = null;
        if (orderType.intValue() == 3) {
            // 得到采购汽运计费公式
            formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(8));
            // 替换采购汽运运计算公式
            formula_string = formula_string.replace("到厂计量湿吨",netWeight.toString())
                    .replace("单价",priceValue.toString());
        }
        if (orderType.intValue() >= 1 && orderType.intValue() <= 3) {
//            BigDecimal distance = new BigDecimal(101);
            // 得到销售汽运计费公式
//            if (distance.intValue() >= 91 || distance.intValue() <= 109) {
            // 得到销售10km差距内的汽运计费公式
            formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
            // 替换采购汽运运计算公式
            formula_string = formula_string.replace("运输单价",priceValue.toString())
                    .replace("物资净重",netWeight.toString());
//            }
//            else {
//                // 得到销售10km差距外的汽运计费公式
//                formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(11));
//                // 替换采购汽运运计算公式
//                formula_string = formula_string.replace("运输单价",priceValue.toString())
//                        .replace("运输距离",distance.toString())
//                        .replace("物资净重",netWeight.toString());
//            }
        }
        String s = toSufExpr(formula_string);
        return calSufExpr(s);
    }

    public BigDecimal updateSteelAmounts(Map<String,Object> map) throws Exception {
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
        BigDecimal weightBatchId = DataChange.dataToBigDecimal(map.get("weightBatchId"));
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        BigDecimal priceId = DataChange.dataToBigDecimal(map.get("priceId"));
        BigDecimal priceValue = getPriceValue(priceId);
        if(priceValue==null){
            //单价为Null，则返回0
            return new BigDecimal(0);
        }
        BigDecimal netWeight = null;
        if(weightBatchId != null && weightBatchId.intValue() != 0) {
            netWeight = getWeightBatchNetWeight(weightBatchId);
        }else{
            netWeight = getNetWeight(weightTaskResultId);
        }
        // 得到计费公式
        String formula_string = null;
        if (orderType.intValue() >= 1 && orderType.intValue() <= 3) {
//            BigDecimal distance = new BigDecimal(101);
            // 得到销售汽运计费公式
//            if (distance.intValue() >= 91 || distance.intValue() <= 109) {
            // 得到销售10km差距内的汽运计费公式
            formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
            // 替换采购汽运运计算公式
            formula_string = formula_string.replace("运输单价",priceValue.toString())
                    .replace("物资净重",netWeight.toString());
//            }
//            else {
//                // 得到销售10km差距外的汽运计费公式
//                formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(11));
//                // 替换采购汽运运计算公式
//                formula_string = formula_string.replace("运输单价",priceValue.toString())
//                        .replace("运输距离",distance.toString())
//                        .replace("物资净重",netWeight.toString());
//            }
        }
        String s = toSufExpr(formula_string);
        return calSufExpr(s);
    }

    private BigDecimal getWeightBatchNetWeight(BigDecimal weightBatchId) {
        return bmstruckDetailsOrderMapper.getWeightBatchNetWeight(weightBatchId);
    }


    /**
     * 中缀转换后缀表达式
     */
    public  String toSufExpr(String s) {
        StringBuffer sufExpr = new StringBuffer();
        Stack<String> stack = new Stack<>();
        //压入空方便判断
        stack.push(null);
        Pattern pattern = Pattern.compile("\\(int\\)|(?<!\\d|[)])-?\\d+(\\.\\d+)?|!=|>=|<=|==|[+\\-*/%()><=|]");
        Matcher matcher = pattern.matcher(s);
        while (matcher.find()) {
            String group = matcher.group();
            if (group.matches("!=|>=|<=|==|[+\\-*/%()><=|]|\\(int\\)")) {//是运算符
                if (group.equals("(")) {//之间压栈
                    stack.push(group);
                } else if (group.equals(")")) {//等于右括号，一直弹栈，直到遇到左括号
                    String pop = null;
                    while (!(pop = stack.pop()).equals("(")) {//遍历循环至左括号
                        sufExpr.append(pop + " ");
                    }
                } else {//是运算符：加减乘除强转，根据优先级压栈
                    while (getPriority(group) <= getPriority(stack.peek())) {
                        String pop = stack.pop();
                        System.out.println(pop);
                        System.out.println(sufExpr);
                        if(pop!=null&&!pop.equals("|")){
                            sufExpr.append(pop + " ");
                        }
                    }
                    stack.push(group);
                }
            } else {//是数字
                sufExpr.append(group + " ");
            }
        }
        String pop = null;
        while (null != (pop = stack.pop())) {
            sufExpr.append(pop + " ");
        }
        return sufExpr.toString();
    }

    /**
     * 设置出栈优先级，(：优先级最低，表示只有遇到)才能出栈
     * 当栈顶遇到优先级比自己小或等于的弹栈
     */
    public  Integer getPriority(String c) {
        if (c == null) {
            return 0;
        }
        switch (c) {
            case "(":
                return 1;
            case "+":
            case "-":
                return 2;
            case "*":
            case "/":
            case "%":
                return 3;
            case ">":
            case "<":
            case ">=":
            case "<=":
            case "!=":
            case "==":
                return 4;
            case "|":
                return 5;
            case "=":
                return 6;
            case "(int)":
                return 7;
        }
        return 0;
    }

    /**
     * 计算值
     */
    public  BigDecimal cal(BigDecimal a1, BigDecimal a2, String operator) throws Exception {
        switch (operator){
            case "+":return a1.add(a2);
            case "-":return a1.subtract(a2);
            case "*":return a1.multiply(a2);
            case "/":return a1.divide(a2,3,BigDecimal.ROUND_CEILING);
            case "%":return a1.divideAndRemainder(a2)[1];
            default:
                break;
        }
        throw new Exception("非法运算符");
    }

    public  Boolean calBoolean(BigDecimal a1, BigDecimal a2, String operator) throws Exception {
        switch (operator){
            case ">":return a1.compareTo(a2) == 1;
            case "<":return a1.compareTo(a2) == -1;
            case ">=":return a1.compareTo(a2) > -1;
            case "<=":return a1.compareTo(a2) < 1;
            case "!=":return a1.compareTo(a2) != 0;
            case "==":return a1.compareTo(a2) == 0;
            default:
                break;
        }
        throw new Exception("非法运算符");
    }

    /**
     * 计算后缀表达式
     */
    public  BigDecimal calSufExpr(String sufExpr) throws Exception {
        Stack<BigDecimal> stack = new Stack<>();
        Pattern pattern=Pattern.compile("\\(int\\)|-?\\d+(\\.\\d+)?|!=|>=|<=|==|[+\\-*/%><=]");//提取运算符和数字
        Matcher matcher = pattern.matcher(sufExpr);
        BigDecimal result=new BigDecimal("0.0");
        while (matcher.find()){
            String group = matcher.group();
            if(group.matches("[+\\-*/%]")){
                BigDecimal a1 =stack.pop();
                BigDecimal a2 =stack.pop();
                result = cal(a2, a1, group);
                stack.push(result);
            }
            else if(group.equals("(int)")){
                BigDecimal pop = stack.pop();
                BigDecimal bigDecimal = pop.setScale(0, BigDecimal.ROUND_DOWN);
                stack.push(bigDecimal);
            }
            else if(group.matches("!=|>=|<=|==|[><]")){
                BigDecimal a1 =stack.pop();
                BigDecimal a2 =stack.pop();
                stack.push(calBoolean(a2,a1,group)?new BigDecimal(1):new BigDecimal(0));
            }
            else if(group.equals("=")){
                BigDecimal a1 =stack.pop();
                BigDecimal a2 =stack.pop();
                if (a2.compareTo(new BigDecimal(1))==0) {
                    stack.push(a1);
                }
            }
            else {//为数字直接压栈
                stack.push(new BigDecimal(group));
            }
        }
        return result;
    }


    /**
     * 新增内转汽运详单
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public int addConvertedDetailsOrder(BigDecimal orderId) throws Exception {
        // 得到最大id
        BigDecimal detailsId = selectMaxId();
        String detailsNo = noUtil.setResultNo("QYXD", detailsId);
        // 新增详单实体
        BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
        // 设置常规字段
        bmstruckDetailsOrder.setInsertTime(new Date());
        bmstruckDetailsOrder.setInsertUsername("admin");
        bmstruckDetailsOrder.setInsertUpdateRemark("无");
        // 通过订单号获取物资信息以及结算方式
        Map<String, Object> mapVal=getSettlement(orderId);
        //需求类型（0：计重；1：计时；2：计次；3：包月）
        String requirementType=mapVal.get("requirementType").toString();
        Integer materialId =Integer.parseInt(mapVal.get("materialId").toString());
        //通过物资id以及结算方式获取单价；
        BigDecimal priceId=getPriceByWz(requirementType,materialId);
        // 将单价存入实体
        bmstruckDetailsOrder.setPriceId(priceId);
        // 获取物资数量/计时获取时长/计数为一次/包月为包月价
        if("0".equals(requirementType)){
            //通过单价ID获取单价
            BigDecimal price=getPriceValue(priceId);
            //获取物资重量
            BigDecimal weight=getNetWeight(priceId);
            bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(price.doubleValue()*weight.doubleValue()));
        }
        else{
            //通过单价ID获取单价
            BigDecimal price=getPriceValue(priceId);
            bmstruckDetailsOrder.setDetailsAmount(price);
        }
        return bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
    }
    //通过物资id以及结算方式获取单价；
    @Override
    public BigDecimal getPriceByWz(String requirementType, Integer materialId) {
        return bmstruckDetailsOrderMapper.getPriceByWz(requirementType,materialId);
    }

    @Override
    // 通过订单号获取物资信息以及结算方式
    public Map<String, Object> getSettlement(BigDecimal orderId) {
        return bmstruckDetailsOrderMapper.getSettlement(orderId);
    }

    /**
     * 修改详单
     * @param mapValue
     * @return
     */

    @Override
    public synchronized int updateDetailsOrder(Map<String, Object> mapValue) {
        System.out.println("修改单价,时间:" + new Date() + "-----------" + mapValue);
        BigDecimal orderId = DataChange.dataToBigDecimal(mapValue.get("orderId"));
        BigDecimal priceId = DataChange.dataToBigDecimal(mapValue.get("priceId"));
        BigDecimal priceValue = getPriceValue(priceId);
        System.out.println("运单Id,为" + orderId);
        System.out.println("随接口传输过来的单价Id,为" + priceId);
        try {
            int i = insertSelectiveNew(orderId,priceId);
        } catch (Exception e) {
            //不打印给控制台（可能是正常情况）
        }
        //根据运输订单id查询计费详单id
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        omstruckOrder.setOrderId(orderId);
        omstruckOrder.setPriceId(priceId);
        try{
            //通过userId查询出用户名
            String carrierName = bmstruckDetailsOrderMapper.getCarrierNameForPriceValue((String) mapValue.get("userId"));
            System.out.println("正在执行该操作的人员为:" + carrierName + "时间为:" + new Date()) ;
            //根据运输ID查询出记录下来的用户名
            String recordUserName = bmstruckDetailsOrderMapper.getUserName(orderId);
            if (recordUserName==null){
                omstruckOrder.setRecordUsername(carrierName+",");
            }else {
                String[] s = recordUserName.split(",");
                if (s.length < 2){
                    omstruckOrder.setRecordUsername(recordUserName+carrierName+",");
                }else if (s.length ==2){
                    omstruckOrder.setRecordUsername(recordUserName+carrierName);
                }else if (s.length==3){
                    s[0]=s[1];
                    s[1]=s[2];
                    s[2]=carrierName;
                    omstruckOrder.setRecordUsername(s[0]+","+s[1]+","+s[2]);
                }
            }
        }catch (Exception e){
            System.out.println("e"+e.getMessage());
        }
        List<BigDecimal> detailIds = bmstruckDetailsOrderMapper.getDetailIds(orderId);
        omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        int result = 0;
        for (BigDecimal detailsId : detailIds) {
            BmstruckDetailsOrder bmstruckDetailsOrder = bmstruckDetailsOrderMapper.selectByPrimaryKey(detailsId);
            bmstruckDetailsOrder.setHistoryDetailsAmount(bmstruckDetailsOrder.getDetailsAmount());
            // 重新设置单价
            BigDecimal priceId1 = bmstruckDetailsOrder.getPriceId();
            bmstruckDetailsOrder.setPriceids(priceId1+","+priceId);
            bmstruckDetailsOrder.setPriceId(priceId);
            bmstruckDetailsOrder.setPriceValue(priceValue);
            BigDecimal weightTaskResultId = bmstruckDetailsOrder.getWeightTaskResultId();
            BigDecimal weightBatchId = bmstruckDetailsOrder.getWeightBatchId();
            Map<String,Object> map = new HashMap<>();
            if(weightBatchId != null) {
                map.put("orderId",orderId);
                map.put("weightBatchId",weightBatchId);
                map.put("priceId",priceId);
            }else{
                map.put("orderId",orderId);
                map.put("weightTaskResultId",weightTaskResultId);
                map.put("priceId",priceId);
            }
            try {
                // 计算出新的详单金额
                BigDecimal newAmount = updateSteelAmounts(map);
                bmstruckDetailsOrder.setDetailsAmount(newAmount.divide(new BigDecimal(1),2, RoundingMode.HALF_UP));
                //修改单价的历史时间
                //omstruckOrderMapper.modifyOldTime(priceId,new Date());
            }catch (Exception e) {
                System.out.println("更新历史时间失败");
            }
            System.out.println("更新详单数据成功");
            result = bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
        }
        /*try {
            amsFeign.copySteelPrice(mapValue);
        } catch (Exception e) {
            e.printStackTrace();
        }*/
        if(DataChange.dataToBigDecimal(mapValue.get("updatePlace")).intValue() == 1) {
            System.out.println("更新asom里面的实际地址数据");
            Map<String, Object> stringObjectMap = bmstruckDetailsOrderMapper.getsaleShippingAddressId(mapValue);
            BigDecimal saleShippingAddressId = (BigDecimal) stringObjectMap.get("saleShippingAddressId");
            BigDecimal historyShippingAddressId = (BigDecimal) stringObjectMap.get("historyShippingAddressId");
            bmstruckDetailsOrderMapper.updateActuallyPlace(mapValue);
            //if (historyShippingAddressId!=null){
            //    //修改地址(不修改历史地址)
            //    bmstruckDetailsOrderMapper.updatePlaceNew(mapValue);
            //}else if (historyShippingAddressId==null ) {
            //    mapValue.put("historyPlaceId", saleShippingAddressId);
            //    //修改地址(不修改历史地址)
            //    bmstruckDetailsOrderMapper.updatePlace(mapValue);
            //}
        }
        System.out.println("修改单价,时间:" + new Date() + "-----------" + mapValue);
        return result;
    }

    @Override
    public int updateAsomPriceId(Map<String, Object> mapValue) {
        System.out.println("更新ASOM表里面的数据实际地址数据" + mapValue + "----------" + new Date());
        //前面更新运单时更新过地址了，这里就不更新了，如果订单ID为空，才更新
        if(DataChange.dataToBigDecimal(mapValue.get("updatePlace")).intValue() == 1 && mapValue.get("orderId")==null) {
            Map<String, Object> stringObjectMap = bmstruckDetailsOrderMapper.getsaleShippingAddressId(mapValue);
            BigDecimal saleShippingAddressId = (BigDecimal) stringObjectMap.get("saleShippingAddressId");
            BigDecimal historyShippingAddressId = (BigDecimal) stringObjectMap.get("historyShippingAddressId");
            bmstruckDetailsOrderMapper.updateActuallyPlace(mapValue);
            //if (historyShippingAddressId!=null){
            //    //修改地址(不修改历史地址)
            //    bmstruckDetailsOrderMapper.updatePlaceNew(mapValue);
            //}else if (historyShippingAddressId==null ) {
            //    mapValue.put("historyPlaceId", saleShippingAddressId);
            //    //修改地址(不修改历史地址)
            //    bmstruckDetailsOrderMapper.updatePlace(mapValue);
            //}
        }
        return bmstruckDetailsOrderMapper.updateAsomPriceId(mapValue);
    }

    @Override
    public BigDecimal getCarrierIdBySSO(String carrierSsoId) {
        return bmstruckDetailsOrderMapper.getCarrierIdBySSO(carrierSsoId);
    }

    // 根据单价id查询价格和地址
    @Override
    public Map<String,Object> findAddressAndPrice(Integer priceId) {
        return bmstruckDetailsOrderMapper.findAddressAndPrice(new BigDecimal(priceId));
    }

    /**
     * 增加焦炭途损费
     * @param map
     * @return
     */
    @Override
    public int addLossFeeOfCoke(Map<String,Object> map) {
        BigDecimal lossFees = DataChange.dataToBigDecimal(map.get("lossFees"));
        BigDecimal detailsId = DataChange.dataToBigDecimal(map.get("detailsId"));
        BmstruckDetailsOrder bmstruckDetailsOrder = bmstruckDetailsOrderMapper.selectByPrimaryKey(detailsId);
        BigDecimal detailsAmount = bmstruckDetailsOrder.getDetailsAmount();
        DecimalFormat df = new DecimalFormat("0.00");
        Double newAmount = detailsAmount.doubleValue() - lossFees.doubleValue();
        String newAmountStr = df.format(newAmount);
        bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(newAmountStr));
        int result = bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
        return result;
    }

    /*
    内转计重计费详单
     */
    @Override
    public List<Map<String, Object>> getInwardWeightDetailsOrder(Map<String, Object> mapValue, Integer orderType) {
        List<Map<String,Object>>mapList = new ArrayList<>();
        switch (orderType){
            case 10:
                List<Map<String, Object>> inwardReportResult =  bmstruckDetailsOrderMapper.getPurInwarWeightDetailsOrder(mapValue);
                return inwardReportResult;
            case 21:
                return bmstruckDetailsOrderMapper.getInwardTimeDetailsOrder(mapValue);
            case 11:
                return bmstruckDetailsOrderMapper.getAllInwardWeight(mapValue);
            case 26:
                return bmstruckDetailsOrderMapper.getInwardCountDetailsOrder(mapValue);
            default:
                break;
        }
        return mapList;
    }

    @Override
    public synchronized int inserInwardOrder(Map<String, Object> mapVal) {
        //获取运输订单ID
        BigDecimal orderId= DataChange.dataToBigDecimal(mapVal.get("orderId"));
        //根据运输订单去查找订单类型
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        //根据运输订单id去查询计费详单id
        if(bmstruckDetailsOrderMapper.selectDetailsByOrder(orderId) > 0){
            return -1;
        }
        List<Map<String,Object>> priceAmountList = new ArrayList<>();
        if(inwardTypeList.contains(orderType.intValue())){
            //获取该订单的计量实绩ID以及净重,只会返回一条数据
            priceAmountList = bmstruckDetailsOrderMapper.getWeightTaskResultId(orderId);
        }
        if(toLineAndMaterial.contains(orderType.intValue())){
            //如果在以上订单类型里面则需要根据运输订单ID去找线路和物资
            Map<String,Object> priceInfoPur = bmstruckDetailsOrderMapper.getPriceInfoPur(orderId);
            //根据物资品类ID和承运起止范围去匹配单价
            Map<String,Object> map = bmstruckDetailsOrderMapper.getPurInwardPrice(priceInfoPur);
            if(map != null){
                mapVal.putAll(map);
            }else{
                return -1;
            }
        }
        if(fixLineList.contains(orderType.intValue())){
            //拼装车皮进厂以及一焦化采购焦炭进厂
            Map<String,Object> priceInfoPur = bmstruckDetailsOrderMapper.getPriceInfoPur(orderId);
            priceInfoPur.put("transRangeId",1);
            //根据物资品类ID和承运起止范围去匹配单价
            Map<String,Object> map = bmstruckDetailsOrderMapper.getPurInwardPrice(priceInfoPur);
            if(map != null){
                mapVal.putAll(map);
            }else{
                return -1;
            }
        }
        if(steelTypeList.contains(orderType.intValue())){
            //钢材倒库
            //首先获取净重
            //BigDecimal netWeight = bmstruckDetailsOrderMapper.selectNetWeight(orderId);
            //mapVal.put("netWeight",netWeight);
            //获取单价
            Map<String, Object> priceInfoPur = new HashMap<>();
            priceInfoPur.put("transRangeId",1);
            priceInfoPur.put("materialTypeId",5102);
            Map<String,Object> map = bmstruckDetailsOrderMapper.getPurInwardPrice(priceInfoPur);
            if(map != null){
                mapVal.putAll(map);
            }else{
                return -1;
            }
        }
        if(orderType.intValue() == 21 || orderType.intValue()==26){
            //计时/计次
            priceAmountList.add(mapVal);
        }
        //获取单价ID
        BigDecimal priceId = DataChange.dataToBigDecimal(mapVal.get("priceId")) ;
        //获取单价值
        BigDecimal priceValue = DataChange.dataToBigDecimal(mapVal.get("priceValue"));
        if(priceId == null){
            System.out.println(orderId + "没有单价");
            return 1;
        }
        int result = 0;
        for (Map<String, Object> map : priceAmountList) {
            BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
            //查询计重且计时
            String s = bmstruckDetailsOrderMapper.selectWeightAndTimeByOrderId(orderId);
            int num=0;
            if (s!=null && s.contains("计时且过计量")){
                num=21;
            }
            if(inwardTypeList.contains(orderType.intValue()) && num==0){
                BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
                BigDecimal netWeight = null;
                if(mapVal.get("netWeight") != null) {
                     //因为事务的关系,部分订单结束时可能没有净重，故需要添加净重
                     netWeight = DataChange.dataToBigDecimal(mapVal.get("netWeight"));
                }
                else{
                     netWeight = DataChange.dataToBigDecimal(map.get("netWeight"));
                }
                //计算详单金额
                BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*netWeight.doubleValue());
                //保留两位小数
                DecimalFormat df = new DecimalFormat("0.00");
                String format = df.format(detailsAmount);
                //关联计量实绩
                bmstruckDetailsOrder.setWeightTaskResultId(weightTaskResultId);
                if(priceId != null && priceValue !=null && detailsAmount.intValue() > 0){
                    bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(format));
                }
            }
            //内转计时结算
            if(orderType.intValue() == 21 || num==21){
                BigDecimal resultTime = DataChange.dataToBigDecimal(mapVal.get("Time1"));
                //保留两位小数
                DecimalFormat df = new DecimalFormat("0.00");
                BigDecimal settleTime  = new BigDecimal(String.valueOf(resultTime.divide(new BigDecimal(60), 14, BigDecimal.ROUND_HALF_UP)));
                if(settleTime.doubleValue()<2.00){
                    BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*2);
                    bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(df.format(detailsAmount)));
                }else{
                    BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*settleTime.doubleValue());
                    bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(df.format(detailsAmount)));
                }
            }
            //内转计次结算
            if(orderType.intValue() == 26){
                //保留两位小数
                DecimalFormat df = new DecimalFormat("0.00");
                BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue());
                bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(df.format(detailsAmount)));
            }
            bmstruckDetailsOrder.setPriceId(priceId);
            bmstruckDetailsOrder.setInsertUpdateRemark("单价存在");
            // 得到最大id
            BigDecimal detailsId = selectMaxId();
            bmstruckDetailsOrder.setOrderId(orderId);
            String detailsNo = noUtil.setResultNo("QYXD", detailsId);
            bmstruckDetailsOrder.setDetailsId(detailsId);
            bmstruckDetailsOrder.setDetailsNo(detailsNo);
            bmstruckDetailsOrder.setDetailsTime(new Date());
            // 设置常规字段
            bmstruckDetailsOrder.setInsertTime(new Date());
            bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
            bmstruckDetailsOrder.setInsertUsername("admin");
            bmstruckDetailsOrder.setUpdateUsername("admin");
            result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
        }
        return result;
    }

    @Override
    public int updateDetails() {
        List<Map<String,Object>>mapList = bmstruckDetailsOrderMapper.selectDetailsNoAmount();
        int i=0;
        for (Map<String,Object>map:mapList
             ) {
            //获取详单ID、价格值，净重
            BigDecimal detailsId = DataChange.dataToBigDecimal(map.get("detailsId"));
            BigDecimal netWeight = DataChange.dataToBigDecimal(map.get("netWeight"));
            BigDecimal priceValue = DataChange.dataToBigDecimal(map.get("priceValue"));
            BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
            bmstruckDetailsOrder.setDetailsId(detailsId);
            BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*netWeight.doubleValue());
            DecimalFormat df = new DecimalFormat("0.00");
            String format = df.format(detailsAmount);
            bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(format));
            i += bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
        }
        return i;
    }
    /*
    内转计重+计时计费详单
     */
    @Override
    public List<Map<String, Object>> getInwardWeightTimeDetailsOrder(Map<String, Object> mapValue, Integer orderType) {

        List<Map<String,Object>>mapListWeight = new ArrayList<>();
        List<Map<String,Object>>mapListTime = new ArrayList<>();
               //计重计费详单查询结果
               mapListWeight = bmstruckDetailsOrderMapper.getInwardWeightDetailsOrder(mapValue);
               //for(Map<String, Object> mapListWeightOne : mapListWeight)
               //{
               //     mapListWeightOne.put("resultTime","null");
               //}
               //计时计费详单查询结果
               mapListTime = bmstruckDetailsOrderMapper.getInwardTimeDetailsOrder(mapValue);
               //将计时查询结果加入到计重查询结果中
               for(Map<String, Object> mapListTimeOne:mapListTime)
           {    mapListTimeOne.put("capacityNumber",mapListTimeOne.remove("capacityNum"));
               mapListWeight.add(mapListTimeOne);
           }
               //返回计重+计时计费详单查询结果
        return mapListWeight;
    }

    @Override
    public List<Map<String, Object>> getNoInwardDetails(Map<String, Object> mapValue) {
        return bmstruckDetailsOrderMapper.getNoInwardDetails(mapValue);
    }

    @Override
    public List<Map<String, Object>> getSteelTruckDetailsOrder(Map<String, Object> mapValue) {
        return bmstruckDetailsOrderMapper.getSteelTruckDetailsOrder(mapValue);
    }

    @Override
    public int newInwardSettle(List<Map<String,Object>> orderIds) {
        int count = 0;
        //遍历数组
        for(Map<String,Object> orderIdMap:orderIds){
            Integer orderId = DataChange.dataToBigDecimal(orderIdMap.get("orderId")).intValue();
            //根据运输ID获取订单类型
            BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(new BigDecimal(orderId));
            //根据订单类型调用不同的方法
            //如果订单类型是11,
            if(orderType.intValue() == 11){
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                if(detailsIds.size() == 0){
                    omsFeign.closeInwardOrder(orderId);
                    count++;
                }else{
                    for(int i=0;i<detailsIds.size();i++){
                        bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsIds.get(i));
                        omsFeign.closeInwardOrder(orderId);
                        count++;
                    }
                }
            }
            if(orderType.intValue() == 10 || orderType.intValue() == 20){
                //根据运输订单ID找寻计费详单ID
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                for(BigDecimal detailsId:detailsIds){
                    //根据详单ID物理删除详单
                    bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsId);
                    count++;

                }
                inserInwardOrder(orderIdMap);
            }
            if(orderType.intValue() == 23 || orderType.intValue() == 24){
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                for(BigDecimal detailsId:detailsIds){
                    //根据详单ID物理删除详单
                    bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsId);
                    count++;
                }
                inserInwardOrder(orderIdMap);
            }
            if(orderType.intValue() == 16 || orderType.intValue() == 15){
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                for(BigDecimal detailsId:detailsIds){
                    //根据详单ID物理删除详单
                    bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsId);
                    count++;
                }
                inserInwardOrder(orderIdMap);
            }
        }
        return count;
    }


    @Override
    public int updateDetailsStatus(List<Integer> detailsOrderList) {
        int i = 0;
        for(Integer detailsId :detailsOrderList) {
            if(detailsId == null) {
                continue;
            }
            //BigDecimal detailId  = DataChange.dataToBigDecimal(map.get("detailId"));
            //BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
            //bmstruckDetailsOrder.setDetailsId(detailId);
            //bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(1));
            //i += bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
            try {
                i += bmstruckDetailsOrderMapper.updateDetailsStatus(detailsId);
            } catch (Exception e) {
                e.printStackTrace();
            }
            /*BigDecimal priceId = omstruckOrderMapper.getPriceId(orderId);
            omstruckOrderMapper.modifyOldTime(priceId,new Date());*/
        }
        return i;
    }

    @Override
    public int getSaleOrderStatus(BigDecimal orderId) {
        return bmstruckDetailsOrderMapper.getSaleOrderStatus(orderId);
    }

    @Override
    public synchronized int insertPriceValue(List<Map<String, Object>> mapList) {
        for (Map<String, Object> map : mapList) {
            Integer placeId =(Integer) map.get("placeId");
            //根据位置ID去查询是否有单价存在，如果有就跳过
            BigDecimal priceIdInt = bmstruckDetailsOrderMapper.getPriceIdInt(placeId);
            if (priceIdInt!=null&&priceIdInt.compareTo(BigDecimal.ZERO)!=0){
                break;
            }else {
                ////新增单价
                //BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
                //BigDecimal omsTruckOrderPriceId = bmstruckDetailsOrderMapper.getOmsTruckOrderPriceId(orderId);
                //Map<String,Object> map1=new HashMap<>();
                //map1.put("orderId",orderId);
                //map1.put("priceId",omsTruckOrderPriceId);
                //try {
                //    amsFeign.copySteelPrice(map1);
                //} catch (Exception e) {
                //    e.printStackTrace();
                //}
                //单价的主键
                //map1.put("priceId",bmstruckDetailsOrderMapper.selectMaxIdNew());
                //map1.put("priceValue",map.get("priceValue"));
                //map1.put("placeId",placeId);
                //bmstruckDetailsOrderMapper.insertPriceValue(map1);
            }
        }
        return 0;
    }

    public int cancelMakeSure(List<Integer> detailsOrderList) {
        int i = 0;
        for(Integer detailsId :detailsOrderList) {
            if(detailsId == null) {
                continue;
            }
            //BigDecimal detailId  = DataChange.dataToBigDecimal(map.get("detailId"));
            //BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
            //bmstruckDetailsOrder.setDetailsId(detailId);
            //bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(1));
            //i += bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
            i += bmstruckDetailsOrderMapper.cancelMakeSure(detailsId);
            /*BigDecimal priceId = omstruckOrderMapper.getPriceId(orderId);
            omstruckOrderMapper.modifyOldTime(priceId,new Date());*/
        }
        return i;
    }

    @Override
    public synchronized int updateDetailsDirect(Map<String, Object> mapValue) throws Exception {
        List<BigDecimal> orderIds = (List<BigDecimal>) mapValue.get("orderList");
        BigDecimal priceValue = DataChange.dataToBigDecimal(mapValue.get("detailAmount"));//以java变量名为准,这里是所填写的单价值
        if(priceValue.intValue() < 0){
            throw new Exception("单价不能小于等于0");
        }
        String detailRemark = mapValue.get("detailRemark").toString();
        String userId = mapValue.get("userId").toString();
        String userName = bmstruckDetailsOrderMapper.getUserNameByUserId(userId);
        String url = mapValue.get("url").toString();
        AmsContractTransportPrice amsContractTransportPrice = new AmsContractTransportPrice();
        BigDecimal priceId = amsContractTransportPriceMapper.selectMaxId();
        amsContractTransportPrice.setPriceId(priceId);
        amsContractTransportPrice.setPriceValue(priceValue);
        amsContractTransportPrice.setPriceDate(new Date());
        int result = 0;
        for(int i=0;i<orderIds.size();i++){
            BigDecimal orderId = DataChange.dataToBigDecimal(orderIds.get(i));
            //校验
            BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
            if(orderType.intValue() != 1){
                throw new Exception("订单类型错误，不允许生成汽运计费详单");
            }
            //更新订单表单价
            bmstruckDetailsOrderMapper.updateOrderPrice(orderId,priceId);
            //更新车序号表单价
            bmstruckDetailsOrderMapper.updateAsomPriceIdByOrderId(orderId,priceId);
            saleLogUtil.logOrder(orderId,"直接修改单价",userName,SaleLogUtil.UPDATE);
            //查询订单计量详情
            List<Map<String,Object>> batchIdList = bmstruckDetailsOrderMapper.getWeightBatchIds(orderId);
            for (Map<String, Object> map : batchIdList) {
                if(null == map){
                    continue;
                }
                BigDecimal weightBatchId = DataChange.dataToBigDecimal(map.get("weightBatchId"));
                //根据计量实绩查找批次ID
                BigDecimal netWeight = DataChange.dataToBigDecimal(map.get("netWeight"));
                if (netWeight == null) {
                    System.out.println("没有计量实绩,不生成结算数据:" + orderId);
                    continue;
                }
                // 得到计费公式
                String formula_string = null;
                if (orderType.intValue() >= 1 && orderType.intValue() <= 3) {
                    // 得到销售10km差距内的汽运计费公式
                    formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
                    // 替换采购汽运运计算公式
                    formula_string = formula_string.replace("运输单价",priceValue.toString())
                            .replace("物资净重",netWeight.toString());
                }
                String s = toSufExpr(formula_string);
                BigDecimal  detailsAmountOld = calSufExpr(s);
                Double amount = detailsAmountOld.doubleValue();
                BigDecimal detailsAmount = new BigDecimal(amount).setScale(2,RoundingMode.HALF_UP);
                if(bmstruckDetailsOrderMapper.getIsHaveDetailsOrderByBatch(weightBatchId) > 0 ){
                    //获取详单ID
                    BigDecimal detailsId = bmstruckDetailsOrderMapper.getDetailsIdByBatchId(weightBatchId);
                    BmstruckDetailsOrder bmstruckDetailsOrder = bmstruckDetailsOrderMapper.selectByPrimaryKey(detailsId);
                    bmstruckDetailsOrder.setPriceId(priceId);
                    bmstruckDetailsOrder.setPriceValue(priceValue);
                    bmstruckDetailsOrder.setOrderId(orderId);
                    bmstruckDetailsOrder.setDetailsId(detailsId);
                    bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
                   result += bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
                    continue;
                }
                //计算总费用
                //判断该计量实绩有没有结算数据
                //否则，新增详单
                try {
                    BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
                    bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
                    // 得到最大id
                    BigDecimal detailsId = selectMaxId();
                    String detailsNo = noUtil.setResultNo("QYXD", detailsId);
                    bmstruckDetailsOrder.setDetailsId(detailsId);
                    bmstruckDetailsOrder.setWeightBatchId(weightBatchId);
                    bmstruckDetailsOrder.setOrderId(orderId);
                    bmstruckDetailsOrder.setDetailsNo(detailsNo);
                    bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
                    bmstruckDetailsOrder.setDetailsTime(new Date());
                    bmstruckDetailsOrder.setPriceValue(priceValue);//填写的单价
                    bmstruckDetailsOrder.setPhoto(url);//上传的凭证图片路径
                    bmstruckDetailsOrder.setRemark(detailRemark);//凭证备注
                    // 设置常规字段
                    bmstruckDetailsOrder.setInsertTime(new Date());
                    bmstruckDetailsOrder.setUpdateTime(new Date());
                    bmstruckDetailsOrder.setInsertUsername(userId);
                    bmstruckDetailsOrder.setUpdateUsername("admin");
                    bmstruckDetailsOrder.setInsertUpdateRemark("无");
                    result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
                }catch (Exception e){
                    //不打印给控制台（有可能是正常情况）
                    e.printStackTrace();
                }
            }
        }
        amsContractTransportPriceMapper.insertSelective(amsContractTransportPrice);
        return result;
    }


    @Override
    public int addTruckDetail(Map<String, Object> mapValue) throws Exception {
        List<BigDecimal> orderIds = (List<BigDecimal>) mapValue.get("orderList");
        BigDecimal detailsAmount = DataChange.dataToBigDecimal(mapValue.get("detailAmount"));
        String detailRemark = mapValue.get("detailRemark").toString();
        String userId = mapValue.get("userId").toString();

        String urls = "" + mapValue.get("urls");
        int result = 0;
        for(int i=0;i<orderIds.size();i++){
            BigDecimal orderId = DataChange.dataToBigDecimal(orderIds.get(i));
            //校验
            BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
            if(orderType.intValue() != 1){
                throw new Exception("订单类型错误，不允许生成汽运计费详单");
            }
            List<Map<String,Object>> weightTaskResultIdList = bmstruckDetailsOrderMapper.getSteelWeightTaskResultId(orderId);
            if(weightTaskResultIdList.size()<=0){
                throw new Exception("没有计量实绩，无法冲红");
            }
            //新增详单
            try {
                // 得到最大id
                BigDecimal detailsId = selectMaxId();
                BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
                bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
                String detailsNo = noUtil.setResultNo("QYXD", detailsId);
                bmstruckDetailsOrder.setWeightTaskResultId(DataChange.dataToBigDecimal(weightTaskResultIdList.get(0).get("weightTaskResultId")));
                bmstruckDetailsOrder.setDetailsId(detailsId);
                bmstruckDetailsOrder.setOrderId(orderId);
                bmstruckDetailsOrder.setDetailsNo(detailsNo);
                bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
                bmstruckDetailsOrder.setDetailsTime(new Date());
                bmstruckDetailsOrder.setRemark(detailRemark);//凭证备注
                bmstruckDetailsOrder.setPhoto(urls);//图片
                // 设置常规字段
                bmstruckDetailsOrder.setInsertTime(new Date());
                bmstruckDetailsOrder.setUpdateTime(new Date());
                bmstruckDetailsOrder.setInsertUsername(userId);
                bmstruckDetailsOrder.setUpdateUsername("admin");
                bmstruckDetailsOrder.setInsertUpdateRemark("无");
                result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return result;
    }

    @Override
    public int updateConsignee(Map<String, Object> map) throws Exception {
        bmstruckDetailsOrderMapper.updateConsignee(map);
        //记录日志
        saleLogUtil.logOrder(map,"修改计费详单的收货客户",SaleLogUtil.UPDATE);
        return 0;
    }
}