package com.xzx.gc.order.service;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.convert.Convert;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.exceptions.ExceptionUtil;
|
import cn.hutool.core.lang.Dict;
|
import cn.hutool.core.map.MapUtil;
|
import cn.hutool.core.util.ArrayUtil;
|
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.CommonEnum;
|
import com.xzx.gc.common.constant.Constants;
|
import com.xzx.gc.common.constant.OrderEnum;
|
import com.xzx.gc.common.constant.PayEnum;
|
import com.xzx.gc.common.dto.SimplePage;
|
import com.xzx.gc.common.exception.BusinessException;
|
import com.xzx.gc.common.exception.RestException;
|
import com.xzx.gc.common.utils.*;
|
import com.xzx.gc.entity.*;
|
import com.xzx.gc.model.admin.PayRequestInfoModel;
|
import com.xzx.gc.model.admin.PayStorageModel;
|
import com.xzx.gc.model.admin.StorageUserModel;
|
import com.xzx.gc.model.comon.account.AllAcountParamDto;
|
import com.xzx.gc.model.order.OrderInfoReq;
|
import com.xzx.gc.model.order.RkStatisticsStorageReceiverDto;
|
import com.xzx.gc.model.user.AccountVo;
|
import com.xzx.gc.order.dto.*;
|
import com.xzx.gc.order.mapper.*;
|
import com.xzx.gc.service.AccountContext;
|
import com.xzx.gc.util.DoubleUtil;
|
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 javax.servlet.http.HttpServletRequest;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.ParseException;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service
|
@Transactional
|
@Slf4j
|
public class StorageService {
|
|
|
@Autowired
|
private PayInfoMapper payInfoMapper;
|
|
@Autowired
|
private IdUtils idUtils;
|
|
@Autowired
|
private OrderItemInfoMapper orderItemInfoMapper;
|
|
@Autowired
|
private OrderBatchInfoMapper orderBatchInfoMapper;
|
|
@Autowired
|
private OrderBatchMapper orderBatchMapper;
|
|
|
@Autowired
|
private RedisUtil redisUtil;
|
|
@Autowired
|
private AddressMapper addressMapper;
|
|
@Autowired
|
private OrderStorageDetailMapper orderStorageDetailMapper;
|
|
|
@Autowired
|
private SysStorageService sysStorageService;
|
|
@Autowired
|
private OrderDetailService orderDetailService;
|
|
@Autowired
|
private OrderClockInMapper orderClockInMapper;
|
|
@Autowired
|
private OrderStorageInfoMapper orderStorageInfoMapper;
|
|
@Autowired
|
private OrderDetailMapper orderDetailMapper;
|
|
@Autowired
|
private SysStorageMapper sysStorageMapper;
|
|
@Autowired
|
private OrderBatchInfoService orderBatchInfoService;
|
|
@Autowired
|
private OrderMapper orderMapper;
|
|
@Autowired
|
private PackageGoodsInfoService packageGoodsInfoService;
|
|
@Autowired
|
private PromotionRebateService promotionRebateService;
|
|
@Autowired
|
private OtherUserMapper otherUserMapper;
|
@Autowired
|
private AccountMapper accountMapper;
|
@Autowired
|
private OrderService orderService;
|
@Autowired
|
private HttpServletRequest request;
|
@Autowired
|
private BusinessUtil businessUtil;
|
|
@Autowired
|
private OtherUserService otherUserService;
|
|
|
@Autowired
|
private SysEnvironmentalInfoService sysEnvironmentalInfoService;
|
|
@Autowired
|
private WeightItemPriceService weightItemPriceService;
|
|
@Autowired
|
private CityPartnerService cityPartnerService;
|
|
|
@Autowired
|
private PartnerGaodeService partnerGaodeService;
|
|
@Autowired
|
private UserVehicleInfoService userVehicleInfoService;
|
@Autowired
|
private OrderHomeApplianceService orderHomeApplianceService;
|
|
/**
|
* 入库详情
|
* @param storageId
|
* @return
|
*/
|
public StorageDetailBatchDto detail(String storageId){
|
|
StorageDetailBatchDto storageDetailBatchDto=new StorageDetailBatchDto();
|
//物品清单
|
OrderStorageDetailInfo orderStorageDetailInfo=new OrderStorageDetailInfo();
|
orderStorageDetailInfo.setStorageId(storageId);
|
List<OrderStorageDetailInfo> select = orderStorageDetailMapper.select(orderStorageDetailInfo);
|
|
Example example=new Example(OrderStorageInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("storageId",storageId);
|
OrderStorageInfo orderStorageInfo = orderStorageInfoMapper.selectOneByExample(example);
|
Long sysStorageId = orderStorageInfo.getSysStorageId();
|
Short sysStorageType = orderStorageInfo.getSysStorageType();
|
if(CollUtil.isNotEmpty(select)){
|
|
|
Map<String,Dict> map=new HashMap<>();
|
|
for (OrderStorageDetailInfo storageDetailInfo : select) {
|
String flag = storageDetailInfo.getFlag();
|
BigDecimal weight = storageDetailInfo.getWeight();
|
String amount = storageDetailInfo.getAmount();
|
String money = storageDetailInfo.getMoney();
|
String itemType = storageDetailInfo.getItemType();
|
String price=storageDetailInfo.getPrice();
|
|
if(OrderEnum.入库型.getValue().equals(flag)&&weight!=null&&weight.compareTo(BigDecimal.ZERO)!=0){
|
|
if(map.containsKey(itemType)){
|
Dict dict = map.get(itemType);
|
BigDecimal storageWeight1 = dict.getBigDecimal("storageWeight");
|
dict.set("storageWeight",NumberUtil.add(storageWeight1,weight));
|
BigDecimal storageMoney1 = dict.getBigDecimal("storageMoney");
|
dict.set("storageMoney",NumberUtil.add(storageMoney1,Convert.toBigDecimal(money)));
|
map.put(itemType,dict);
|
}else{
|
Dict dict=Dict.create();
|
dict.set("storageWeight",weight);
|
dict.set("storageMoney",new BigDecimal(money));
|
dict.set("price",price);
|
map.put(itemType,dict);
|
}
|
}
|
|
if(OrderEnum.入库型.getValue().equals(flag)&&amount!=null&&Convert.toBigDecimal(amount,BigDecimal.ZERO).compareTo(BigDecimal.ZERO)!=0){
|
|
if(map.containsKey(itemType)){
|
Dict dict = map.get(itemType);
|
BigDecimal storageAmount1 = dict.getBigDecimal("storageAmount");
|
dict.set("storageAmount",NumberUtil.add(storageAmount1,Convert.toBigDecimal(amount)));
|
BigDecimal storageMoney1 = dict.getBigDecimal("storageMoney");
|
dict.set("storageMoney",NumberUtil.add(storageMoney1,Convert.toBigDecimal(money)));
|
map.put(itemType,dict);
|
}else{
|
Dict dict=Dict.create();
|
dict.set("storageAmount",Convert.toBigDecimal(amount));
|
dict.set("storageMoney",new BigDecimal(money));
|
dict.set("price",price);
|
map.put(itemType,dict);
|
}
|
}
|
|
|
if(OrderEnum.回收型.getValue().equals(flag)&&weight!=null&&weight.compareTo(BigDecimal.ZERO)!=0){
|
|
if(map.containsKey(itemType)){
|
Dict dict = map.get(itemType);
|
BigDecimal recyleweight1 = dict.getBigDecimal("recyleweight");
|
dict.set("recyleweight",NumberUtil.add(recyleweight1,weight));
|
BigDecimal recyleMoney1 = dict.getBigDecimal("recyleMoney");
|
dict.set("recyleMoney",NumberUtil.add(recyleMoney1,Convert.toBigDecimal(money)));
|
map.put(itemType,dict);
|
}else{
|
Dict dict=Dict.create();
|
dict.set("recyleweight",weight);
|
dict.set("recyleMoney",new BigDecimal(money));
|
dict.set("price",price);
|
map.put(itemType,dict);
|
}
|
}
|
|
if(OrderEnum.回收型.getValue().equals(flag)&&amount!=null&&Convert.toBigDecimal(amount,BigDecimal.ZERO).compareTo(BigDecimal.ZERO)!=0){
|
|
if(map.containsKey(itemType)){
|
Dict dict = map.get(itemType);
|
BigDecimal recyleAmount1 = dict.getBigDecimal("recyleAmount");
|
dict.set("recyleAmount",NumberUtil.add(recyleAmount1,Convert.toBigDecimal(amount)));
|
BigDecimal recyleMoney1 = dict.getBigDecimal("recyleMoney");
|
dict.set("recyleMoney",NumberUtil.add(recyleMoney1,Convert.toBigDecimal(money)));
|
map.put(itemType,dict);
|
}else{
|
Dict dict=Dict.create();
|
dict.set("recyleAmount",Convert.toBigDecimal(amount));
|
dict.set("recyleMoney",new BigDecimal(money));
|
dict.set("price",price);
|
map.put(itemType,dict);
|
}
|
}
|
}
|
|
|
if(MapUtil.isNotEmpty(map)){
|
List<OrderStorageDetailInfo> list=new ArrayList<>();
|
|
|
for (String s : map.keySet()) {
|
OrderStorageDetailInfo orderStorageDetailInfo1=new OrderStorageDetailInfo();
|
|
//选取仓库价格
|
SysEnvironmentalInfo sysEnvironmentalInfo1=new SysEnvironmentalInfo();
|
if(Convert.toShort(OrderEnum.打包站.getValue()).equals(sysStorageType)){
|
PackageGoodsInfo byPackageId = packageGoodsInfoService.findByPackageIdAndItemType(sysStorageId.toString(),s);
|
BeanUtil.copyProperties(byPackageId,sysEnvironmentalInfo1);
|
}else if(Convert.toShort(OrderEnum.仓库.getValue()).equals(sysStorageType)){
|
SysStorage byId1 = sysStorageService.findById(Convert.toInt(sysStorageId));
|
Integer areaId = Convert.toInt(byId1.getArea());
|
sysEnvironmentalInfo1 = sysEnvironmentalInfoService.findByItemTypeAndArea(s, areaId);
|
}
|
|
Dict dict = map.get(s);
|
String price = dict.getStr("price");
|
//设置分类价格等
|
orderStorageDetailInfo1.setItemTypeName(sysEnvironmentalInfo1.getTitle());
|
if(StrUtil.isNotBlank(price)){
|
orderStorageDetailInfo1.setItemTypePrice(price);
|
}else {
|
orderStorageDetailInfo1.setItemTypePrice(sysEnvironmentalInfo1.getPrice());
|
}
|
orderStorageDetailInfo1.setItemTypePicture(sysEnvironmentalInfo1.getPicture());
|
//上门价格
|
orderStorageDetailInfo1.setItemTypePrice2(sysEnvironmentalInfo1.getSecondPrice());
|
|
BigDecimal recyleweight = dict.getBigDecimal("recyleweight");
|
BigDecimal recyleMoney = dict.getBigDecimal("recyleMoney");
|
BigDecimal recyleAmount = dict.getBigDecimal("recyleAmount");
|
BigDecimal storageWeight = dict.getBigDecimal("storageWeight");
|
BigDecimal storageMoney = dict.getBigDecimal("storageMoney");
|
BigDecimal storageAmount= dict.getBigDecimal("storageAmount");
|
|
if(recyleweight!=null&&recyleweight.compareTo(BigDecimal.ZERO)!=0){
|
orderStorageDetailInfo1.setWeight(recyleweight);
|
}
|
|
if(recyleMoney!=null&&recyleMoney.compareTo(BigDecimal.ZERO)!=0){
|
orderStorageDetailInfo1.setMoney(recyleMoney.toString());
|
}
|
|
if(recyleAmount!=null&&recyleAmount.compareTo(BigDecimal.ZERO)!=0){
|
orderStorageDetailInfo1.setAmount(Convert.toStr(recyleAmount));
|
}
|
|
if(storageWeight!=null&&storageWeight.compareTo(BigDecimal.ZERO)!=0){
|
orderStorageDetailInfo1.setStorageWeight(storageWeight);
|
}
|
|
if(storageMoney!=null&&storageMoney.compareTo(BigDecimal.ZERO)!=0){
|
orderStorageDetailInfo1.setStorageMoney(storageMoney.toString());
|
}
|
|
if(storageAmount!=null&&storageAmount.compareTo(BigDecimal.ZERO)!=0){
|
orderStorageDetailInfo1.setStorageAmount(storageAmount);
|
}
|
|
list.add(orderStorageDetailInfo1);
|
}
|
|
storageDetailBatchDto.setList(list);
|
}
|
}
|
|
//获取地称的
|
OrderBatchInfo batchInfo=new OrderBatchInfo();
|
|
String orderId = orderStorageInfo.getOrderId();
|
Example example1=new Example(OrderBatchInfo.class);
|
Example.Criteria criteria1 = example1.createCriteria();
|
criteria1.andEqualTo("orderId",orderId);
|
criteria1.andEqualTo("status",OrderEnum.已入库.getValue());
|
OrderBatchInfo orderBatchInfo = orderBatchInfoMapper.selectOneByExample(example1);
|
|
if(orderBatchInfo!=null){
|
String weight = orderBatchInfo.getWeight();
|
batchInfo.setWeight(weight);
|
|
OrderClockIn today = orderClockInMapper.findToday(orderStorageInfo.getReceiver(), StrUtil.split(orderBatchInfo.getCreateTime(),"")[0]);
|
if(today!=null){
|
batchInfo.setEmptyWeight(today.getWeight());
|
}
|
}
|
|
//获取仓库名称
|
if(Convert.toShort(OrderEnum.打包站.getValue()).equals(sysStorageType)){
|
CityPartner sysStorage = cityPartnerService.findById(Convert.toInt(sysStorageId));
|
if(sysStorage!=null){
|
orderStorageInfo.setSysStorageName(sysStorage.getPartnerName());
|
}
|
}else if(Convert.toShort(OrderEnum.仓库.getValue()).equals(sysStorageType)){
|
SysStorage sysStorage = sysStorageMapper.selectByPrimaryKey(sysStorageId);
|
if(sysStorage!=null){
|
orderStorageInfo.setSysStorageName(sysStorage.getStorageName());
|
}
|
}
|
|
storageDetailBatchDto.setOrderStorageInfo(orderStorageInfo);
|
|
//设置地称信息
|
if(StrUtil.isBlank(batchInfo.getWeight())) {
|
batchInfo.setWeight(Convert.toStr(Constants.WEIGHT_INIT));
|
}
|
if(StrUtil.isBlank(batchInfo.getEmptyWeight())) {
|
batchInfo.setEmptyWeight(Convert.toStr(Constants.WEIGHT_INIT));
|
}
|
storageDetailBatchDto.setOrderBatchInfo(batchInfo);
|
return storageDetailBatchDto;
|
}
|
|
|
/**
|
* 查看回收订单
|
* @param storageId
|
* @return
|
*/
|
public List<OrderDetailInfo> recyledDetail(String storageId) {
|
|
OrderStorageInfo orderStorageInfo = orderStorageInfoMapper.selectByPrimaryKey(storageId);
|
|
if(orderStorageInfo==null){
|
throw new RestException(-1,"入库订单不存在");
|
}
|
|
String orderId = orderStorageInfo.getOrderId();
|
|
|
String[] split = orderId.split(",");
|
|
|
List<OrderDetailInfo> list=new ArrayList<>();
|
for (String s : split) {
|
OrderDetailInfo orderDetailInfo = orderDetailMapper.selectByPrimaryKey(s);
|
//地址
|
Long addressId = orderDetailInfo.getAddressId();
|
AddressInfo addressInfo = addressMapper.selectByPrimaryKey(addressId);
|
orderDetailInfo.setAddress(StrUtil.nullToEmpty(addressInfo.getAddressArea())+addressInfo.getDetailAddress());
|
|
//重新赋值回收员真实名称 源于小程序这边存入的是昵称
|
String receiverPhone = orderDetailInfo.getReceiverPhone();
|
if(StrUtil.isNotBlank(receiverPhone)) {
|
OtherUserInfo otherUserInfo1 = otherUserService.findByMobileAndUserType(receiverPhone,CommonEnum.回收员.getValue());
|
if(otherUserInfo1!=null) {
|
orderDetailInfo.setReceiverName(otherUserInfo1.getName());
|
}
|
}
|
|
//回收的物品
|
OrderItemInfo orderItemInfo=new OrderItemInfo();
|
orderItemInfo.setOrderId(s);
|
List<OrderItemInfo> orderItemInfos = orderItemInfoMapper.select(orderItemInfo);
|
|
List<String> itemTypeNames=new ArrayList<>();
|
if(CollUtil.isNotEmpty(orderItemInfos)){
|
List<OrderItemInfo> collect = orderItemInfos.stream().filter(x -> (StrUtil.isNotBlank(x.getWeight())&&Convert.toBigDecimal(x.getWeight()).compareTo(BigDecimal.ZERO)!=0)||(StrUtil.isNotBlank(x.getAmount())&&Convert.toBigDecimal(x.getAmount()).compareTo(BigDecimal.ZERO)!=0)).collect(Collectors.toList());
|
|
if(CollUtil.isNotEmpty(collect)){
|
|
for (OrderItemInfo itemInfo : collect) {
|
String itemType = itemInfo.getItemType();
|
SysEnvironmentalInfo sysEnvironmentalInfo1 = sysEnvironmentalInfoService.findByItemTypeAndArea(itemType,Convert.toInt(Constants.TIANXIN_CODE));
|
if(sysEnvironmentalInfo1!=null) {
|
itemTypeNames.add(sysEnvironmentalInfo1.getTitle());
|
}
|
}
|
|
|
orderDetailInfo.setItemTypeName(CollUtil.join(itemTypeNames,"、"));
|
}
|
}
|
|
|
list.add(orderDetailInfo);
|
}
|
|
|
return list;
|
|
|
}
|
|
|
/**
|
* 统计
|
* @param userId
|
* @param userType
|
* @return
|
*/
|
public RkStatisticsDto statistics(String userId,String userType,String data,String receiver){
|
RkStatisticsDto rkStatisticsDto=new RkStatisticsDto();
|
RkStatisticsStorageDto rkStatisticsStorageDto=new RkStatisticsStorageDto();
|
RkStatisticsRecyleDto rkStatisticsRecyleDto=new RkStatisticsRecyleDto();
|
Example example=new Example(OrderStorageInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("storageStatus",OrderEnum.已入库.getValue());
|
if(CommonEnum.回收员.getValue().equals(userType)){
|
criteria.andEqualTo("receiver",userId);
|
}else if(CommonEnum.入库员.getValue().equals(userType)||CommonEnum.打包员.getValue().equals(userType)){
|
criteria.andEqualTo("storageUserId",userId);
|
}else if(CommonEnum.打包站运营员.getValue().equals(userType)){
|
criteria.andEqualTo("sysStorageType",OrderEnum.打包站.getValue());
|
String partnerId = otherUserService.findById(userId).getPartnerId();
|
criteria.andEqualTo("sysStorageId",partnerId);
|
}else{
|
throw new RestException(-1,"用户角色不正确");
|
}
|
|
|
/**********入库员*************/
|
example.setOrderByClause("storage_time desc");
|
List<OrderStorageInfo> orderStorageInfos = orderStorageInfoMapper.selectByExample(example);
|
List<OrderStorageInfo> orderStorageInfosToday=new ArrayList<>();
|
//按时间筛选
|
List<OrderStorageInfo> orderStorageInfosTime=new ArrayList<>();
|
if(CollUtil.isNotEmpty(orderStorageInfos)){
|
rkStatisticsStorageDto.setNumSum(orderStorageInfos.size());
|
BigDecimal weight=Constants.WEIGHT_INIT;
|
BigDecimal money=Constants.MONEY_INIT;
|
for (OrderStorageInfo orderStorageInfo : orderStorageInfos) {
|
if(StrUtil.isNotBlank(orderStorageInfo.getStorageTime())&&DateUtil.format(new Date(),DateUtils.DATE_FORMAT_YMD).equals(orderStorageInfo.getStorageTime().split(" ")[0])){
|
orderStorageInfosToday.add(orderStorageInfo);
|
}
|
if(StrUtil.isNotBlank(data)&&StrUtil.isNotBlank(orderStorageInfo.getStorageTime())&&DateUtil.formatDate(DateUtil.parseDate(data)).equals(orderStorageInfo.getStorageTime().split(" ")[0])){
|
orderStorageInfosTime.add(orderStorageInfo);
|
}
|
weight=NumberUtil.add(weight,Convert.toBigDecimal(orderStorageInfo.getStorageWeight()));
|
money=NumberUtil.add(money,Convert.toBigDecimal(orderStorageInfo.getStorageMoney()));
|
}
|
rkStatisticsStorageDto.setStorageMoneySum(money);
|
rkStatisticsStorageDto.setStorageWeightSum(weight);
|
|
//当天入库
|
if(CollUtil.isNotEmpty(orderStorageInfosToday)){
|
rkStatisticsStorageDto.setNum(orderStorageInfosToday.size());
|
BigDecimal weightToday=Constants.WEIGHT_INIT;
|
BigDecimal moneyToday=Constants.MONEY_INIT;
|
for (OrderStorageInfo orderStorageInfo : orderStorageInfosToday) {
|
weightToday=NumberUtil.add(weightToday,Convert.toBigDecimal(orderStorageInfo.getStorageWeight()));
|
moneyToday=NumberUtil.add(moneyToday,Convert.toBigDecimal(orderStorageInfo.getStorageMoney()));
|
}
|
rkStatisticsStorageDto.setStorageMoney(moneyToday);
|
rkStatisticsStorageDto.setStorageWeight(weightToday);
|
}
|
|
|
//按时间入库
|
if(CollUtil.isNotEmpty(orderStorageInfosTime)){
|
|
List<RkStatisticsStorageReceiverDto> receiverList=new ArrayList<>();
|
if(StrUtil.isNotBlank(receiver)){
|
BigDecimal weightToday=Constants.WEIGHT_INIT;
|
BigDecimal moneyToday=Constants.MONEY_INIT;
|
//根据回收员筛选
|
List<OrderStorageInfo> collect = orderStorageInfosTime.stream().filter(x -> receiver.equals(x.getReceiver())).collect(Collectors.toList());
|
for (OrderStorageInfo orderStorageInfo : collect) {
|
weightToday=NumberUtil.add(weightToday,Convert.toBigDecimal(orderStorageInfo.getStorageWeight()));
|
moneyToday=NumberUtil.add(moneyToday,Convert.toBigDecimal(orderStorageInfo.getStorageMoney()));
|
}
|
RkStatisticsStorageReceiverDto dto=new RkStatisticsStorageReceiverDto();
|
OtherUserInfo byId = otherUserService.findById(receiver);
|
dto.setUserId(byId.getUserId());
|
dto.setAvatar(byId.getAvatar());
|
dto.setName(byId.getName());
|
dto.setMoney(businessUtil.changeMoney(moneyToday));
|
dto.setWeight(businessUtil.changeWeight(weightToday.toString()));
|
dto.setTime(data);
|
receiverList.add(dto);
|
}else {
|
//按回收员分组
|
Map<String, List<OrderStorageInfo>> collect = orderStorageInfosTime.stream().collect(Collectors.groupingBy(x -> x.getReceiver()));
|
for (String s : collect.keySet()) {
|
BigDecimal weightToday=Constants.WEIGHT_INIT;
|
BigDecimal moneyToday=Constants.MONEY_INIT;
|
RkStatisticsStorageReceiverDto dto=new RkStatisticsStorageReceiverDto();
|
OtherUserInfo byId = otherUserService.findById(s);
|
dto.setUserId(byId.getUserId());
|
dto.setAvatar(byId.getAvatar());
|
dto.setName(byId.getName());
|
for (OrderStorageInfo orderStorageInfo : collect.get(s)) {
|
weightToday=NumberUtil.add(weightToday,Convert.toBigDecimal(orderStorageInfo.getStorageWeight()));
|
moneyToday=NumberUtil.add(moneyToday,Convert.toBigDecimal(orderStorageInfo.getStorageMoney()));
|
}
|
dto.setMoney(businessUtil.changeMoney(moneyToday));
|
dto.setWeight(businessUtil.changeWeight(weightToday.toString()));
|
dto.setTime(data);
|
receiverList.add(dto);
|
}
|
}
|
rkStatisticsStorageDto.setReceiverList(receiverList);
|
}
|
|
|
//回收员赋值入库信息
|
if(CommonEnum.回收员.getValue().equals(userType)) {
|
BeanUtils.copyProperties(rkStatisticsStorageDto, rkStatisticsRecyleDto);
|
rkStatisticsRecyleDto.setNum(0);
|
rkStatisticsRecyleDto.setNumSum(0);
|
}
|
}
|
|
/**********回收员*************/
|
if(CommonEnum.回收员.getValue().equals(userType)){
|
List<OrderDetailInfo> orderRecyleInfosToday=new ArrayList<>();
|
List<OrderDetailInfo> orderInfos = orderDetailService.findByReceiver(userId);
|
if(CollUtil.isNotEmpty(orderInfos)){
|
rkStatisticsRecyleDto.setNumSum(orderInfos.size());
|
BigDecimal weight=Constants.WEIGHT_INIT;
|
BigDecimal money=Constants.MONEY_INIT;
|
for (OrderDetailInfo orderInfo : orderInfos) {
|
if(StrUtil.isNotBlank(orderInfo.getCompleteTime())&&DateUtil.format(new Date(),DateUtils.DATE_FORMAT_YMD).equals(orderInfo.getCompleteTime().split(" ")[0])){
|
orderRecyleInfosToday.add(orderInfo);
|
}
|
weight=NumberUtil.add(weight,Convert.toBigDecimal(orderInfo.getWeight()));
|
money=NumberUtil.add(money,Convert.toBigDecimal(orderInfo.getMoney()));
|
}
|
rkStatisticsRecyleDto.setRecycleMoneySum(money);
|
rkStatisticsRecyleDto.setRecycleWeightSum(weight);
|
|
if(CollUtil.isNotEmpty(orderRecyleInfosToday)){
|
rkStatisticsRecyleDto.setNum(orderRecyleInfosToday.size());
|
BigDecimal weightToday=Constants.WEIGHT_INIT;
|
BigDecimal moneyToday=Constants.MONEY_INIT;
|
for (OrderDetailInfo orderStorageInfo : orderRecyleInfosToday) {
|
weightToday=NumberUtil.add(weightToday,Convert.toBigDecimal(orderStorageInfo.getWeight()));
|
moneyToday=NumberUtil.add(moneyToday,Convert.toBigDecimal(orderStorageInfo.getMoney()));
|
}
|
rkStatisticsRecyleDto.setRecycleMoney(moneyToday);
|
rkStatisticsRecyleDto.setRecycleWeight(weightToday);
|
}
|
}
|
}
|
|
if(CommonEnum.回收员.getValue().equals(userType)){
|
rkStatisticsDto.setRkStatisticsRecyleDto(rkStatisticsRecyleDto);
|
}else{
|
rkStatisticsDto.setStatisticsStorageDto(rkStatisticsStorageDto);
|
}
|
return rkStatisticsDto;
|
}
|
|
/**
|
* 入库
|
* @param rk
|
*/
|
public void rk(RkDto rk){
|
boolean lock=false;
|
try {
|
if(redisUtil.setnx(Constants.REDIS_ORDER_KEY+"rk:"+rk.getStorageId(),rk.getStorageId())) {
|
lock=true;
|
|
|
String now = DateUtil.now();
|
OtherUserInfo otherUserInfo = otherUserMapper.selectByPrimaryKey(rk.getStorageUserId());
|
//修改入库信息
|
Example example = new Example(OrderStorageInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("storageId", rk.getStorageId());
|
OrderStorageInfo orderStorageInfo = orderStorageInfoMapper.selectOneByExample(example);
|
if (orderStorageInfo == null) {
|
throw new RestException(-1, "入库单不存在");
|
}
|
|
Map map = new HashMap();
|
map.put("userId", orderStorageInfo.getReceiver());
|
List<AccountVo> receiverAccounts = accountMapper.queryMyMoney(map);
|
if(CollUtil.isEmpty(receiverAccounts)){
|
throw new RestException(-1, "回收员账户已被禁用");
|
}
|
|
//检验是否已入库
|
if (orderStorageInfo.getStorageStatus().toString().equals(OrderEnum.已入库.getValue())) {
|
throw new RestException(-1, "订单已入库");
|
}
|
orderStorageInfo.setStorageUserId(rk.getStorageUserId());
|
orderStorageInfo.setStorageUserName(otherUserInfo.getName());
|
orderStorageInfo.setStorageUserPhone(otherUserInfo.getMobilePhone());
|
orderStorageInfo.setStorageTime(now);
|
orderStorageInfo.setStorageWeight(rk.getStorageWeight());
|
orderStorageInfo.setStorageMoney(Convert.toBigDecimal(rk.getStorageMoney()));
|
|
int usertype=0;
|
String packageId=null;
|
if(otherUserInfo.getUserType().equals(CommonEnum.打包员.getValue())||otherUserInfo.getUserType().equals(CommonEnum.打包站运营员.getValue())) {
|
usertype = 2;
|
packageId = otherUserInfo.getPartnerId();
|
}else if(otherUserInfo.getUserType().equals(CommonEnum.入库员.getValue())){
|
usertype=1;
|
}
|
Map map2 = new HashMap();
|
map2.put("userId", rk.getStorageUserId());
|
List<AccountVo> storageAccount = accountMapper.queryMyMoney(map2);
|
if(CollUtil.isEmpty(storageAccount)){
|
throw new RestException(-1, "账户已被禁用");
|
}
|
AccountVo accountVo = storageAccount.get(0);
|
String overdraftLimit = accountVo.getOverdraftLimit();
|
BigDecimal limit = Convert.toBigDecimal(overdraftLimit, Constants.MONEY_INIT);
|
BigDecimal moneyDecimal=Convert.toBigDecimal(rk.getStorageMoney());
|
BigDecimal moneyDB = Convert.toBigDecimal(accountVo.getMoney(), Constants.MONEY_INIT);
|
if(usertype==2) {
|
if (NumberUtil.isLess(NumberUtil.add(limit, moneyDB), moneyDecimal)) {
|
throw new RestException(-1, "额度不足");
|
}
|
}else if(usertype==1){
|
//判断仓管员额度是否足够
|
if (NumberUtil.isGreater(moneyDecimal, limit)) {
|
throw new RestException(-1, "额度不足");
|
}
|
}
|
|
orderStorageInfo.setStorageStatus(Convert.toShort(OrderEnum.已入库.getValue()));
|
|
if(usertype==1){
|
//仓库ID 地磅必须在入库才知道入库id
|
OtherUserInfo byId = otherUserService.findById(rk.getStorageUserId());
|
orderStorageInfo.setSysStorageId(Convert.toLong(byId.getStorageId()));
|
}
|
|
//查询废纸分类的单价 合伙人存在多个区域则按最低的单价算
|
String paperBasic=null;
|
String partnerId = otherUserService.findById(orderStorageInfo.getReceiver()).getPartnerId();
|
List<PartnerGaode> byPartnerId = partnerGaodeService.findByPartnerId(partnerId);
|
List<String> areaIds=byPartnerId.stream().map(x->x.getTownId()).collect(Collectors.toList());
|
if(usertype==2) {
|
paperBasic = sysEnvironmentalInfoService.findByMinItemPriceTypeAndAreaIds(areaIds);
|
if (paperBasic==null) {
|
throw new RestException(-1,"请设置纸类的基准价格");
|
}
|
}
|
|
|
orderStorageInfoMapper.updateByPrimaryKeySelective(orderStorageInfo);
|
OrderBatchInfo orderBatchInfo = new OrderBatchInfo();
|
orderBatchInfo.setStatus(Convert.toShort(OrderEnum.已入库.getValue()));
|
Example example1 = new Example(OrderBatchInfo.class);
|
example1.createCriteria().andEqualTo("orderId", orderStorageInfo.getOrderId());
|
//修改批次信息
|
orderBatchInfoMapper.updateByExampleSelective(orderBatchInfo, example1);
|
//修改物品分类信息
|
List<WeightItemPrice> list=new ArrayList<>();
|
|
BigDecimal paperWeight=BigDecimal.ZERO;
|
//纸类的所有小类集合
|
List<String> paperChildType=CollUtil.newArrayList();
|
if(usertype==2) {
|
paperChildType = packageGoodsInfoService.findChildItemTypeByType(packageId, Constants.PAPER_ITEM_TYPE);
|
}
|
for (OrderItemDto orderItemReq : rk.getStorageItemList()) {
|
//修改入库的金额 和数量 重量
|
OrderStorageDetailInfo detailInfo = new OrderStorageDetailInfo();
|
detailInfo.setWeight(Convert.toBigDecimal(orderItemReq.getWeight(),Constants.WEIGHT_INIT));
|
detailInfo.setMoney(orderItemReq.getMoney());
|
detailInfo.setAmount(orderItemReq.getAmount());
|
detailInfo.setPrice(orderItemReq.getItemTypePrice());
|
|
Example example2 = new Example(OrderStorageDetailInfo.class);
|
Example.Criteria criteria2 = example2.createCriteria();
|
criteria2.andEqualTo("storageId", rk.getStorageId());
|
criteria2.andEqualTo("flag", OrderEnum.入库型.getValue());
|
criteria2.andEqualTo("itemType", orderItemReq.getItemType());
|
orderStorageDetailMapper.updateByExampleSelective(detailInfo, example2);
|
|
if(usertype==2) {
|
|
if(orderItemReq.getWeight().compareTo(BigDecimal.ZERO)>0){
|
//计算出所有纸类的重量
|
if(paperChildType.contains(orderItemReq.getItemType())){
|
paperWeight=NumberUtil.add(paperWeight,orderItemReq.getWeight());
|
}
|
}
|
|
//提成明细
|
if (detailInfo.getWeight().compareTo(BigDecimal.ZERO) > 0) {
|
WeightItemPrice weightItemPrice = new WeightItemPrice();
|
weightItemPrice.setStorageId(rk.getStorageId());
|
weightItemPrice.setStorageTime(now);
|
weightItemPrice.setPackageId(orderStorageInfo.getSysStorageId().toString());
|
weightItemPrice.setWeight(detailInfo.getWeight().toString());
|
weightItemPrice.setReceiver(orderStorageInfo.getReceiver());
|
weightItemPrice.setProductType(orderItemReq.getItemType());
|
weightItemPrice.setPackagePrice(orderItemReq.getItemTypePrice());
|
weightItemPrice.setGoodsPrice(paperBasic);
|
//1:未审核，2：已审核 3：异常
|
weightItemPrice.setStatus("1");
|
list.add(weightItemPrice);
|
}
|
}
|
|
}
|
|
//添加提成明细
|
if(CollUtil.isNotEmpty(list)){
|
weightItemPriceService.addBatch(list);
|
}
|
|
String payType="";
|
//修改订单相关
|
int i=0;
|
|
List<OrderInfo> listOrder=new ArrayList<>();
|
for (String orderId : orderStorageInfo.getOrderId().split(",")) {
|
|
//修改订单信息
|
OrderInfo orderInfo = new OrderInfo();
|
orderInfo.setOrderId(orderId);
|
orderInfo.setOrderStatus(OrderEnum.完成.getValue());
|
listOrder.add(orderInfo);
|
// orderMapper.updateByPrimaryKeySelective(orderInfo);
|
|
if(i==0) {
|
PayInfo payInfo = new PayInfo();
|
payInfo.setOrderId(orderId);
|
payInfo.setCreateUserId(orderStorageInfo.getReceiver());
|
List<PayInfo> select = payInfoMapper.select(payInfo);
|
if (CollUtil.isNotEmpty(select)) {
|
String payType1 = select.get(0).getPayType();
|
if (PayEnum.现金支出.getValue().equals(payType1) || PayEnum.现金收入.getValue().equals(payType1)) {
|
payType = PayEnum.现金支出.getValue();
|
} else {
|
payType = PayEnum.环保金支出.getValue();
|
}
|
}
|
}
|
//修改订单详情信息 冗余字段暂时废弃
|
// OrderDetailInfo orderDetailInfo = new OrderDetailInfo();
|
// orderDetailInfo.setStorageMoney(Convert.toStr(rk.getStorageMoney()));
|
// orderDetailInfo.setStorageUserId(orderStorageInfo.getStorageUserId());
|
// orderDetailInfo.setStorageUserName(orderStorageInfo.getStorageUserName());
|
// orderDetailInfo.setStorageUserPhone(orderStorageInfo.getStorageUserPhone());
|
// Example example2 = new Example(OrderDetailInfo.class);
|
// example2.createCriteria().andEqualTo("orderId", orderId);
|
// orderDetailMapper.updateByExampleSelective(orderDetailInfo, example2);
|
i++;
|
}
|
|
//批量修改订单状态
|
if(CollUtil.isNotEmpty(listOrder)){
|
orderBatchMapper.updateBatchByPrimaryKeySelective(listOrder);
|
}
|
|
OrderInfoReq orderInfoReq = new OrderInfoReq();
|
orderInfoReq.setNewVersion(true);
|
orderInfoReq.setReceiver(orderStorageInfo.getReceiver());
|
orderInfoReq.setStorageUserId(orderStorageInfo.getStorageUserId());
|
orderInfoReq.setPayType(payType);
|
orderInfoReq.setStorageMoney(Convert.toStr(rk.getStorageMoney()));
|
orderInfoReq.setOrderId(orderStorageInfo.getOrderId());
|
orderInfoReq.setStorageId(orderStorageInfo.getStorageId());
|
orderInfoReq.setVersion(rk.getVersion());
|
if(paperBasic!=null){
|
orderInfoReq.setPaperMoney(NumberUtil.mul(Convert.toBigDecimal(paperBasic),paperWeight));
|
}
|
//录入支付记录
|
AccountVo receiverAccount=receiverAccounts.get(0);
|
// orderService.storageOperInfo(orderInfoReq, orderStorageInfo.getStorageId(), now, accountId);
|
//更改账户信息
|
orderService.storageAccount(orderInfoReq, receiverAccount,accountVo,usertype,partnerId);
|
|
//推广返利
|
AllAcountParamDto allAcountParamDto=AllAcountParamDto.builder().
|
type(6).flowNo(orderStorageInfo.getOrderId()).userId(orderInfoReq.getStorageUserId())
|
.build();
|
// accountFactory.getService(6).account(allAcountParamDto);
|
new AccountContext(promotionRebateService).account(allAcountParamDto);
|
|
//入库消息
|
orderService.storageMessage(orderInfoReq, now);
|
|
//删除回收员的入库错误次数
|
redisUtil.hdel(Constants.REDIS_ORDER_KEY + "storage:errcount", orderStorageInfo.getReceiver());
|
}
|
} catch (RestException e){
|
throw new BusinessException(-1,e.getMsg(),ExceptionUtil.getMessage(e));
|
}catch (Exception e) {
|
ExceptionUtils.err("入库失败",e);
|
}finally {
|
if(lock) {
|
redisUtil.del(Constants.REDIS_ORDER_KEY + "rk:" + rk.getStorageId());
|
}
|
}
|
|
|
}
|
|
|
/**
|
* 已完成订单列表查询
|
* @param simplePage
|
* @param userId
|
* @return
|
*/
|
public List<OrderStorageInfo> findCompleteOrder(SimplePage simplePage,String userId){
|
Example example=new Example(OrderStorageInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("storageStatus",Convert.toShort(0));
|
//rk代表入库员已完成列表查询接口
|
if(StrUtil.isBlank(simplePage.getExtra())){
|
criteria.andEqualTo("receiver",userId);
|
}else{
|
criteria.andEqualTo("storageUserId",userId);
|
}
|
example.setOrderByClause("storage_time desc");
|
PageHelper.startPage(simplePage.getPageNo(),simplePage.getPageSize());
|
List<OrderStorageInfo> select = orderStorageInfoMapper.selectByExample(example);
|
//查看是否是定点下单 不可能混合 否则会拆分成2个入库单
|
if(CollUtil.isNotEmpty(select)){
|
for (OrderStorageInfo orderStorageInfo : select) {
|
// String orderId = orderStorageInfo.getOrderId();
|
// String s = orderId.split(",")[0];
|
// OrderInfo orderInfo = orderMapper.selectByPrimaryKey(s);
|
// if(orderInfo!=null) {
|
// orderStorageInfo.setStoreId(orderInfo.getStoreId());
|
// }
|
String weight = orderStorageInfo.getStorageWeight();
|
String recycleWeight = orderStorageInfo.getRecycleWeight();
|
if(StrUtil.isBlank(weight)){
|
orderStorageInfo.setStorageWeight(Constants.WEIGHT_INIT.toString());
|
}
|
if(StrUtil.isBlank(recycleWeight)){
|
orderStorageInfo.setRecycleWeight(Constants.WEIGHT_INIT.toString());
|
}
|
|
}
|
}
|
//如果是入库员 需要显示回收员名字和其所属的车辆编号
|
if(StrUtil.isNotBlank(simplePage.getExtra())) {
|
for (OrderStorageInfo orderStorageInfo : select) {
|
String receiver = orderStorageInfo.getReceiver();
|
orderStorageInfo.setReceiverName(otherUserService.findById(receiver).getName());
|
VehicleInfo byUserId = userVehicleInfoService.findByUserId(receiver);
|
if (byUserId != null) {
|
orderStorageInfo.setVehicleNo(byUserId.getVehicleNo());
|
}
|
}
|
}else {
|
//回收员
|
for (OrderStorageInfo orderStorageInfo : select) {
|
String orderId = orderStorageInfo.getOrderId();
|
String[] split = orderId.split(",");
|
if(ArrayUtil.isNotEmpty(split)&&split.length==1){
|
orderId=split[0];
|
OrderInfo byId = orderService.findById(orderId);
|
//设置订单状态
|
orderStorageInfo.setOrderType(byId.getOrderType());
|
|
if(OrderEnum.到家服务.getValue().equals(byId.getOrderType())){
|
orderStorageInfo.setRelaPhone(byId.getRelaPhone());
|
orderStorageInfo.setCreateUserId(byId.getCreateUserId());
|
orderStorageInfo.setOrderId(byId.getOrderId());
|
}else if(OrderEnum.家电回收.getValue().equals(byId.getOrderType())){
|
OrderDetailInfo byId1 = orderDetailService.findById(orderId);
|
Long homeApplianceId = byId1.getHomeApplianceId();
|
//家电下单的家电信息
|
if(homeApplianceId!=null) {
|
OrderHomeAppliance byOrderId = orderHomeApplianceService.findById(homeApplianceId);
|
orderStorageInfo.setOrderHomeAppliance(byOrderId);
|
}
|
}
|
|
|
}
|
}
|
}
|
return select;
|
}
|
|
/**
|
* 已完成订单列表个数
|
* @return
|
*/
|
public int countCompleteOrder(String userId){
|
Example example=new Example(OrderStorageInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("storageStatus",Convert.toShort(OrderEnum.已入库.getValue()));
|
criteria.andEqualTo("storageUserId",userId);
|
int select = orderStorageInfoMapper.selectCountByExample(example);
|
return select;
|
}
|
|
/**
|
* 新任务订单列表个数
|
* @return
|
*/
|
public int countStorageOrder(String userId){
|
Example example=new Example(OrderStorageInfo.class);
|
Example.Criteria criteria = example.createCriteria();
|
criteria.andEqualTo("storageStatus",Convert.toShort(OrderEnum.入库检验中.getValue()));
|
criteria.andEqualTo("storageUserId",userId);
|
int select = orderStorageInfoMapper.selectCountByExample(example);
|
return select;
|
}
|
|
|
|
/**
|
* 手动扫码入库新任务详情
|
*
|
* @param request
|
* @param userId
|
* @param usertype 1入库 2打包
|
* @return
|
*/
|
public Result<RkDto> rkDetail(HttpServletRequest request, String userId, int usertype, String packageId) {
|
Result<RkDto> result = new Result();
|
RkDto rk = new RkDto();
|
|
String key=Constants.REDIS_ORDER_KEY+"rkscan:"+request.getHeader("userId");
|
if(redisUtil.setnx(key,"0")) {
|
|
try {
|
//获取用户所有待入库订单
|
List<OrderInfo> orderInfos = orderService.findDetailByReceiverAndStatus(userId, OrderEnum.待入库.getValue());
|
if (CollUtil.isEmpty(orderInfos)) {
|
return Result.error(-1, "没有待入库的订单");
|
}
|
|
|
//定点回收
|
List<String> collect1 = orderInfos.stream().filter(x -> x.getStoreId() != null).map(OrderInfo::getOrderId).collect(Collectors.toList());
|
|
//上门回收
|
List<String> collect2 = orderInfos.stream().filter(x -> x.getStoreId() == null).map(OrderInfo::getOrderId).collect(Collectors.toList());
|
|
//1为上门 2为定点
|
int type = 0;
|
|
Dict dict = null;
|
if (CollUtil.isNotEmpty(collect1)) {
|
type = 2;
|
String storageId = idUtils.generate("RK", 0);
|
dict = orderBatchInfoService.addDB(userId, collect1, storageId, usertype, packageId);
|
}
|
|
if (CollUtil.isNotEmpty(collect2)) {
|
type = 1;
|
String storageId = idUtils.generate("RK", 2);
|
dict = orderBatchInfoService.addDB(userId, collect2, storageId, usertype, packageId);
|
}
|
|
|
//混合订单直接返回到列表
|
if (CollUtil.isNotEmpty(collect1) && CollUtil.isNotEmpty(collect2)) {
|
rk.setMixOrder(true);
|
result.setData(rk);
|
return result;
|
}
|
|
List<OrderItemDto> orderItemDtos = new ArrayList<>();
|
List<OrderStorageDetailInfo> select = (List<OrderStorageDetailInfo>) dict.get("detail");
|
//设置分类
|
setItem(rk, orderItemDtos, select, usertype, packageId);
|
rk.setStorageUserId(request.getHeader("userId"));
|
rk.setStorageId(dict.getStr("storageId"));
|
OrderInfoReq orderInfoReq = new OrderInfoReq();
|
orderInfoReq.setReceiver(userId);
|
List<String> strings = orderMapper.fwOrderListByUserId(orderInfoReq);
|
if (CollUtil.isNotEmpty(strings)) {
|
rk.setFwOrderNum(strings.size());
|
}
|
//回收金额
|
String recycleMoney = dict.getStr("recycleMoney");
|
rk.setMoney(recycleMoney);
|
result.setData(rk);
|
} catch (Exception e) {
|
ExceptionUtils.err("扫码入库失败",e);
|
} finally {
|
redisUtil.del(key);
|
}
|
return result;
|
}else {
|
throw new RestException(-1,"二维码已被扫码");
|
}
|
|
}
|
|
|
/**
|
* 设置分类信息
|
* @param rk
|
* @param orderItemDtos
|
* @param select
|
*/
|
public void setItem(RkDto rk, List<OrderItemDto> orderItemDtos, List<OrderStorageDetailInfo> select, int usertype, String packageId) {
|
//入库根据仓库所属地查看价格
|
Long parentId = null;
|
|
if (usertype == 1) {
|
SysStorage byId1 = sysStorageService.findById(Convert.toInt(packageId));
|
Integer areaId = Convert.toInt(byId1.getArea());
|
SysEnvironmentalInfo sysEnvironmentalInfo2 = sysEnvironmentalInfoService.findByItemTypeAndArea(Constants.HOUSE_HOLD_ITEM_TYPE,areaId);
|
if (sysEnvironmentalInfo2 != null) {
|
parentId = sysEnvironmentalInfo2.getId();
|
}
|
if (CollUtil.isNotEmpty(select)) {
|
for (OrderStorageDetailInfo detailInfo : select) {
|
OrderItemDto orderItemDto = new OrderItemDto();
|
BeanUtils.copyProperties(detailInfo, orderItemDto);
|
|
//设置分类名称和图片
|
String itemType = detailInfo.getItemType();
|
SysEnvironmentalInfo sysEnvironmentalInfo1 = null;
|
sysEnvironmentalInfo1 = sysEnvironmentalInfoService.findByItemTypeAndArea(itemType, areaId);
|
|
if (sysEnvironmentalInfo1 != null) {
|
|
|
Long parentId1 = sysEnvironmentalInfo1.getParentId();
|
if (parentId != null && parentId.intValue() == (parentId1.intValue())) {
|
orderItemDto.setHouseHold(true);
|
BigDecimal mul = NumberUtil.mul(Convert.toBigDecimal(sysEnvironmentalInfo1.getPutStoragePrice()), Convert.toBigDecimal(orderItemDto.getAmount(), Constants.MONEY_INIT));
|
orderItemDto.setMoney(businessUtil.changeMoney(mul));
|
}else {
|
BigDecimal mul = NumberUtil.mul(Convert.toBigDecimal(sysEnvironmentalInfo1.getPutStoragePrice()), Convert.toBigDecimal(orderItemDto.getWeight(), Constants.MONEY_INIT));
|
orderItemDto.setMoney(businessUtil.changeMoney(mul));
|
}
|
orderItemDto.setItemPic(sysEnvironmentalInfo1.getPicture());
|
orderItemDto.setItemName(sysEnvironmentalInfo1.getTitle());
|
orderItemDto.setItemTypePrice(sysEnvironmentalInfo1.getPutStoragePrice().toString());
|
// if (type == 1) {
|
// orderItemDto.setItemTypePrice(sysEnvironmentalInfo1.getPutStoragePrice().toString());
|
// } else if (type == 2) {
|
// orderItemDto.setItemTypePrice(sysEnvironmentalInfo1.getSecondPrice());
|
// }
|
|
//查找父类的itemType
|
SysEnvironmentalInfo byId = null;
|
byId = sysEnvironmentalInfoService.findById(parentId1);
|
if (byId != null) {
|
orderItemDto.setParentItemType(byId.getItemType());
|
}
|
orderItemDtos.add(orderItemDto);
|
}
|
}
|
//按重量降序排序
|
List<OrderItemDto> collect = orderItemDtos.stream().sorted(Comparator.comparing(OrderItemDto::getWeight).reversed()).collect(Collectors.toList());
|
rk.setStorageItemList(collect);
|
}
|
} else if (usertype == 2) {
|
List<PackageGoodsInfo> byPackageId = packageGoodsInfoService.findByPackageId(packageId);
|
if (CollUtil.isNotEmpty(byPackageId)) {
|
for (PackageGoodsInfo packageGoodsInfo : byPackageId) {
|
OrderItemDto orderItemDto = new OrderItemDto();
|
orderItemDto.setAmount("0");
|
orderItemDto.setWeight(Constants.WEIGHT_INIT);
|
orderItemDto.setMoney(Constants.MONEY_INIT.toString());
|
orderItemDto.setItemType(packageGoodsInfo.getItemType());
|
//设置分类名称和图片
|
Long parentId1 = packageGoodsInfo.getParentId();
|
if (parentId != null && parentId.intValue() == (parentId1.intValue())) {
|
orderItemDto.setHouseHold(true);
|
}
|
orderItemDto.setItemPic(packageGoodsInfo.getPicture());
|
orderItemDto.setItemName(packageGoodsInfo.getTitle());
|
|
orderItemDto.setItemTypePrice(packageGoodsInfo.getPutStoragePrice().toString());
|
// if (type == 1) {
|
// orderItemDto.setItemTypePrice(packageGoodsInfo.getPrice());
|
// } else if (type == 2) {
|
// orderItemDto.setItemTypePrice(packageGoodsInfo.getSecondPrice());
|
// }
|
|
//查找父类的itemType
|
SysEnvironmentalInfo byId = null;
|
packageGoodsInfo = packageGoodsInfoService.findById(parentId1);
|
if (packageGoodsInfo != null) {
|
byId = new SysEnvironmentalInfo();
|
BeanUtil.copyProperties(packageGoodsInfo, byId);
|
}
|
if (byId != null) {
|
orderItemDto.setParentItemType(byId.getItemType());
|
}
|
orderItemDtos.add(orderItemDto);
|
}
|
rk.setStorageItemList(orderItemDtos);
|
}
|
|
}
|
|
}
|
|
|
}
|
