package com.example.erp.service.sd;
|
|
import com.alibaba.excel.util.StringUtils;
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.alibaba.fastjson.TypeReference;
|
import com.baomidou.dynamic.datasource.annotation.DS;
|
import com.example.erp.dto.mm.FinishedOperateLogDTO;
|
import com.example.erp.dto.sd.DeliveryDetailDTO;
|
import com.example.erp.dto.sd.DeliveryDetailProductDTO;
|
import com.example.erp.entity.mm.FinishedOperateLog;
|
import com.example.erp.entity.sd.*;
|
import com.example.erp.entity.userInfo.Log;
|
import com.example.erp.entity.userInfo.SysError;
|
import com.example.erp.mapper.mm.FinishedGoodsInventoryMapper;
|
import com.example.erp.mapper.mm.FinishedOperateLogMapper;
|
import com.example.erp.mapper.sd.*;
|
import com.example.erp.service.mm.FinishedGoodsInventoryService;
|
import com.example.erp.service.userInfo.LogService;
|
import com.example.erp.service.userInfo.SysErrorService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
|
import java.lang.reflect.Field;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicReference;
|
|
@Service
|
@DS("sd")
|
@Transactional(rollbackFor = Exception.class)
|
public class DeliveryService {
|
@Autowired
|
DeliveryMapper deliveryMapper;
|
@Autowired
|
DeliveryDetailMapper deliveryDetailMapper;
|
@Autowired
|
OrderMapper orderMapper;
|
@Autowired
|
OrderDetailMapper orderDetailMapper;
|
@Autowired
|
FinishedGoodsInventoryMapper finishedGoodsInventoryMapper;
|
@Autowired
|
FinishedOperateLogMapper finishedOperateLogMapper;
|
@Autowired
|
DeliveryOtherMoneyMapper deliveryOtherMoneyMapper;
|
@Autowired
|
LogService logService;
|
@Autowired
|
SysErrorService sysErrorService;
|
@Autowired
|
FinishedGoodsInventoryService finishedGoodsInventoryService;
|
|
|
public Map<String, Object> getSelectShippingOrder(Integer pageNum, Integer pageSize,List<String> selectDate, Delivery delivery) {
|
Integer offset = (pageNum - 1) * pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", deliveryMapper.getSelectShippingOrder(offset, pageSize,startDate,endDate, delivery));
|
map.put("total", deliveryMapper.getSelectShippingOrderPageTotal(offset, pageSize,startDate,endDate, delivery));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
public Map<String, Object> getSelectDeliveryDetailReport(Integer pageNum, Integer pageSize,List<String> selectDate, DeliveryDetail deliveryDetail) {
|
Integer offset = (pageNum - 1) * pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", deliveryDetailMapper.getSelectDeliveryDetailReport(offset, pageSize,startDate,endDate, deliveryDetail));
|
map.put("total", deliveryDetailMapper.getSelectDeliveryDetailReportPageTotal(offset, pageSize,startDate,endDate, deliveryDetail));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
public Map<String, Object> getSelectDeliveryDetailProductReport(Integer pageNum, Integer pageSize,List<String> selectDate, DeliveryDetail deliveryDetail) {
|
Integer offset = (pageNum - 1) * pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", deliveryDetailMapper.getSelectDeliveryDetailProductReport(offset, pageSize,startDate,endDate, deliveryDetail));
|
map.put("total", deliveryDetailMapper.getSelectDeliveryDetailProductReportPageTotal(offset, pageSize,startDate,endDate, deliveryDetail));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
public Map<String, Object> getSelectShippingOrderDetail(Integer pageNum, Integer pageSize, OrderDetail orderDetail) {
|
Integer offset = (pageNum - 1) * pageSize;
|
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", deliveryDetailMapper.getSelectShippingOrderDetail(offset, pageSize, orderDetail));
|
map.put("delivery", deliveryMapper.getSelectShippingOrderDetailDelivery(offset, pageSize, orderDetail));
|
map.put("total", deliveryDetailMapper.getSelectShippingOrderDetailPageTotal(offset, pageSize, orderDetail));
|
map.put("orderOtherMoneyList",deliveryOtherMoneyMapper.findById(orderDetail.getDeliveryDetail().getDeliveryId()));
|
|
return map;
|
}
|
|
public Map<String, Object> getSelectOrderInventory(Integer pageNum, Integer pageSize,List<String> selectDate, Order order) {
|
Integer offset = (pageNum - 1) * pageSize;
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(15).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", deliveryMapper.getSelectOrderInventory(offset, pageSize,startDate,endDate, order));
|
map.put("total", deliveryMapper.getSelectOrderInventoryPageTotal(offset, pageSize,startDate,endDate, order));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
public Map<String, Object> getSelectShippingOrderDetails(Integer pageNum, Integer pageSize, OrderDetail orderDetail) {
|
Integer offset = (pageNum - 1) * pageSize;
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", deliveryDetailMapper.getSelectShippingOrderDetails(offset, pageSize, orderDetail));
|
map.put("title", deliveryMapper.getSelectShippingOrderDetailDeliverys(offset, pageSize, orderDetail));
|
map.put("total", deliveryDetailMapper.getSelectShippingOrderDetailsPageTotal(offset, pageSize, orderDetail));
|
return map;
|
}
|
|
public String insertDelivery(Map<String,Object> object) {
|
|
String saveState = "true";
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
|
try {
|
String deliveryId="";
|
String oddNumber;
|
if (object.get("deliveryId") != null) {
|
deliveryId = object.get("deliveryId").toString();
|
} else {
|
deliveryId = "";
|
}
|
String deliveryIdType = object.get("deliveryIdType").toString();
|
Delivery delivery = JSONObject.parseObject(JSONObject.toJSONString(object.get("title")), Delivery.class);
|
List<OrderDetail> orderDetaillist = JSONArray.parseArray(JSONObject.toJSONString(object.get("delivery")), OrderDetail.class);
|
List<DeliveryOtherMoney> deliveryOtherMoneyList = JSONArray.parseArray(JSONObject.toJSONString(object.get("otherMoney")), DeliveryOtherMoney.class);
|
//查询发货单是否存在
|
Integer deliveryConut = deliveryMapper.getDeliveryConut(deliveryId);
|
|
Log log = new Log();
|
log.setOperator(delivery.getCreator());
|
log.setOperatorId(delivery.getCreatorId());
|
log.setContent(object.toString());
|
|
if (deliveryConut != 0) {
|
//编辑还原数据
|
String deliveryDetailNumber = "";
|
if (!orderDetaillist.isEmpty()) {
|
for (OrderDetail orderDetail : orderDetaillist) {
|
if (orderDetaillist.size() - 1 == orderDetaillist.indexOf(orderDetail)) {
|
deliveryDetailNumber += orderDetail.getDeliveryDetail().getDeliveryNumber();
|
} else {
|
deliveryDetailNumber += orderDetail.getDeliveryDetail().getDeliveryNumber() + "|";
|
}
|
|
}
|
}
|
|
List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryId);
|
if (!deliveryDetaillist.isEmpty()) {
|
for (DeliveryDetail deliveryDetail : deliveryDetaillist) {
|
//还原库存数以及订单明细的发货数
|
finishedGoodsInventoryMapper.updateInventoryquantityInt(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
|
deliveryDetailMapper.updateIsNotOrderDetailDeliveryNum(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
|
}
|
}
|
//还原发货表的面积数量金额
|
deliveryMapper.updatedelivery(0.0, 0, 0.0,0.0, deliveryId);
|
//删除发货明细的数据
|
deliveryDetailMapper.deleteDeliveryDetail(deliveryId);
|
//删除订单额外金额的数据
|
deliveryOtherMoneyMapper.deleteDeliveryOtherMoney(deliveryId);
|
oddNumber = deliveryId;
|
deliveryMapper.updateDelivery(delivery, oddNumber, orderDetaillist.get(0).getOrderId());
|
log.setFunction("insertDelivery修改:"+oddNumber);
|
} else {
|
//获取单号
|
oddNumber = orderNumberSetting("发货",deliveryIdType);
|
//新增发货表数据
|
deliveryMapper.insertDelivery(delivery, oddNumber, orderDetaillist.get(0).getOrderId());
|
log.setFunction("insertDelivery新增:"+oddNumber);
|
}
|
double area = 0.0;
|
Integer quantity = 0;
|
double money = 0.0;
|
AtomicReference<Double> otherMoney = new AtomicReference<>(0.0);
|
|
//先把其他金额副表的金额与数量置0
|
deliveryOtherMoneyList.forEach(deliveryOtherMoney -> {
|
deliveryOtherMoney.setQuantity(0.0);
|
});
|
double otherMoneys=0.0;
|
|
List <Map<String, Object>> moneryList=new ArrayList<Map<String, Object>>();//最终结果
|
//获取对象集合循环进行新增修改
|
if (!orderDetaillist.isEmpty()) {
|
for (OrderDetail orderDetail : orderDetaillist) {
|
if(orderDetail.getDeliveryDetail().getQuantity()>0){
|
OrderDetail orderDetails =deliveryDetailMapper.selectOrderDetailDeliveryCount(orderDetail);
|
Boolean aBoolean1 =orderDetails.getQuantity()>= orderDetail.getDeliveryDetail().getQuantity()+orderDetails.getDeliveryNum();
|
Boolean aBoolean2 = !Integer.valueOf(orderDetails.getQuantity().toString()).equals(orderDetails.getDeliveryNum());
|
//判断是否已经发货
|
if(aBoolean1 && aBoolean2){
|
double deliveryDetailotherMoneys=0.0;
|
Integer calculateType=0;
|
|
if (orderDetail.getOrder().getOrderId()==null){
|
Order order=deliveryMapper.selectOrderId(orderDetail.getOrderId());
|
calculateType=order.getCalculateType();
|
}else{
|
calculateType=orderDetail.getOrder().getCalculateType();
|
}
|
double deliveryDetailMoney = 0.0;
|
double deliveryDetailArea = 0.0;
|
BigDecimal getComputeArea= BigDecimal.valueOf(orderDetail.getComputeArea());
|
BigDecimal getQuantity= BigDecimal.valueOf(orderDetail.getDeliveryDetail().getQuantity());
|
BigDecimal getPrice= BigDecimal.valueOf(orderDetail.getPrice());
|
BigDecimal getWidth= BigDecimal.valueOf(orderDetail.getWidth());
|
BigDecimal getHeight= BigDecimal.valueOf(orderDetail.getHeight());
|
BigDecimal singlePieceArea =getComputeArea.multiply(getQuantity).setScale(2, RoundingMode.HALF_UP)
|
.multiply(getPrice).setScale(2, RoundingMode.HALF_UP);
|
//根据订单计算方式进行金额计算
|
if (calculateType==1){
|
deliveryDetailMoney=singlePieceArea.doubleValue();
|
deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
|
|
}else if (calculateType==2){
|
//判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
|
if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
|
deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP)
|
.multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
|
deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
|
}else{
|
deliveryDetailMoney=singlePieceArea.doubleValue();
|
deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
|
}
|
}else if (calculateType==3){
|
deliveryDetailMoney=getQuantity.multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
|
deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
|
|
}else if (calculateType==4){
|
//判断实际单片面积跟结算单片面积是否相等 结算总面积跟实际总面积是否相等
|
if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
|
deliveryDetailMoney=getWidth.multiply(getHeight).multiply(getQuantity).multiply(getPrice).
|
divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
|
deliveryDetailArea=getWidth.multiply(getHeight).multiply(getQuantity).divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue();
|
}else{
|
deliveryDetailMoney=getComputeArea.multiply(getQuantity).multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue();
|
deliveryDetailArea=getComputeArea.multiply(getQuantity).doubleValue();
|
}
|
}
|
/*if (calculateType==1){
|
deliveryDetailMoney=Double.parseDouble(String.format("%.2f",Double.parseDouble(
|
String.format("%.2f", orderDetail.getComputeArea()*orderDetail.getDeliveryDetail().getQuantity())
|
)*orderDetail.getPrice()));
|
}else if (calculateType==2){
|
if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())){
|
deliveryDetailMoney=Double.parseDouble(String.format("%.2f",Double.parseDouble(
|
String.format("%.2f", orderDetail.getWidth()*orderDetail.getHeight()*orderDetail.getDeliveryDetail().getQuantity()/1000000)
|
)*orderDetail.getPrice()));
|
}else{
|
deliveryDetailMoney=Double.parseDouble(String.format("%.2f",Double.parseDouble(
|
String.format("%.2f", orderDetail.getComputeArea()*orderDetail.getDeliveryDetail().getQuantity())
|
)*orderDetail.getPrice()));
|
}
|
}else if (calculateType==3){
|
deliveryDetailMoney=Double.parseDouble(String.format("%.2f",orderDetail.getPrice() * orderDetail.getDeliveryDetail().getQuantity()));
|
|
}*/
|
|
|
|
if(orderDetail.getOtherColumns()!="{}"&&orderDetail.getOtherColumns()!=null){
|
JSONObject jsonObject = JSON.parseObject(orderDetail.getOtherColumns());
|
for(String key : jsonObject.keySet()){
|
boolean isnull = key.contains("M");
|
if(isnull) {
|
Map<String, Object> moneryItemmap = new HashMap<>();
|
Map<String, Object> deliveryDetailOtherMoney = deliveryDetailMapper.getSelectOrderotherMoney(orderDetail.getOrderId(),orderDetail.getOrderNumber(),
|
key, Double.valueOf(jsonObject.get(key).toString()),orderDetail.getDeliveryDetail().getQuantity());
|
if(deliveryDetailOtherMoney.get("monery")!=null){
|
otherMoneys=otherMoneys+Double.valueOf(deliveryDetailOtherMoney.get("monery").toString());
|
deliveryDetailotherMoneys=Double.valueOf(deliveryDetailOtherMoney.get("monery").toString());
|
moneryItemmap.put("DeliveryDetailOtherMoney", deliveryDetailOtherMoney);
|
moneryList.add(moneryItemmap);
|
}else{
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
return "false1";
|
}
|
}
|
}
|
|
}
|
|
|
//对循环明细的数据进行累加
|
quantity += orderDetail.getDeliveryDetail().getQuantity();
|
area += deliveryDetailArea;
|
money += deliveryDetailMoney;
|
Integer deliveryDetailmaximum = deliveryDetailMapper.getdeliveryDetailmaximum(oddNumber);
|
|
//额外金额修改
|
Map<String,String> otherColumns = JSON.parseObject(orderDetail.getOtherColumns(), new TypeReference<Map<String, String>>(){});
|
if(otherColumns!=null){
|
otherColumns.forEach((key, value) ->{
|
boolean isnull = key.contains("M");
|
if(isnull){
|
deliveryOtherMoneyList.forEach(deliveryOtherMoney ->{
|
if(deliveryOtherMoney.getColumn().equals(key)){
|
deliveryOtherMoney.setQuantity(deliveryOtherMoney.getQuantity()+( Double.valueOf(value)* orderDetail.getDeliveryDetail().getQuantity()));
|
}
|
});
|
|
}
|
});
|
}
|
//新增发货明细数据
|
deliveryDetailMapper.insertDeliveryDetail(orderDetail, oddNumber, deliveryDetailmaximum + 1,deliveryDetailMoney,deliveryDetailotherMoneys,deliveryDetailArea);
|
//修改订单明细
|
deliveryDetailMapper.updateOrderDetailDeliveryNum(orderDetail);
|
//修改库存表出库数量
|
finishedGoodsInventoryMapper.updateInventoryquantityOut(orderDetail.getOrderId(), orderDetail.getOrderNumber(), orderDetail.getDeliveryDetail().getQuantity());
|
}else{
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
return "false2";
|
}
|
}
|
|
}
|
//往订单其他金额副表传入数据
|
deliveryOtherMoneyList.forEach(deliveryOtherMoney ->{
|
deliveryOtherMoney.setId(null);
|
deliveryOtherMoney.setDeliveryId(oddNumber);
|
if(deliveryOtherMoney.getQuantity()!=null && deliveryOtherMoney.getPrice()!=null){
|
deliveryOtherMoney.setMoney((deliveryOtherMoney.getQuantity()*deliveryOtherMoney.getPrice()));
|
otherMoney.updateAndGet(v -> new Double((double) (v + deliveryOtherMoney.getMoney())));
|
deliveryOtherMoneyMapper.insertDeliveryOtherMoney(deliveryOtherMoney);
|
}
|
});
|
double freight=0.0;
|
if (delivery.getFreightPrice()!=null&&delivery.getFreightQuantity()!=null){
|
freight=delivery.getFreightPrice()*delivery.getFreightQuantity();
|
}
|
|
int intMoney= (int) Math.round(money+freight+otherMoneys);
|
//修改发货明细累加面积数量金额
|
deliveryMapper.updatedelivery(Double.valueOf(String.format("%.2f", area)), quantity, Double.valueOf(intMoney), otherMoneys, oddNumber);
|
logService.saveLog(log);
|
} else {
|
return "false3";
|
}
|
}catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("insertDelivery");
|
sysErrorService.insert(sysError);
|
saveState = "false4";
|
|
}
|
|
return saveState;
|
}
|
|
|
public String updateDeliveryToExamine(Map<String,Object> object) {
|
String saveState = "true";
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
Log log = new Log();
|
String deliveryId = "";
|
int type =3;
|
if (object.get("deliveryId") != null) {
|
deliveryId = object.get("deliveryId").toString();
|
}
|
|
if (object.get("type") != null) {
|
type = Integer.parseInt(object.get("type").toString());
|
}
|
|
if(Boolean.parseBoolean(object.get("deliveryOutbound").toString())){
|
if(type==2){
|
List<OrderDetail> orderDetaillist=finishedGoodsInventoryMapper.getSelectDeliveryDetailDeliveryId(deliveryId);
|
if(!Objects.equals(finishedGoodsInventoryService.deliveryDetailLogic(orderDetaillist,savePoint,object.get("userName").toString()), "true")){
|
return finishedGoodsInventoryService.deliveryDetailLogic(orderDetaillist,savePoint,object.get("userName").toString());
|
}
|
}else{
|
List<FinishedOperateLog> finishedOperateLogslist=finishedOperateLogMapper.getSelectStorageRecordDeliveryId(deliveryId,"出库");
|
if(!Objects.equals(finishedGoodsInventoryService.cancelDeliveryDetailLogic(finishedOperateLogslist,savePoint,object.get("userName").toString(),log), "true")){
|
return finishedGoodsInventoryService.cancelDeliveryDetailLogic(finishedOperateLogslist,savePoint,object.get("userName").toString(),log);
|
}
|
|
}
|
|
}
|
|
deliveryMapper.updateDeliveryToExamine(deliveryId,type);
|
|
|
log.setOperatorId(object.get("userId").toString());
|
log.setOperator(object.get("userName").toString());
|
log.setContent(object.toString());
|
log.setFunction("updateDeliveryToExamine修改:"+deliveryId);
|
logService.saveLog(log);
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("addDeliveryDetail");
|
sysErrorService.insert(sysError);
|
saveState = "false";
|
|
}
|
return saveState;
|
|
|
|
}
|
|
public Boolean deleteDelivery(Map<String,Object> object) {
|
boolean saveState = true;
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
String deliveryId = "";
|
if (object.get("deliveryId") != null) {
|
deliveryId = object.get("deliveryId").toString();
|
}
|
List<DeliveryDetail> deliveryDetaillist = deliveryDetailMapper.getIsNotDeliveryDetail(deliveryId);
|
if (!deliveryDetaillist.isEmpty()) {
|
for (DeliveryDetail deliveryDetail : deliveryDetaillist) {
|
//还原库存数以及订单明细的发货数
|
finishedGoodsInventoryMapper.updateInventoryquantityInt(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
|
deliveryDetailMapper.updateIsNotOrderDetailDeliveryNum(deliveryDetail.getOrderId(), deliveryDetail.getOrderNumber(), deliveryDetail.getQuantity());
|
}
|
}
|
//删除订单额外金额的数据
|
deliveryOtherMoneyMapper.deleteDeliveryOtherMoney(deliveryId);
|
deliveryDetailMapper.deleteDeliveryDetail(deliveryId);
|
deliveryMapper.deleteDelivery(deliveryId);
|
|
Log log = new Log();
|
log.setOperatorId(object.get("userId").toString());
|
log.setOperator(object.get("userName").toString());
|
log.setContent(object.toString());
|
log.setFunction("deleteDelivery删除:"+deliveryId);
|
logService.saveLog(log);
|
|
return true;
|
}catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("deleteDelivery");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
}
|
return saveState;
|
|
}
|
|
public List<Map<String, Object>> getSelectDeliveryPrinting(Map<String,Object> object) throws IllegalAccessException {
|
List<Delivery> deliveries = JSONArray.parseArray(JSONObject.toJSONString(object.get("deliveryId")), Delivery.class);
|
String type = "";
|
if (object.get("type") != null) {
|
type = object.get("type").toString();
|
}
|
List <Map<String, Object>> list1=new ArrayList<Map<String, Object>>();//最终结果
|
for(Delivery deliverys:deliveries){
|
|
Map<String, Object> map = new HashMap<>();
|
List <Map<String, Object>> list=new ArrayList<Map<String, Object>>();//最终结果
|
List <Map<String, Object>> moneryList=new ArrayList<Map<String, Object>>();//最终结果
|
List<DeliveryDetail> deliveryDetailList=deliveryDetailMapper.getSelectDeliveryPrinting(deliverys.getDeliveryId(),type);
|
String orderId="";
|
double otherMoney=0.0;
|
for (DeliveryDetail detail : deliveryDetailList) {
|
orderId=detail.getOrderDetail().getOrderId();
|
Map<String, Object> itemmap = new HashMap<>();
|
|
List<Map<String, Object>> deliveryDetailList2 = deliveryDetailMapper.getSelectDeliveryDetailPrinting(detail.getDeliveryId(),
|
detail.getOrderDetail().getProductId(), detail.getOrderDetail().getOrderId());
|
|
for (Map<String, Object> stringObjectMap : deliveryDetailList2) {
|
if(stringObjectMap.get("other_columns")!=null){
|
JSONObject jsonObject = JSON.parseObject(stringObjectMap.get("other_columns").toString());
|
for(String key : jsonObject.keySet()){
|
boolean isnull = key.contains("M");
|
if(isnull) {
|
Map<String, Object> moneryItemmap = new HashMap<>();
|
Map<String, Object> deliveryDetailOtherMoney = deliveryDetailMapper.getSelectotherMoney(detail.getOrderDetail().getOrderId(),
|
detail.getDeliveryId(),Integer.parseInt(stringObjectMap.get("order_number").toString()), key,Double.valueOf(jsonObject.get(key).toString()));
|
Double sss= Double.valueOf(jsonObject.get(key).toString());
|
moneryItemmap.put("DeliveryDetailOtherMoney", deliveryDetailOtherMoney);
|
moneryList.add(moneryItemmap);
|
}
|
}
|
|
}
|
}
|
itemmap.put("DeliveryDetail", detail);
|
itemmap.put("DeliveryDetailList", deliveryDetailList2);
|
list.add(itemmap);
|
|
}
|
/*Delivery delivery=deliveryMapper.getSelectShippingOrderDetailDeliveryPrinting(deliveryDetail);
|
delivery.setMoney(delivery.getMoney()+otherMoney);
|
map.put("data", list);
|
map.put("otherMoney",moneryList);
|
map.put("delivery", deliveryMapper.getSelectShippingOrderDetailDeliveryPrinting(deliveryDetail));
|
map.put("money", toChinese(delivery.getMoney().toString(), false));*/
|
|
deliverys.setMoney(deliverys.getMoney()+otherMoney);
|
map.put("data", list);
|
map.put("otherMoney",moneryList);
|
map.put("delivery",deliverys );
|
map.put("money", toChinese(deliverys.getMoney().toString(), false));
|
list1.add(map);
|
}
|
|
|
return list1;
|
|
}
|
|
public Map<String, Object> getSelectOrderPrinting(OrderDetail orderDetail,List<String> productId) {
|
Map<String, Object> map = new HashMap<>();
|
List <Map<String, Object>> list=new ArrayList<Map<String, Object>>();//最终结果
|
List <Map<String, Object>> moneryList=new ArrayList<Map<String, Object>>();//最终结果
|
List<Map<String,Object>> orderProductDistinct;
|
if (!Objects.equals(productId.get(0), "null")){
|
orderProductDistinct = orderDetailMapper.getOrderProductDistinctByIds(orderDetail.getOrderId(),productId);
|
}else{
|
orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderDetail.getOrderId());
|
}
|
BigDecimal areSum=new BigDecimal("0");
|
BigDecimal grossAmount=new BigDecimal("0");
|
int quantity=0;
|
for (Map<String, Object> maps : orderProductDistinct) {
|
List<OrderDetail> orderDetails = deliveryDetailMapper.getSelectOrderPrinting(maps.get("productId"),orderDetail.getOrderId());
|
for (OrderDetail detail : orderDetails) {
|
|
areSum=areSum.add(BigDecimal.valueOf(detail.getArea()));
|
quantity+=detail.getQuantity();
|
grossAmount=grossAmount.add(BigDecimal.valueOf(detail.getGrossAmount()));
|
|
Map<String, Object> itemmap = new HashMap<>();
|
List<Map<String, Object>> deliveryDetailList2 = deliveryDetailMapper.getSelectOrderDetailPrinting(
|
detail.getProductId(), detail.getOrderId());
|
for (Map<String, Object> stringObjectMap : deliveryDetailList2) {
|
|
if(stringObjectMap.get("other_columns")!=null){
|
JSONObject jsonObject = JSON.parseObject(stringObjectMap.get("other_columns").toString());
|
for(String key : jsonObject.keySet()){
|
boolean isnull = key.contains("M");
|
if(isnull){
|
Map<String, Object> moneryItemmap = new HashMap<>();
|
Map<String, Object> deliveryDetailOtherMoney = deliveryDetailMapper.getSelectOrderotherMoneys(detail.getOrderId(),Integer.parseInt(stringObjectMap.get("order_number").toString())
|
,key,Double.valueOf(jsonObject.get(key).toString()));
|
grossAmount=grossAmount.add(BigDecimal.valueOf(Double.parseDouble(deliveryDetailOtherMoney.get("monery").toString())));
|
moneryItemmap.put("DeliveryDetailOtherMoney", deliveryDetailOtherMoney);
|
moneryList.add(moneryItemmap);
|
}
|
|
}
|
|
}
|
}
|
itemmap.put("productId",maps.get("productId"));
|
itemmap.put("productName",maps.get("productName"));
|
itemmap.put("remarks",maps.get("remarks"));
|
itemmap.put("DeliveryDetail", detail);
|
itemmap.put("DeliveryDetailList", deliveryDetailList2);
|
list.add(itemmap);
|
|
}
|
}
|
|
Order order=deliveryMapper.getSelectShippingOrderDetailPrinting(orderDetail);
|
order.setMoney((double) Math.round(grossAmount.doubleValue()));
|
order.setQuantity((long) quantity);
|
order.setArea(areSum.doubleValue());
|
map.put("data", list);
|
map.put("otherMoney",moneryList);
|
map.put("delivery", order);
|
map.put("money", toChinese(order.getMoney().toString(), false));
|
return map;
|
|
}
|
|
public List<DeliveryDetailDTO> exportDeliveryDetailReport(List<LocalDate> dates) {
|
return deliveryDetailMapper.exportDeliveryDetailReport(dates);
|
}
|
|
public List<DeliveryDetailProductDTO> exportDeliveryDetailProductReport(List<LocalDate> dates) {
|
return deliveryDetailMapper.exportDeliveryDetailProductReport(dates);
|
}
|
|
public boolean updateDeliveryPrintNumber(String deliveryId) {
|
return deliveryMapper.updateDeliveryPrintNumber(deliveryId);
|
}
|
|
|
|
|
|
private static final String[] NUMBERS = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
|
|
private static final String[] IUNIT = {"元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟"};
|
|
private static final String[] DUNIT = {"角", "分"};
|
|
private static final String[] CN_NUMBERS = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
|
|
private static final String[] CN_IUNIT = {"", "十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千"};
|
|
|
|
/**
|
* 转换为大写的中文金额,支持负数
|
* @param amount 金额
|
* @param isSimplified 是否简体中文：true:简体，false：繁体
|
* @return
|
*/
|
public static String toChinese(String amount, boolean isSimplified) {
|
// 判断输入的金额字符串是否符合要求
|
if (StringUtils.isBlank(amount) || !amount.matches("(-)?[\\d]*(.)?[\\d]*")) {
|
throw new RuntimeException("请输入数字");
|
}
|
|
if ("0".equals(amount) || "0.00".equals(amount) || "0.0".equals(amount)) {
|
return isSimplified ? "零" : "零元";
|
}
|
|
// 判断金额数字中是否存在负号"-"
|
boolean flag = false;
|
if (amount.startsWith("-")) {
|
// 标志位，标志此金额数字为负数
|
flag = true;
|
amount = amount.replaceAll("-", "");
|
}
|
// 去掉金额数字中的逗号","
|
amount = amount.replaceAll(",", "");
|
// 初始化：分离整数部分和小数部分
|
String[] separateNum = separateNum(amount);
|
// 整数部分数字
|
String integerStr = separateNum[0];
|
// 小数部分数字
|
String decimalStr = separateNum[1];
|
// beyond超出计算能力，直接返回
|
if (integerStr.length() > IUNIT.length) {
|
throw new RuntimeException("输入数字超限");
|
}
|
// 整数部分数字
|
int[] integers = toIntArray(integerStr);
|
// 判断整数部分是否存在输入012的情况
|
if (integers.length > 1 && integers[0] == 0) {
|
throw new RuntimeException("输入数字不符合要求");
|
}
|
// 设置万单位
|
boolean isWan = isWan5(integerStr);
|
// 小数部分数字
|
int[] decimals = toIntArray(decimalStr);
|
// 返回最终的大写金额
|
String result = "";
|
String chineseInteger = getChineseInteger(integers, isWan, isSimplified);
|
String chineseDecimal = getChineseDecimal(decimals, isSimplified);
|
if (decimals.length > 0 && isSimplified) {
|
result = chineseInteger;
|
if (!chineseDecimal.equals("零零")) {
|
result = result + "点" + chineseDecimal;
|
}
|
} else {
|
result = chineseInteger + chineseDecimal;
|
|
}
|
if (flag) {
|
// 如果是负数，加上"负"
|
return "负" + result;
|
} else {
|
return result;
|
}
|
}
|
|
/**
|
* 分离整数部分和小数部分
|
* @param str
|
* @return
|
*/
|
private static String[] separateNum(String str) {
|
String integerStr;// 整数部分数字
|
String decimalStr;// 小数部分数字
|
if (str.indexOf('.') >= 1) {
|
integerStr = str.substring(0, str.indexOf('.'));
|
decimalStr = str.substring(str.indexOf('.') + 1);
|
if (decimalStr.length() > 2) {
|
decimalStr = decimalStr.substring(0, 2);
|
}
|
} else if (str.indexOf('.') == 0) {
|
integerStr = "";
|
decimalStr = str.substring(1);
|
} else {
|
integerStr = str;
|
decimalStr = "";
|
}
|
return new String[] {integerStr, decimalStr};
|
}
|
|
/**
|
* 将字符串转为int数组
|
* @param number 数字
|
* @return
|
*/
|
private static int[] toIntArray(String number) {
|
int[] array = new int[number.length()];
|
for (int i = 0; i < number.length(); i++) {
|
array[i] = Integer.parseInt(number.substring(i, i + 1));
|
}
|
return array;
|
}
|
|
/**
|
* 将整数部分转为大写的金额
|
* @param integers 整数部分数字
|
* @param isWan 整数部分是否已经是达到【万】
|
* @return
|
*/
|
private static String getChineseInteger(int[] integers, boolean isWan, boolean isSimplified) {
|
|
int length = integers.length;
|
if (!isSimplified && length == 1 && integers[0] == 0) {
|
return "";
|
}
|
if (!isSimplified) {
|
return traditionalChineseInteger(integers, isWan);
|
} else {
|
return simplifiedChineseInteger(integers, isWan);
|
}
|
}
|
|
/**
|
* 繁体中文整数
|
* @param integers
|
* @param isWan
|
* @return
|
*/
|
private static String traditionalChineseInteger(int[] integers, boolean isWan) {
|
StringBuilder chineseInteger = new StringBuilder("");
|
int length = integers.length;
|
for (int i = 0; i < length; i++) {
|
String key = "";
|
if (integers[i] == 0) {
|
if ((length - i) == 13)// 万（亿）
|
key = IUNIT[4];
|
else if ((length - i) == 9) {// 亿
|
key = IUNIT[8];
|
} else if ((length - i) == 5 && isWan) {// 万
|
key = IUNIT[4];
|
} else if ((length - i) == 1) {// 元
|
key = IUNIT[0];
|
}
|
if ((length - i) > 1 && integers[i + 1] != 0) {
|
key += NUMBERS[0];
|
}
|
}
|
chineseInteger.append(integers[i] == 0 ? key : (NUMBERS[integers[i]] + IUNIT[length - i - 1]));
|
}
|
return chineseInteger.toString();
|
}
|
|
/**
|
* 简体中文整数
|
* @param integers
|
* @param isWan
|
* @return
|
*/
|
private static String simplifiedChineseInteger(int[] integers, boolean isWan) {
|
StringBuilder chineseInteger = new StringBuilder("");
|
int length = integers.length;
|
for (int i = 0; i < length; i++) {
|
String key = "";
|
if (integers[i] == 0) {
|
if ((length - i) == 13) {// 万（亿）
|
key = CN_IUNIT[4];
|
} else if ((length - i) == 9) {// 亿
|
key = CN_IUNIT[8];
|
} else if ((length - i) == 5 && isWan) {// 万
|
key = CN_IUNIT[4];
|
} else if ((length - i) == 1) {// 元
|
key = CN_IUNIT[0];
|
}
|
if ((length - i) > 1 && integers[i + 1] != 0) {
|
key += CN_NUMBERS[0];
|
}
|
if (length == 1 && integers[i] == 0) {
|
key += CN_NUMBERS[0];
|
}
|
}
|
chineseInteger.append(integers[i] == 0 ? key : (CN_NUMBERS[integers[i]] + CN_IUNIT[length - i - 1]));
|
}
|
return chineseInteger.toString();
|
}
|
|
/**
|
* 将小数部分转为大写的金额
|
* @param decimals 小数部分的数字
|
* @return
|
*/
|
private static String getChineseDecimal(int[] decimals, boolean isSimplified) {
|
StringBuilder chineseDecimal = new StringBuilder("");
|
if (!isSimplified) {
|
for (int i = 0; i < decimals.length; i++) {
|
String key = "";
|
|
if ((decimals.length - i) > 1 && decimals[i + 1] != 0) {
|
key += NUMBERS[0];
|
}
|
|
chineseDecimal.append(decimals[i] == 0 ? key : (NUMBERS[decimals[i]] + DUNIT[i]));
|
}
|
} else {
|
for (int i = 0; i < decimals.length; i++) {
|
chineseDecimal.append(CN_NUMBERS[decimals[i]]);
|
}
|
|
}
|
return chineseDecimal.toString();
|
}
|
|
/**
|
* 判断当前整数部分是否已经是达到【万】
|
* @param integerStr 整数部分数字
|
* @return
|
*/
|
private static boolean isWan5(String integerStr) {
|
int length = integerStr.length();
|
if (length > 4) {
|
String subInteger = "";
|
if (length > 8) {
|
subInteger = integerStr.substring(length - 8, length - 4);
|
} else {
|
subInteger = integerStr.substring(0, length - 4);
|
}
|
return Integer.parseInt(subInteger) > 0;
|
} else {
|
return false;
|
}
|
}
|
|
public String orderNumberSetting(String type,String deliveryIdType) {
|
//根据类型自动生成不同的操作单号
|
String alias="";
|
if(Objects.equals(type, "发货")){
|
alias="FH";
|
}
|
String oddNumbers="";
|
|
if(deliveryIdType.equals("day")){
|
//查询当天的最大数量
|
Integer maximum=deliveryMapper.getmaximum(type);
|
//设置两位不够补0
|
String formattedNumber = String.format("%02d", maximum+1);
|
//格式化当前日期
|
Date currentDate = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
|
String formattedDate = dateFormat.format(currentDate);
|
oddNumbers = alias+formattedDate+formattedNumber;
|
}else if(deliveryIdType.equals("month")){
|
Integer maximum = deliveryMapper.getmaximumMonth();
|
String formattedNumber = String.format("%04d", maximum+1);
|
Date currentDate = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMM");
|
String formattedDate = dateFormat.format(currentDate);
|
oddNumbers = alias+formattedDate+formattedNumber;
|
|
}
|
|
return oddNumbers;
|
}
|
}
|
