package com.xzx.gc.order.service;
|
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.convert.Convert;
|
import cn.hutool.core.date.DateTime;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.lang.Dict;
|
import cn.hutool.core.util.NumberUtil;
|
import cn.hutool.core.util.StrUtil;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.xzx.gc.common.Result;
|
import com.xzx.gc.common.constant.Constants;
|
import com.xzx.gc.common.constant.OrderEnum;
|
import com.xzx.gc.common.utils.*;
|
import com.xzx.gc.entity.*;
|
import com.xzx.gc.model.order.ScanDto;
|
import com.xzx.gc.model.system.ConfigInfoReq;
|
import com.xzx.gc.model.system.ConfigInfoVo;
|
import com.xzx.gc.order.mapper.*;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import tk.mybatis.mapper.entity.Example;
|
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
|
/**
|
* 打卡入库
|
*/
|
|
@Service
|
@Transactional
|
@Slf4j
|
public class OrderBatchInfoService {
|
|
@Autowired
|
private OrderBatchInfoMapper orderBatchInfoMapper;
|
|
@Autowired
|
private OrderMapper orderMapper;
|
|
@Autowired
|
private OrderService orderService;
|
|
@Autowired
|
private PackageGoodsInfoService packageGoodsInfoService;
|
|
@Autowired
|
private RedisUtil redisUtil;
|
|
@Autowired
|
private OrderClockInMapper orderClockInMapper;
|
|
@Autowired
|
private OrderStorageInfoMapper orderStorageInfoMapper;
|
|
@Autowired
|
private OrderItemInfoMapper orderItemInfoMapper;
|
|
@Autowired
|
private OtherUserMapper otherUserMapper;
|
|
@Autowired
|
private OrderStorageDetailMapper orderStorageDetailMapper;
|
|
@Autowired
|
private JGUtil jgUtil;
|
|
@Autowired
|
private IdUtils idUtils;
|
|
@Autowired
|
private ConfigService configService;
|
|
@Autowired
|
private UserVehicleRelMapper userVehicleRelMapper;
|
|
@Autowired
|
private VehicleInfoMapper vehicleInfoMapper;
|
|
@Autowired
|
private BusinessUtil businessUtil;
|
|
@Autowired
|
private SysStorageService sysStorageService;
|
|
@Autowired
|
private SysEnvironmentalInfoService sysEnvironmentalInfoService;
|
|
@Autowired
|
private JGPushUtil jgPushUtil;
|
|
/**
|
* 极光推送入库相关信息
|
*
|
* @param scanDto
|
*/
|
private void sendToAnroid(ScanDto scanDto) {
|
//如果是主动发起的请求 或者 定时请求但是结果是成功的则需要推送一条数据
|
if(OrderEnum.主动请求.getValue().equals(Convert.toStr(scanDto.getTimeFlag(),OrderEnum.定时请求.getValue()))||Constants.RESULT_SUCCESS==scanDto.getCode()){
|
jgPushUtil.pushClock(scanDto);
|
}
|
}
|
|
|
/**
|
* 扫码打卡
|
* @param orderBatchInfo
|
* @return
|
*/
|
public Result<ScanDto> add(OrderBatchInfo orderBatchInfo) {
|
ScanDto scanDto = new ScanDto();
|
scanDto.setTimeFlag(orderBatchInfo.getTimeFlag());
|
scanDto.setUserId(orderBatchInfo.getUserId());
|
Result result = new Result();
|
|
//空车误差百分比
|
BigDecimal between= BigDecimal.ZERO;
|
ConfigInfoReq configInfoReq=new ConfigInfoReq();
|
configInfoReq.setConfigTypeCode("BETWEEN_WEIGHT");
|
List<ConfigInfoVo> configInfoVos = configService.configInfoQuery(configInfoReq);
|
if(CollUtil.isNotEmpty(configInfoVos)){
|
between=Convert.toBigDecimal(configInfoVos.get(0).getConfigValue());
|
}
|
|
BigDecimal minWeight = BigDecimal.ZERO;
|
UserVehicleRel userVehicleRel=new UserVehicleRel();
|
userVehicleRel.setUserId(orderBatchInfo.getUserId());
|
userVehicleRel.setDelFlag(Convert.toShort(Constants.DEL_NOT_FLAG));
|
List<UserVehicleRel> select1 = userVehicleRelMapper.select(userVehicleRel);
|
Long vehicleId=null;
|
if(CollUtil.isNotEmpty(select1)){
|
vehicleId = select1.get(0).getVehicleId();
|
VehicleInfo vehicleInfo=new VehicleInfo();
|
vehicleInfo.setId(vehicleId);
|
vehicleInfo.setDelFlag(Convert.toShort(Constants.DEL_NOT_FLAG));
|
VehicleInfo vehicleInfo1 = vehicleInfoMapper.selectOne(vehicleInfo);
|
minWeight=Convert.toBigDecimal(vehicleInfo1.getWeight());
|
log.info("当前用户：{}，空车重量：{}",orderBatchInfo.getUserId(),minWeight);
|
}else{
|
scanDto.setReason("没有绑定车辆");
|
scanDto.setCode(Constants.RESULT_ERROR);
|
scanDto.setReasonDesc("没有与当前用户:{"+orderBatchInfo.getUserId()+"}绑定的车辆");
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "没有与当前用户绑定的车辆");
|
}
|
//设置车辆
|
orderBatchInfo.setVehicleId(vehicleId);
|
|
//打卡时间
|
String createTime = orderBatchInfo.getCreateTime();
|
|
DateTime parse = DateUtil.parse(createTime, DateUtils.DATE_FORMAT_YMD);
|
DateTime parse2= DateUtil.parse(DateUtil.now(),DateUtils.DATE_FORMAT_YMD);
|
if(!DateUtil.isSameDay(parse,parse2)){
|
log.warn("地磅时间不准确，请校准");
|
scanDto.setReason("地磅时间不准确，请校准");
|
scanDto.setCode(Constants.RESULT_ERROR);
|
scanDto.setReasonDesc("地磅时间不对：错误时间为"+createTime);
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "地磅时间不准确");
|
}
|
|
|
|
OrderClockIn today = orderClockInMapper.findToday(orderBatchInfo.getUserId(), StrUtil.split(createTime, " ")[0]);
|
|
if (today == null) {
|
boolean lock=false;
|
//空车打卡
|
try {
|
List<OrderInfo> select= orderService.findDetailByReceiverAndStatus(orderBatchInfo.getUserId(),OrderEnum.待入库.getValue());
|
//判断是否还存在待入库的订单
|
if (CollUtil.isNotEmpty(select)) {
|
//入库打卡 打卡时间更改为最近订单完成时间的当天空车打卡时间
|
String completeTime = select.get(0).getCompleteTime();
|
|
//当天可能属于不用打卡的配置里 取不到打卡重量则取车重为打卡重量
|
today = orderClockInMapper.findToday(orderBatchInfo.getUserId(), StrUtil.split(completeTime, " ")[0]);
|
if(today==null){
|
today=new OrderClockIn();
|
today.setWeight(Convert.toStr(minWeight));
|
}
|
Result<ScanDto> rk = rk(today, scanDto, orderBatchInfo);
|
if(rk!=null){
|
return rk;
|
}
|
}else {
|
scanDto.setDesc("空车打卡失败");
|
scanDto.setType(OrderEnum.空车.getValue());
|
|
//防重复打卡
|
if (redisUtil.setnx(Constants.REDIS_ORDER_KEY + "clock:" + orderBatchInfo.getUserId(), orderBatchInfo.getUserId())) {
|
lock = true;
|
OrderClockIn today1 = orderClockInMapper.findToday(orderBatchInfo.getUserId(), StrUtil.split(createTime, "")[0]);
|
if (today1 != null) {
|
scanDto.setReason("您今天已打过卡了");
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "您今天已打过卡了");
|
}
|
|
String weight = orderBatchInfo.getWeight();
|
if (Convert.toBigDecimal(weight).compareTo(minWeight) < 0) {
|
scanDto.setReason("当前重量异常，请确保货车已在地秤上");
|
scanDto.setReasonDesc("空车当前重量为：" + weight + ",最小重量为:" + minWeight);
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "当前重量异常，请确保货车已在地秤上：" + weight);
|
}
|
|
//空车最大范围
|
BigDecimal maxWeight = NumberUtil.add(minWeight, NumberUtil.mul(minWeight, between));
|
if (Convert.toBigDecimal(weight).compareTo(maxWeight) > 0) {
|
scanDto.setReason("当前重量异常，已超过最大重量");
|
scanDto.setReasonDesc("空车当前重量为：" + weight + ",最大重量为:" + maxWeight);
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "当前重量异常，已超过最大重量：" + weight);
|
}
|
|
|
OrderClockIn orderClockIn = new OrderClockIn();
|
BeanUtils.copyProperties(orderBatchInfo, orderClockIn);
|
orderClockInMapper.insertSelective(orderClockIn);
|
|
scanDto.setCreateTime(DateUtil.parse(createTime).toString(DateUtils.DATE_FORMAT_YMDHM));
|
scanDto.setEmptyWeight(Convert.toBigDecimal(orderBatchInfo.getWeight()));
|
scanDto.setDesc("空车打卡成功");
|
sendToAnroid(scanDto);
|
}
|
}
|
} catch (Exception e) {
|
scanDto.setReason("程序异常");
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
ExceptionUtils.err(Constants.RESULT_ERROR, "空车打卡失败", e);
|
} finally {
|
if(lock) {
|
redisUtil.del(Constants.REDIS_ORDER_KEY + "clock:" + orderBatchInfo.getUserId());
|
}
|
}
|
} else {
|
/*********入库*****************/
|
Result<ScanDto> rk = rk(today, scanDto, orderBatchInfo);
|
if(rk!=null){
|
return rk;
|
}
|
}
|
result.setData(scanDto);
|
return result;
|
}
|
|
|
/**
|
* 载货打卡
|
* @param today
|
* @param scanDto
|
* @param orderBatchInfo
|
* @return
|
*/
|
public Result<ScanDto> rk( OrderClockIn today,ScanDto scanDto,OrderBatchInfo orderBatchInfo){
|
String orderIds = "";
|
boolean lock=false;
|
try {
|
BigDecimal bigDecimal = Convert.toBigDecimal(today.getWeight());
|
if (Convert.toBigDecimal(orderBatchInfo.getWeight()).compareTo(bigDecimal) <= 0) {
|
scanDto.setReason("当前重量异常，请确保货车已在地秤上");
|
scanDto.setReasonDesc("空车当前重量为：" + today.getWeight() + ",载货重量为:" + orderBatchInfo.getWeight());
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "重量异常，请确保货车已在地秤上：" + orderBatchInfo.getWeight());
|
}
|
|
|
scanDto.setDesc("载货打卡失败");
|
scanDto.setType(OrderEnum.载货.getValue());
|
|
String userId = orderBatchInfo.getUserId();
|
|
String timeOrder="";
|
//获取用户所有待入库订单
|
List<OrderInfo> select= orderService.findDetailByReceiverAndStatus(orderBatchInfo.getUserId(),OrderEnum.待入库.getValue());
|
if (CollUtil.isEmpty(select)) {
|
scanDto.setReason("没有待入库的订单");
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "没有待入库的订单");
|
}else {
|
//筛选比打卡时间晚的订单 地磅自动修复的BUG
|
for (Iterator<OrderInfo> iterator = select.iterator(); iterator.hasNext(); ) {
|
OrderInfo orderInfo = iterator.next();
|
String completeTime = orderInfo.getCompleteTime();
|
DateTime parse3 = DateUtil.parse(orderBatchInfo.getCreateTime(), DateUtils.DATE_FORMAT_YMDHMS);
|
DateTime parse4= DateUtil.parse(completeTime,DateUtils.DATE_FORMAT_YMDHMS);
|
//订单完成时间比打卡时间晚 则过滤掉
|
if(DateUtil.compare(parse4,parse3)>=0){
|
timeOrder=orderInfo.getOrderId()+",";
|
iterator.remove();
|
}
|
}
|
}
|
|
if (CollUtil.isEmpty(select)) {
|
scanDto.setReason("没有待入库的订单");
|
scanDto.setCode(Constants.RESULT_ERROR);
|
scanDto.setReasonDesc("没有待入库的订单,存在订单:【"+timeOrder+"】已超出打卡时间"+orderBatchInfo.getCreateTime()+"的情况");
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "没有待入库的订单");
|
}
|
|
List<String> collect = select.stream().map(OrderInfo::getOrderId).collect(Collectors.toList());
|
String join = CollUtil.join(collect, ",");
|
orderIds = join;
|
//防止重复扫码
|
if (redisUtil.setnx(Constants.REDIS_ORDER_KEY + "batch:" + join, join)) {
|
lock=true;
|
//二次验证
|
Example example1 = new Example(OrderBatchInfo.class);
|
example1.createCriteria().andEqualTo("orderId", join);
|
OrderBatchInfo orderBatchInfo1 = orderBatchInfoMapper.selectOneByExample(example1);
|
if (orderBatchInfo1 != null) {
|
scanDto.setReason("当前订单已被扫码");
|
scanDto.setReasonDesc("订单号：" + join);
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
return Result.error(Constants.RESULT_ERROR, "当前订单已被扫码");
|
}
|
|
orderBatchInfo.setStatus(Convert.toShort(1));
|
orderBatchInfo.setOrderId(join);
|
orderBatchInfoMapper.insertSelective(orderBatchInfo);
|
//入库相关数据库操作
|
|
List<String> collect1 = select.stream().filter(x -> x.getStoreId() != null).map(OrderInfo::getOrderId).collect(Collectors.toList());
|
|
List<String> collect2 = select.stream().filter(x -> x.getStoreId() == null).map(OrderInfo::getOrderId).collect(Collectors.toList());
|
|
//门店下单的数据
|
|
BigDecimal weight=BigDecimal.ZERO;
|
if(CollUtil.isNotEmpty(collect1)){
|
String storageId = idUtils.generate("RK", 0);
|
Dict dict = addDB(userId, collect1,storageId,1,null);
|
if (dict.get("recycleWeight") != null) {
|
weight=NumberUtil.add(weight,Convert.toBigDecimal(dict.getStr("recycleWeight")));
|
}
|
}
|
|
//正常下单的数据
|
if(CollUtil.isNotEmpty(collect2)){
|
String storageId = idUtils.generate("RK", 2);
|
Dict dict = addDB(userId, collect2,storageId,1,null);
|
if (dict.get("recycleWeight") != null) {
|
weight=NumberUtil.add(weight,Convert.toBigDecimal(dict.getStr("recycleWeight")));
|
}
|
}
|
|
scanDto.setOrderWeight(Convert.toBigDecimal(businessUtil.changeWeight(Convert.toStr(weight))));
|
scanDto.setCreateTime(DateUtil.parse(orderBatchInfo.getCreateTime()).toString(DateUtils.DATE_FORMAT_YMDHM));
|
|
scanDto.setWeight(Convert.toBigDecimal(orderBatchInfo.getWeight()));
|
scanDto.setDesc("载货打卡成功");
|
scanDto.setEmptyWeight(Convert.toBigDecimal(today.getWeight()));
|
sendToAnroid(scanDto);
|
}
|
|
} catch (Exception e) {
|
redisUtil.hincrBy(Constants.REDIS_ORDER_KEY+"storage:errcount",orderBatchInfo.getUserId(),1);
|
scanDto.setReason("程序异常");
|
scanDto.setCode(Constants.RESULT_ERROR);
|
sendToAnroid(scanDto);
|
ExceptionUtils.err(Constants.RESULT_ERROR, "载货打卡失败", e);
|
} finally {
|
if(lock) {
|
redisUtil.del(Constants.REDIS_ORDER_KEY + "batch:" + orderIds);
|
}
|
}
|
return null;
|
}
|
|
|
/**
|
* 入库信息操作
|
* @param userId
|
* @param collect
|
* @return
|
*/
|
public Dict addDB(String userId, List<String> collect,String storageId,int usertype,String packageId) {
|
Dict res = Dict.create();
|
/*******入库新增*******/
|
String join = CollUtil.join(collect, ",");
|
OrderStorageInfo orderStorageInfo = new OrderStorageInfo();
|
orderStorageInfo.setStorageId(storageId);
|
orderStorageInfo.setOrderId(join);
|
orderStorageInfo.setStorageStatus(Convert.toShort(OrderEnum.入库检验中.getValue()));
|
//回收价格
|
BigDecimal recycleMmoney = BigDecimal.ZERO;
|
BigDecimal recycleWeight = BigDecimal.ZERO;
|
Map<String, Dict> map = new HashMap<>();
|
for (String orderId : collect) {
|
OrderItemInfo orderItemInfo = new OrderItemInfo();
|
orderItemInfo.setOrderId(orderId);
|
List<OrderItemInfo> select1 = orderItemInfoMapper.select(orderItemInfo);
|
if (CollUtil.isNotEmpty(select1)) {
|
for (OrderItemInfo itemInfo : select1) {
|
if (StringUtils.isNotBlank(itemInfo.getMoney()) && Convert.toBigDecimal(itemInfo.getMoney()).compareTo(BigDecimal.ZERO)!=0) {
|
recycleMmoney = NumberUtil.add(recycleMmoney, new BigDecimal(itemInfo.getMoney()));
|
}
|
if (StringUtils.isNotBlank(itemInfo.getWeight()) &&Convert.toBigDecimal(itemInfo.getWeight()).compareTo(BigDecimal.ZERO)!=0) {
|
recycleWeight = NumberUtil.add(recycleWeight, new BigDecimal(itemInfo.getWeight()));
|
}
|
|
String itemType = itemInfo.getItemType();
|
String weight = StrUtil.isBlank(itemInfo.getWeight())?Constants.WEIGHT_INIT.toString():itemInfo.getWeight();
|
String amount = StrUtil.isBlank(itemInfo.getAmount())?"0":itemInfo.getAmount();
|
String money = StrUtil.isBlank(itemInfo.getMoney())?Constants.MONEY_INIT.toString():itemInfo.getMoney();
|
String price=StrUtil.isBlank(itemInfo.getPrice())?Constants.MONEY_INIT.toString():itemInfo.getPrice();
|
String rkPrice=StrUtil.isBlank(itemInfo.getPrice())?Constants.MONEY_INIT.toString():itemInfo.getPrice();
|
if(usertype==1&&StrUtil.isNotBlank(packageId)) {
|
//入库员要根据仓库id查找对应的入库价格
|
String area = sysStorageService.findById(Convert.toInt(packageId)).getArea();
|
BigDecimal putStoragePrice = sysEnvironmentalInfoService.findByItemTypeAndArea(itemType, Convert.toInt(area)).getPutStoragePrice();
|
rkPrice=businessUtil.changeMoney(putStoragePrice);
|
}
|
|
|
if (map.containsKey(itemType)) {
|
Dict dict = map.get(itemType);
|
if (dict.getBigDecimal("weight") != null) {
|
dict.set("weight", NumberUtil.add(dict.getBigDecimal("weight"), new BigDecimal(weight)));
|
}
|
if (dict.getBigDecimal("amount") != null) {
|
dict.set("amount", NumberUtil.add(dict.getBigDecimal("amount"), new BigDecimal(amount)));
|
}
|
if (dict.getBigDecimal("money") != null) {
|
dict.set("money", NumberUtil.add(dict.getBigDecimal("money"), new BigDecimal(money)));
|
}
|
|
} else {
|
Dict dict = Dict.create().set("weight", weight).set("amount", amount).set("money", money).set("price",price).set("rkPrice",rkPrice);
|
map.put(itemType, dict);
|
}
|
}
|
}
|
//更改订单状态
|
OrderInfo orderInfo1 = new OrderInfo();
|
orderInfo1.setOrderId(orderId);
|
//更新订单状态
|
orderInfo1.setOrderStatus(OrderEnum.入库中.getValue());
|
orderMapper.updateByPrimaryKeySelective(orderInfo1);
|
}
|
orderStorageInfo.setRecycleMoney(recycleMmoney);
|
orderStorageInfo.setRecycleWeight(Convert.toStr(recycleWeight));
|
res.set("recycleWeight", orderStorageInfo.getRecycleWeight());
|
res.set("recycleMoney", Convert.toStr(orderStorageInfo.getRecycleMoney()));
|
orderStorageInfo.setReceiver(userId);
|
OtherUserInfo otherUserInfo = otherUserMapper.selectByPrimaryKey(userId);
|
if (otherUserInfo != null) {
|
orderStorageInfo.setReceiverName(otherUserInfo.getName());
|
orderStorageInfo.setReceiverPhone(otherUserInfo.getMobilePhone());
|
orderStorageInfo.setReceiverAvatar(otherUserInfo.getAvatar());
|
}
|
//添加入库记录
|
|
if(usertype==1){
|
orderStorageInfo.setSysStorageType(Convert.toShort(OrderEnum.仓库.getValue()));
|
}else if(usertype==2){
|
orderStorageInfo.setSysStorageType(Convert.toShort(OrderEnum.打包站.getValue()));
|
}
|
if(packageId!=null) {
|
orderStorageInfo.setSysStorageId(Convert.toLong(packageId));
|
}
|
orderStorageInfoMapper.insertSelective(orderStorageInfo);
|
res.set("storageId", storageId);
|
|
/*************添加入库明细********************/
|
List<OrderStorageDetailInfo> list = new ArrayList<>();
|
|
if(usertype==1) {
|
for (String s : map.keySet()) {
|
OrderStorageDetailInfo orderStorageDetailInfo = new OrderStorageDetailInfo();
|
orderStorageDetailInfo.setStorageId(storageId);
|
//回收
|
orderStorageDetailInfo.setFlag(OrderEnum.回收型.getValue());
|
orderStorageDetailInfo.setItemType(s);
|
orderStorageDetailInfo.setMoney(map.get(s).getStr("money"));
|
orderStorageDetailInfo.setWeight(new BigDecimal(map.get(s).getStr("weight")));
|
orderStorageDetailInfo.setAmount(map.get(s).getStr("amount"));
|
orderStorageDetailInfo.setPrice(map.get(s).getStr("price"));
|
|
orderStorageDetailMapper.insertSelective(orderStorageDetailInfo);
|
list.add(orderStorageDetailInfo);
|
|
OrderStorageDetailInfo orderStorageDetailInfo2 = new OrderStorageDetailInfo();
|
BeanUtils.copyProperties(orderStorageDetailInfo, orderStorageDetailInfo2);
|
orderStorageDetailInfo2.setPrice(map.get(s).getStr("rkPrice"));
|
orderStorageDetailInfo2.setFlag(OrderEnum.入库型.getValue());
|
orderStorageDetailMapper.insertSelective(orderStorageDetailInfo2);
|
}
|
}else if(usertype==2){
|
List<PackageGoodsInfo> byPackageId = packageGoodsInfoService.findByPackageId(packageId);
|
if(CollUtil.isNotEmpty(byPackageId)){
|
for (PackageGoodsInfo packageGoodsInfo : byPackageId) {
|
OrderStorageDetailInfo orderStorageDetailInfo = new OrderStorageDetailInfo();
|
orderStorageDetailInfo.setStorageId(storageId);
|
//回收
|
orderStorageDetailInfo.setFlag(OrderEnum.回收型.getValue());
|
orderStorageDetailInfo.setItemType(packageGoodsInfo.getItemType());
|
orderStorageDetailInfo.setMoney(Constants.MONEY_INIT.toString());
|
orderStorageDetailInfo.setWeight(Constants.WEIGHT_INIT);
|
orderStorageDetailInfo.setAmount("0");
|
|
orderStorageDetailMapper.insertSelective(orderStorageDetailInfo);
|
list.add(orderStorageDetailInfo);
|
|
OrderStorageDetailInfo orderStorageDetailInfo2 = new OrderStorageDetailInfo();
|
BeanUtils.copyProperties(orderStorageDetailInfo, orderStorageDetailInfo2);
|
orderStorageDetailInfo2.setFlag(OrderEnum.入库型.getValue());
|
orderStorageDetailMapper.insertSelective(orderStorageDetailInfo2);
|
}
|
}
|
}
|
res.set("detail", list);
|
return res;
|
}
|
|
|
|
|
|
|
|
public Map<String,Object> queryBatchInfoDetailList(String weightError, String startTime,String endTime,String userId,String vehicleId,String page, String limit){
|
PageHelper.startPage(Convert.toInt(page),Convert.toInt(limit));
|
List<Map<String,Object>> data = orderBatchInfoMapper.queryBatchInfoDetailList(weightError, startTime,endTime,userId,vehicleId);
|
PageInfo<Map<String,Object>> pageInfo=new PageInfo<>(data);
|
List<Map<String,String>> dataTimeWeightList = new ArrayList<>();
|
for (Map<String,Object> obj:data) {
|
//同一天的空车重量相同，对应打卡空车重量也相同。
|
String orderId = obj.get("orderId").toString();
|
if(orderId.equals("0")){
|
Map<String,String> map = new HashMap<>();
|
String time = obj.get("createtime").toString();
|
String[] dayStr = time.split(" ");
|
String cweight = obj.get("cweight").toString();
|
map.put("day",dayStr[0]);
|
map.put("clockWeight",cweight);
|
dataTimeWeightList.add(map);
|
obj.put("clockWeight","-");
|
}
|
obj.put("orderid",orderId);
|
|
}
|
//赋值给载重车的空车重量
|
for (Map<String,Object> obj:data) {
|
String orderId = obj.get("orderId").toString();
|
BigDecimal we = new BigDecimal("0");
|
if(!"0".equals(orderId)){
|
String time = obj.get("createtime").toString();
|
String timeStr = time.split(" ")[0];
|
Map<String,Object> clockObj =orderBatchInfoMapper.queryEmptyWeight(weightError, timeStr+" 00:00:00",timeStr+" 23:59:59",userId,vehicleId);
|
if(null!=clockObj){
|
obj.put("clockWeight",clockObj.get("cweight").toString());
|
we = new BigDecimal(obj.get("cweight").toString()).subtract(new BigDecimal(clockObj.get("cweight").toString()));
|
}
|
}else{
|
we = new BigDecimal(obj.get("cweight").toString()).subtract(new BigDecimal(obj.get("vweight").toString()));
|
|
}
|
obj.put("weightError",we.toString());
|
}
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", data);
|
map.put("count", pageInfo.getTotal());
|
map.put("code", 0);
|
return map;
|
}
|
|
public Map<String,Object> queryClockDetailList(String weightError, String startTime,String endTime,String userId,String vehicleId,String page, String limit){
|
PageHelper.startPage(Convert.toInt(page),Convert.toInt(limit));
|
List<Map<String,Object>> data = orderBatchInfoMapper.queryClockDetailList(weightError, startTime,endTime,userId,vehicleId);
|
PageInfo<Map<String,Object>> pageInfo=new PageInfo<>(data);
|
for (Map<String,Object> obj:data) {
|
obj.put("clockWeight","-");
|
BigDecimal we = new BigDecimal("0");
|
we = new BigDecimal(obj.get("cweight").toString()).subtract(new BigDecimal(obj.get("vweight").toString()));
|
obj.put("weightError",we.toString());
|
obj.put("orderid",obj.get("orderId").toString());
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", data);
|
map.put("count",pageInfo.getTotal());
|
map.put("code", 0);
|
return map;
|
}
|
|
public Map<String,Object> queryBatchDetailList(String weightError, String startTime,String endTime,String userId,String vehicleId,String page, String limit){
|
PageHelper.startPage(Convert.toInt(page),Convert.toInt(limit));
|
List<Map<String,Object>> data = orderBatchInfoMapper.queryBatchDetailList(weightError, startTime,endTime,userId,vehicleId);
|
PageInfo<Map<String,Object>> pageInfo=new PageInfo<>(data);
|
for (Map<String,Object> obj:data) {
|
//计算当天打卡空车重量
|
String time = obj.get("createtime").toString();
|
if(null!=obj.get("orderId")){
|
obj.put("orderid",obj.get("orderId").toString());
|
}
|
|
String timeStr = time.split(" ")[0];
|
Map<String,Object> clockObj =orderBatchInfoMapper.queryEmptyWeight(weightError, timeStr+" 00:00:00",timeStr+" 23:59:59",userId,vehicleId);
|
if(null!=clockObj){
|
obj.put("clockWeight",clockObj.get("cweight").toString());
|
|
BigDecimal we = new BigDecimal("0");
|
we = new BigDecimal(obj.get("bweight").toString()).subtract(new BigDecimal(clockObj.get("cweight").toString()));
|
obj.put("weightError",we.toString());
|
}
|
|
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", data);
|
map.put("count", pageInfo.getTotal());
|
map.put("code", 0);
|
return map;
|
}
|
|
}
|
