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;
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) throws Exception {
List<Map<String,Object>> weightTaskResultIdList = bmstruckDetailsOrderMapper.getSteelWeightTaskResultId(orderId);
System.out.println("根据运单查询到的计量实绩数据为," + weightTaskResultIdList);
Map<String,Object> priceMap = getPriceId(orderId);
System.out.println("根据运单查询到单价数据为," + priceMap);
if (priceMap == null || priceMap.size() == 0 || priceMap.get("priceId") == null) {
return 0;
}
BigDecimal priceId = (BigDecimal) priceMap.get("priceId");
//if (priceId.intValue() == 0) {
// return 0;
//}
int result = 0;
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.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 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 = 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);
}
/**
* 中缀转换后缀表达式
*/
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
*/
@Transactional
@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"));
System.out.println("运单Id,为" + orderId);
System.out.println("随接口传输过来的单价Id,为" + priceId);
try {
int i = insertSelectiveNew(orderId);
} 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());
}
omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
List<BigDecimal> detailIds = bmstruckDetailsOrderMapper.getDetailIds(orderId);
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);
BigDecimal weightTaskResultId = bmstruckDetailsOrder.getWeightTaskResultId();
Map<String,Object> map = new HashMap<>();
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 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>> weightTaskResultIdList = bmstruckDetailsOrderMapper.getSteelWeightTaskResultId(orderId);
for (Map<String, Object> map : weightTaskResultIdList) {
BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
BigDecimal netWeightIsNull = bmstruckDetailsOrderMapper.getNetWeight(weightTaskResultId);
if (netWeightIsNull == null) {
System.out.println("没有计量实绩,不生成结算数据:" + orderId);
continue;
}
//计算总费用
BigDecimal detailsAmountOld = generateTruckFeesForDirect(priceValue, weightTaskResultId);
Double amount = detailsAmountOld.doubleValue();
BigDecimal detailsAmount = new BigDecimal(amount).setScale(2,RoundingMode.HALF_UP);
//判断该计量实绩有没有结算数据
if(bmstruckDetailsOrderMapper.getIsHaveDetailsOrder(weightTaskResultId) > 0 ){
//如果有，更新
Map<String,Object> temp =new HashMap<>();
temp.put("orderId",orderId);
temp.put("weightTaskResultId",weightTaskResultId);
temp.put("priceValue",priceValue);
temp.put("detailAmount",detailsAmount);
temp.put("detailRemark",detailRemark);
temp.put("url",url);
temp.put("userId",userId);
result +=bmstruckDetailsOrderMapper.updateTruckDetails(temp);
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.setWeightTaskResultId(weightTaskResultId);
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;
}
}