From 1c5cec37312c58cbc394778bdb649feafd2f8af3 Mon Sep 17 00:00:00 2001
From: guoyuji <guoyujie@ng.com>
Date: 星期五, 30 八月 2024 14:00:58 +0800
Subject: [PATCH] Merge branch 'master' of http://10.153.19.25:10101/r/ERP_override
---
north-glass-erp/src/main/java/com/example/erp/service/sd/OrderService.java | 494 +++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 446 insertions(+), 48 deletions(-)
diff --git a/north-glass-erp/src/main/java/com/example/erp/service/sd/OrderService.java b/north-glass-erp/src/main/java/com/example/erp/service/sd/OrderService.java
index 6c06526..3a03a09 100644
--- a/north-glass-erp/src/main/java/com/example/erp/service/sd/OrderService.java
+++ b/north-glass-erp/src/main/java/com/example/erp/service/sd/OrderService.java
@@ -1,30 +1,35 @@
package com.example.erp.service.sd;
+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.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.example.erp.common.Constants;
-import com.example.erp.entity.sd.Order;
-import com.example.erp.entity.sd.OrderDetail;
-import com.example.erp.entity.sd.OrderGlassDetail;
-import com.example.erp.entity.sd.OrderProcessDetail;
+import com.example.erp.dto.sd.OrderDTO;
+import com.example.erp.dto.sd.OrderDetailProductDTO;
+import com.example.erp.entity.sd.*;
+import com.example.erp.entity.userInfo.Log;
import com.example.erp.entity.userInfo.SysError;
import com.example.erp.exception.ServiceException;
-import com.example.erp.mapper.sd.OrderDetailMapper;
-import com.example.erp.mapper.sd.OrderGlassDetailMapper;
-import com.example.erp.mapper.sd.OrderMapper;
-import com.example.erp.mapper.sd.OrderProcessDetailMapper;
+import com.example.erp.mapper.sd.*;
+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.math.BigDecimal;
+import java.math.RoundingMode;
+import java.sql.SQLOutput;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
+import java.util.stream.Collectors;
@Service
@DS("sd")
@@ -34,30 +39,81 @@
private final OrderDetailMapper orderDetailMapper;
private final OrderGlassDetailMapper orderGlassDetailMapper;
private final SysErrorService sysErrorService;
+ private final OrderOtherMoneyMapper orderOtherMoneyMapper;
+ private final ProductMapper productMapper;
+ private final LogService logService;
private final OrderProcessDetailMapper orderProcessDetailMapper;
- public OrderService(OrderMapper orderMapper, OrderDetailMapper orderDetailMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, SysErrorService sysErrorService) {
+ public OrderService(OrderMapper orderMapper, OrderDetailMapper orderDetailMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, SysErrorService sysErrorService, OrderOtherMoneyMapper orderOtherMoneyMapper, ProductMapper productMapper, LogService logService) {
this.orderMapper = orderMapper;
this.orderDetailMapper = orderDetailMapper;
this.orderGlassDetailMapper = orderGlassDetailMapper;
this.orderProcessDetailMapper = orderProcessDetailMapper;
this.sysErrorService = sysErrorService;
+ this.orderOtherMoneyMapper = orderOtherMoneyMapper;
+ this.productMapper = productMapper;
+ this.logService = logService;
}
public boolean saveOrder(Map<String,Object> orderMap) throws Exception {
JSONObject orderJson = new JSONObject(orderMap);
+ String orderIdType = orderJson.getString("orderIdType");
Order order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("title")), Order.class);
List<OrderDetail> OrderDetails = JSONArray.parseArray(JSONObject.toJSONString(orderJson.get("detail")), OrderDetail.class);
+ List<OrderOtherMoney> orderOtherMoneyList = JSONArray.parseArray(JSONObject.toJSONString(orderJson.get("otherMoney")), OrderOtherMoney.class);
+ if(orderOtherMoneyList != null ){
+ orderOtherMoneyList = orderOtherMoneyList.stream().filter(o -> o.getColumn().indexOf("M")==0).collect(Collectors.toList());
+ }
+
boolean saveState = true;
//璁剧疆鍥炴粴鐐�
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
//鍒ゆ柇浼犲叆id鍙傛暟鏄惁涓虹┖锛屾湭浼犲叆id涓虹┖鎻掑叆璁㈠崟琛紝浼犲叆鏇存柊琛�
try{
+ Log log = new Log();
+ log.setOperator(orderJson.getString("creator"));
+ log.setOperatorId(orderJson.getString("creatorId"));
+ log.setContent(orderMap.toString());
+
if(order.getOrderId() == null || order.getOrderId().isEmpty()){
- insertOrder(order,OrderDetails);
+ insertOrder(order,OrderDetails,orderOtherMoneyList,orderIdType);
+ log.setFunction("saveOrder鍒涘缓:"+order.getOrderId());
}else {
- updateOrder(order,OrderDetails);
+ updateOrder(order,OrderDetails,orderOtherMoneyList);
+ log.setFunction("saveOrder淇敼:"+order.getOrderId());
}
+
+ logService.saveLog(log);
+ }catch (Exception e){
+ TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
+ //灏嗗紓甯镐紶鍏ユ暟鎹簱
+ SysError sysError = new SysError();
+ sysError.setError(e.toString()+Arrays.toString(e.getStackTrace()));
+ sysError.setFunc("saveOrder");
+ sysErrorService.insert(sysError);
+ saveState = false;
+
+ //throw new Exception();
+ }
+ return saveState;
+ }
+
+ public boolean saveOrderTitle(Map<String,Object> orderMap) throws Exception {
+ JSONObject orderJson = new JSONObject(orderMap);
+ Order order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("title")), Order.class);
+
+ boolean saveState = true;
+ //璁剧疆鍥炴粴鐐�
+ Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
+ //鍒ゆ柇浼犲叆id鍙傛暟鏄惁涓虹┖锛屾湭浼犲叆id涓虹┖鎻掑叆璁㈠崟琛紝浼犲叆鏇存柊琛�
+ try{
+ LambdaUpdateWrapper<Order> updateWrapper = new LambdaUpdateWrapper<>();
+ updateWrapper.eq(Order::getOrderId, order.getOrderId());
+ order.setCreateTime(null);
+ orderMapper.update(order,updateWrapper);
+ //淇敼璁㈠崟涓昏〃闈㈢Н涓庡懆闀夸互鍙婇噸閲�
+ orderMapper.updateOrderParameter(order.getOrderId());
+
}catch (Exception e){
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
//灏嗗紓甯镐紶鍏ユ暟鎹簱
@@ -71,58 +127,153 @@
}
return saveState;
}
+
+
+ public Map<String,Object> selectOrder(Map<String,Object> orderMap) throws Exception {
+ JSONObject orderJson = new JSONObject(orderMap);
+ Order order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("title")), Order.class);
+ Map<String,Object> map = new HashMap<>();
+ if(order.getOrderId()!=null && !order.getOrderId().isEmpty()){
+ map.put("data",0);
+ }else{
+ map.put("data",orderMapper.selectOrder(order));
+ }
+
+ return map;
+ }
//鐢熸垚璁㈠崟鏁版嵁
- public void insertOrder(Order order,List<OrderDetail> OrderDetails) {
- Integer maxOrderId = orderMapper.selectMaxOrderId();
- //鏌ヨ璁㈠崟id锛屽苟涓旇嚜澧�
- String formattedNumber = String.format("%02d", maxOrderId+1);
- //鏍煎紡鍖栧綋鍓嶆棩鏈�
- Date currentDate = new Date();
- SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
- String formattedDate = dateFormat.format(currentDate);
- String orderId = "NG"+formattedDate+formattedNumber;
+ public void insertOrder(Order order, List<OrderDetail> OrderDetails, List<OrderOtherMoney> orderOtherMoneyList, String orderIdType) {
+ //鏍规嵁浼犲叆鐨勫綋鍓嶆湀浠芥垨鑰呭綋澶╃敓鎴愯鍗昳d
+ String orderId = getOrderId(orderIdType);
//寰�涓昏〃鎻掓暟鎹�
order.setOrderId(orderId);
order.setCreateOrder(2);
orderMapper.insert(order);
- insertOtherDetail(orderId,OrderDetails);
+ insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList);
}
+
+ private String getOrderId(String dateType){
+ String orderId = null;
+ if(dateType.equals("day")){
+ Integer maxOrderId = orderMapper.selectMaxOrderId();
+ //鏌ヨ璁㈠崟id锛屽苟涓旇嚜澧�
+ String formattedNumber = String.format("%02d", maxOrderId+1);
+ //鏍煎紡鍖栧綋鍓嶆棩鏈�
+ Date currentDate = new Date();
+ SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
+ String formattedDate = dateFormat.format(currentDate);
+ orderId = "NG"+formattedDate+formattedNumber;
+ }else if(dateType.equals("month")){
+ Integer maxOrderId = orderMapper.selectMaxOrderIdByMonth();
+ String formattedNumber = String.format("%04d", maxOrderId+1);
+ Date currentDate = new Date();
+ SimpleDateFormat dateFormat = new SimpleDateFormat("yyMM");
+ String formattedDate = dateFormat.format(currentDate);
+ orderId = "NG"+formattedDate+formattedNumber;
+
+ }else if(dateType.equals("year")){
+ Integer maxOrderId = orderMapper.selectMaxOrderIdByYear();
+ String formattedNumber = String.format("%06d", maxOrderId+1);
+ Date currentDate = new Date();
+ SimpleDateFormat dateFormat = new SimpleDateFormat("yy");
+ String formattedDate = dateFormat.format(currentDate);
+ orderId = "NG"+formattedDate+formattedNumber;
+ }
+
+ return orderId;
+ }
+
+
//淇敼璁㈠崟鏁版嵁锛屽苟涓旈噸鏂扮敓鎴愬涓壇琛ㄦ暟鎹�
- public void updateOrder(Order order,List<OrderDetail> OrderDetails) {
+ public void updateOrder(Order order,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
+ order.setCreateTime(null);
LambdaUpdateWrapper<Order> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(Order::getOrderId, order.getOrderId());
orderMapper.update(order,updateWrapper);
- //鍒犻櫎璁㈠崟鏄庣粏琛�
- orderDetailMapper.delete(new LambdaQueryWrapper<OrderDetail>().eq(OrderDetail::getOrderId, order.getOrderId()));
- //鍒犻櫎璁㈠崟灏忕墖琛�
- orderGlassDetailMapper.delete(new LambdaQueryWrapper<OrderGlassDetail>().eq(OrderGlassDetail::getOrderId, order.getOrderId()));
- //鍒犻櫎璁㈠崟宸ヨ壓琛�
- // orderProcessDetailMapper.delete(new LambdaQueryWrapper<OrderProcessDetail>().eq(OrderProcessDetail::getOrderId, order.getOrderId()));
- insertOtherDetail(order.getOrderId(),OrderDetails);
+ //鍒犻櫎璁㈠崟鏄庣粏琛�
+ orderDetailMapper.delete(new LambdaQueryWrapper<OrderDetail>().eq(OrderDetail::getOrderId, order.getOrderId()));
+ //鍒犻櫎璁㈠崟灏忕墖琛�
+ orderGlassDetailMapper.delete(new LambdaQueryWrapper<OrderGlassDetail>().eq(OrderGlassDetail::getOrderId, order.getOrderId()));
+ //鍒犻櫎鍏朵粬閲戦鏄庣粏琛�
+ orderOtherMoneyMapper.delete(new LambdaQueryWrapper<OrderOtherMoney>().eq(OrderOtherMoney::getOrderId, order.getOrderId()));
+
+
+ //鍒犻櫎璁㈠崟宸ヨ壓琛�
+ // orderProcessDetailMapper.delete(new LambdaQueryWrapper<OrderProcessDetail>().eq(OrderProcessDetail::getOrderId, order.getOrderId()));
+ insertOtherDetail(order.getOrderId(),OrderDetails,orderOtherMoneyList);
}
//鎻掑叆鍏朵粬鍓〃鏁版嵁锛岃鍏朵粬鏂规硶寮曠敤
- public void insertOtherDetail(String orderId,List<OrderDetail> OrderDetails) {
+ public void insertOtherDetail(String orderId,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
+ //鍏堟妸鍏朵粬閲戦鍓〃鐨勯噾棰濅笌鏁伴噺缃�0
+ orderOtherMoneyList.forEach(orderOtherMoney -> {
+ orderOtherMoney.setQuantity(0.0);
+ });
+
//寰幆缁欒鍗曟槑缁嗚〃瀛楁娣诲姞搴忓彿鍜屽懆闀�
for (int i = 0; i < OrderDetails.size(); i++) {
OrderDetails.get(i).setOrderNumber(i+1);
OrderDetails.get(i).setOrderId(orderId);
- OrderDetails.get(i).setPerimeter(OrderDetails.get(i).getWidth()*OrderDetails.get(i).getHeight()*2/1000);
- OrderDetails.get(i).setWeight(1.0);
+ OrderDetails.get(i).setPerimeter(Double.valueOf(String.format("%.3f",(OrderDetails.get(i).getWidth()+OrderDetails.get(i).getHeight())*2/1000*OrderDetails.get(i).getQuantity())));
+ Product product = productMapper.selectById(OrderDetails.get(i).getProductId());
+
+ OrderDetails.get(i).setWeight(Double.valueOf(String.format("%.2f",product.getThickness()*OrderDetails.get(i).getWidth()*OrderDetails.get(i).getHeight()/1000000*2.5)));
+ if(OrderDetails.get(i).getBendRadius()!=null && OrderDetails.get(i).getBendRadius()!=0){
+ //鑾峰彇寮挗寮у害
+ Double bendRadius = OrderDetails.get(i).getBendRadius();
+ //鑾峰彇瀹�
+ Double width = OrderDetails.get(i).getWidth();
+ //鑾峰彇鎷遍珮
+ String archRiseS = String.format("%.1f",bendRadius-(bendRadius*Math.cos(width/2/bendRadius)));
+ Double archRise = Double.parseDouble(archRiseS);
+ OrderDetails.get(i).setArchRise(archRise);
+ }
+
+ Map<String,Object> otherColumns = JSON.parseObject(OrderDetails.get(i).getOtherColumns(), new TypeReference<Map<String, Object>>(){});
+ int finalI = i;
+ if(otherColumns!=null){
+ otherColumns.values().removeIf(value -> value == null || value.equals(""));
+ OrderDetails.get(i).setOtherColumns(JSON.toJSONString(otherColumns));
+
+ otherColumns.forEach((key, value) ->{
+
+ if(value!=null && !value.equals("") && key.contains("M")) {
+ orderOtherMoneyList.forEach(orderOtherMoney -> {
+ if (orderOtherMoney.getColumn().equals(key)) {
+ orderOtherMoney.setQuantity(
+ orderOtherMoney.getQuantity()+(Double.parseDouble((String) value) * OrderDetails.get(finalI).getQuantity()));
+ }
+ });
+ }
+
+ });
+ }else{
+ OrderDetails.get(i).setOtherColumns("{}");
+ }
+
}
+
+
+
+
//寰�鏄庣粏琛ㄦ彃鏁版嵁
orderDetailMapper.insertBatch(OrderDetails);
- //淇敼璁㈠崟涓昏〃闈㈢Н涓庡懆闀夸互鍙婇噸閲�
- orderMapper.updateOrderParameter(orderId);
//寰�灏忕墖琛ㄤ紶鍏ヤ骇鍝佹暟鎹�
orderGlassDetailMapper.insertOrderGlassDetail(orderId);
- //鏌ヨ璁㈠崟灏忕墖琛ㄨ幏鍙栧伐鑹轰紶鍏ュ皬鐗囧伐鑹鸿〃
- //List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper.selectOrderGlassDetail(orderId);
- /*List<OrderProcessDetail> orderProcessDetailList = getOrderProcessDetails(orderGlassDetails);
- //璧嬪�艰鍗曞伐鑹鸿〃
- orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);*/
+ orderOtherMoneyList.forEach(orderOtherMoney ->{
+ orderOtherMoney.setId(null);
+ orderOtherMoney.setOrderId(orderId);
+ if(orderOtherMoney.getQuantity()!=null && orderOtherMoney.getPrice()!=null){
+ orderOtherMoney.setMoney((orderOtherMoney.getQuantity()*orderOtherMoney.getPrice()));
+ }
+ orderOtherMoneyMapper.insert(orderOtherMoney);
+ });
+ //淇敼璁㈠崟涓昏〃闈㈢Н涓庡懆闀夸互鍙婇噸閲�
+ orderMapper.updateOrderParameter(orderId);
+
+
}
public static List<OrderProcessDetail> getOrderProcessDetails(List<OrderGlassDetail> orderGlassDetails) {
@@ -176,18 +327,26 @@
public Map<String,Object> getOrderById(String id) {
Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
List<OrderDetail> orderDetails = orderDetailMapper.selectList(new QueryWrapper<OrderDetail>().eq("order_id",id));
+ List<OrderOtherMoney> orderOtherMoneyList = orderOtherMoneyMapper.findById(id);
+
+
Map<String,Object> map = new HashMap<>();
map.put("order",order);
map.put("orderDetails",orderDetails);
+ map.put("orderOtherMoneyList",orderOtherMoneyList);
return map;
}
//璁㈠崟瀹℃牳
- public boolean reviewOrderById(String id,Integer status) {
+ public boolean reviewOrderById(String id, Integer status, String userId, String userName) {
Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
if(order.getProcessReview()!=2){
throw new ServiceException(Constants.Code_600,"璇ヨ鍗曡繕鏈鏍�");
+ }else if(status==0){
+ return orderMapper.reviewOrderByIds(id,status,userId,userName);
+ }else{
+ return orderMapper.reviewOrderById(id,status,userId,userName);
}
- return orderMapper.reviewOrderById(id,status);
+
}
//宸ヨ壓瀹℃牳鐣岄潰瀹℃牳鏇存柊鏁版嵁
public boolean reviewProcessById(String id, Integer status,List<OrderGlassDetail> orderGlassDetails) {
@@ -222,22 +381,43 @@
JSONObject jsonObject = new JSONObject(map);
Order order = JSONObject.parseObject(JSONObject.toJSONString(jsonObject.get("order")), Order.class);
List<OrderDetail> OrderDetails = JSONArray.parseArray(JSONObject.toJSONString(jsonObject.get("detail")), OrderDetail.class);
+ List<OrderOtherMoney> orderOtherMoneyList = JSONArray.parseArray(JSONObject.toJSONString(jsonObject.get("otherMoney")), OrderOtherMoney.class);
double money = 0;
for (OrderDetail orderDetail : OrderDetails) {
orderDetail = updateOrderMoneyComputed(orderDetail,order.getCalculateType());
- money+= orderDetail.getGrossAmount();
+ BigDecimal getGrossAmount= BigDecimal.valueOf(orderDetail.getGrossAmount());
+ money+=getGrossAmount.doubleValue();
}
- order.setMoney(money);
+ Log log = new Log();
+ log.setOperator(order.getCreator());
+ log.setOperatorId(order.getCreatorId());
+ log.setContent(jsonObject.toString());
+ log.setFunction("updateOrderMoney閲戦閲嶇疆:"+order.getOrderId());
+
+ orderOtherMoneyList.forEach(orderOtherMoney -> {
+ if(orderOtherMoney.getQuantity()!=null && orderOtherMoney.getPrice()!=null){
+ orderOtherMoney.setMoney((orderOtherMoney.getQuantity()*orderOtherMoney.getPrice()));
+ }
+ orderOtherMoneyMapper.update(orderOtherMoney,new QueryWrapper<OrderOtherMoney>()
+ .eq("order_id",orderOtherMoney.getOrderId())
+ .eq("`column`",orderOtherMoney.getColumn()));
+ });
+ order.setMoney(money+orderOtherMoneyMapper.selectGrossAmount(order.getOrderId()));
+ order.setOtherMoney(orderOtherMoneyMapper.selectGrossAmount(order.getOrderId()));
orderMapper.updateMoney(order);
orderDetailMapper.updateOrderMoney(OrderDetails);
+ logService.saveLog(log);
return false;
}
private OrderDetail updateOrderMoneyComputed(OrderDetail orderDetail, Integer calculateType) {
+ BigDecimal getPrice= BigDecimal.valueOf(orderDetail.getPrice());
+ BigDecimal getQuantity= BigDecimal.valueOf(orderDetail.getQuantity());
+ BigDecimal getComputeGrossArea= BigDecimal.valueOf(orderDetail.getComputeGrossArea());
if (calculateType == 3) {
- orderDetail.setGrossAmount(orderDetail.getPrice() * orderDetail.getQuantity());
+ orderDetail.setGrossAmount(getPrice.multiply(getQuantity).setScale(2, RoundingMode.HALF_UP).doubleValue());
} else {
- orderDetail.setGrossAmount(orderDetail.getComputeGrossArea() * orderDetail.getPrice());
+ orderDetail.setGrossAmount(getPrice.multiply(getComputeGrossArea).setScale(2, RoundingMode.HALF_UP).doubleValue());
}
return orderDetail;
}
@@ -263,7 +443,7 @@
Map<String,Object> map = new HashMap<>();
map.put("data",orderDetailMapper.getOrderReport(offset, pageSize, startDate, endDate, orderDetail));
- map.put("total",orderDetailMapper.getOrderReportTotal(offset, pageSize, startDate, endDate, orderDetail));
+ map.put("total",orderDetailMapper.getOrderReportTotal(offset, pageSize, startDate, endDate, orderDetail,"order"));
List<String> list = new ArrayList<>();
list.add(startDate);
list.add(endDate);
@@ -272,7 +452,225 @@
return map;
}
- public List<Order> exportOrderReport() {
- return orderDetailMapper.exportOrderReport();
+ public List<OrderDTO> exportOrderReport(List<LocalDate> dates) {
+ return orderDetailMapper.exportOrderReport(dates);
+ }
+
+ public Map<String,Object> getOrderSummaryReport(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",orderDetailMapper.getOrderSummaryReport(offset, pageSize, startDate, endDate, order));
+ map.put("total",orderDetailMapper.getOrderSummaryReportTotal(offset, pageSize, startDate, endDate, order,"order"));
+ List<String> list = new ArrayList<>();
+ list.add(startDate);
+ list.add(endDate);
+ map.put("selectDate",list);
+// map.put("total",orderMapper.getPageTotal(offset, pageSize, startDate, endDate, orderDetail));
+ return map;
+ }
+
+ public List<Order> exportOrderSummary(List<LocalDate> dates) {
+ return orderDetailMapper.exportOrderSummary(dates);
+ }
+
+ public Map<String,Object> getOrderProductSummary(Integer pageNum, Integer pageSize, List<String> selectDate, OrderDetail orderDetail) {
+ 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",orderDetailMapper.getOrderProductSummary(offset, pageSize, startDate, endDate, orderDetail));
+ map.put("total",orderDetailMapper.getOrderProductSummaryTotal(offset, pageSize, startDate, endDate, orderDetail, "product"));
+ List<String> list = new ArrayList<>();
+ list.add(startDate);
+ list.add(endDate);
+ map.put("selectDate",list);
+// map.put("total",orderMapper.getPageTotal(offset, pageSize, startDate, endDate, orderDetail));
+ return map;
+ }
+
+ public List<OrderDTO> exportOrderProductSummary(List<LocalDate> dates) {
+ return orderDetailMapper.exportOrderProductSummary(dates);
+ }
+
+
+ public Map<String,String> getOrderProductDetailTag(String orderId) {
+ return orderDetailMapper.getOrderProductDetailTag(orderId);
+ }
+
+ public List<OrderDetail> getOrderDetailById(String id) {
+ return orderDetailMapper.selectList(new QueryWrapper<OrderDetail>().eq("order_id",id));
+ }
+
+ public List<OrderGlassDetail> getOrderCraftDetailById(String id) {
+ return orderGlassDetailMapper.selectOrderGlassDetailByOrderId(id);
+ }
+
+ public Object printOrderProductDetail(String orderId) {
+ List<Map<String,Object>> orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderId);
+
+ List<Map<String,Object>> orderProductDetail = new ArrayList<>();
+ orderProductDistinct.forEach(map->{
+ Map<String,Object> orderProductDetailMap = new HashMap<>();
+ orderProductDetailMap.put("productId",map.get("productId"));
+ orderProductDetailMap.put("productName",map.get("productName"));
+ List<OrderDetail> orderDetails = orderDetailMapper.getOrderProductByProductId(map.get("productId"),orderId);
+ orderProductDetailMap.put("productDetail",orderDetails);
+ orderProductDetail.add(orderProductDetailMap);
+ });
+
+ Map<String,Object> returns = new HashMap<>();
+
+ returns.put("orderProductDetail",orderProductDetail);
+ returns.put("order",orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",orderId)));
+ return returns;
+ }
+
+ public Object printOrderProductDetails(String orderId,List<String> productId) {
+ List<Map<String,Object>> orderProductDistinct;
+ if (productId.size()>0){
+ orderProductDistinct = orderDetailMapper.getOrderProductDistinctByIds(orderId,productId);
+ }else{
+ orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderId);
+ }
+
+ List<Map<String,Object>> orderProductDetail = new ArrayList<>();
+ orderProductDistinct.forEach(map->{
+ Map<String,Object> orderProductDetailMap = new HashMap<>();
+ orderProductDetailMap.put("productId",map.get("productId"));
+ orderProductDetailMap.put("productName",map.get("productName"));
+ List<OrderDetail> orderDetails = orderDetailMapper.getOrderProductByProductId(map.get("productId"),orderId);
+
+
+ orderProductDetailMap.put("productDetail",orderDetails);
+ orderProductDetail.add(orderProductDetailMap);
+ });
+
+ Map<String,Object> returns = new HashMap<>();
+
+ returns.put("orderProductDetail",orderProductDetail);
+ returns.put("order",orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",orderId)));
+ return returns;
+ }
+
+ public Object printOrderProductGlassDetailMonolithic(String orderId,List<String> productId) {
+ List<Map<String,Object>> orderProductDistinct;
+ if (productId.size()>0){
+ orderProductDistinct = orderDetailMapper.getOrderProductDistinctByIds(orderId,productId);
+ }else{
+ orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderId);
+ }
+
+ Map<String,Object> returns = new HashMap<>();
+ returns.put("order",orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",orderId)));
+
+ List<Map<String,Object>> orderProductDetail = new ArrayList<>();
+
+ orderProductDistinct.forEach(map->{
+ Map<String,Object> orderProductDetailMap = new HashMap<>();
+ orderProductDetailMap.put("productId",map.get("productId"));
+ orderProductDetailMap.put("productName",map.get("productName"));
+ List<Map<String,Object>> orderDetails = orderDetailMapper.getOrderProductByProductIds(map.get("productId"),orderId);
+ List<Map<String,Object>> orderProductDetail1 = new ArrayList<>();
+
+ for(Map<String,Object> objectMap:orderDetails){
+ Map<String,Object> orderProductDetailMap1 = new HashMap<>();
+ orderProductDetailMap1.put("detail",objectMap.get("detail").toString());
+ List<Map<String,Object>> orderGlassDetails =orderGlassDetailMapper.getOrderGlassDetailByProductId(objectMap.get("order_id").toString(),
+ objectMap.get("detail").toString(), Long.valueOf(objectMap.get("product_id").toString()));
+ orderProductDetailMap1.put("orderGlassDetails",orderGlassDetails);
+ orderProductDetail1.add(orderProductDetailMap1);
+ }
+
+ /*orderDetails.forEach(orderDetail->{
+ List<OrderGlassDetail> glassChildList=orderGlassDetailMapper.getOrderGlassDetailByProductIdGlassChild(orderDetail.getOrderId(),orderDetail.getOrderNumber());
+
+ for (OrderGlassDetail glassChildLists:glassChildList){
+ orderProductDetailMap1.put("glassChild",glassChildLists.getGlassChild());
+ List<OrderGlassDetail> orderGlassDetails =orderGlassDetailMapper.getOrderGlassDetailByProductId(orderDetail.getOrderId(),orderDetail.getOrderNumber(),glassChildLists.getGlassChild());
+ Integer differentSize = orderGlassDetailMapper.getDifferentSizeNumber(orderId,orderDetail.getOrderNumber());
+ orderDetail.setDifferentSize(differentSize);
+ orderDetail.setOrderGlassDetails(orderGlassDetails);
+ orderProductDetailMap1.put("orderGlassDetail",orderGlassDetails);
+ }
+ orderProductDetail1.add(orderProductDetailMap1);
+
+ });*/
+ orderProductDetailMap.put("productDetail",orderProductDetail1);
+ orderProductDetail.add(orderProductDetailMap);
+ });
+ returns.put("orderDetail",orderProductDetail);
+ return returns;
+ }
+
+ public Object printOrderProductGlassDetail(String orderId) {
+ Map<String,Object> returns = new HashMap<>();
+ returns.put("order",orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",orderId)));
+
+ List<Map<String,Object>> orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderId);
+ List<Map<String,Object>> orderProductDetail = new ArrayList<>();
+ orderProductDistinct.forEach(map->{
+ Map<String,Object> orderProductDetailMap = new HashMap<>();
+ orderProductDetailMap.put("productId",map.get("productId"));
+ orderProductDetailMap.put("productName",map.get("productName"));
+ List<OrderDetail> orderDetails = orderDetailMapper.getOrderProductByProductId(map.get("productId"),orderId);
+ orderDetails.forEach(orderDetail->{
+ orderDetail.setGrossArea(
+ /*Double.parseDouble(String.format("%.3f",Double.parseDouble(
+ String.format("%.3f",
+ orderDetail.getWidth()*orderDetail.getHeight()/1000000)
+ ) * orderDetail.getQuantity()))*/
+ orderDetail.getComputeGrossArea()
+ );
+
+ List<OrderGlassDetail> orderGlassDetails =
+ orderGlassDetailMapper.selectList(
+ new QueryWrapper<OrderGlassDetail>().
+ eq("order_id",orderId).
+ eq("order_number",orderDetail.getOrderNumber())
+ );
+ Integer differentSize = orderGlassDetailMapper.getDifferentSizeNumber(orderId,orderDetail.getOrderNumber());
+ orderDetail.setDifferentSize(differentSize);
+ orderDetail.setOrderGlassDetails(orderGlassDetails);
+ });
+
+ orderProductDetailMap.put("productDetail",orderDetails);
+ orderProductDetail.add(orderProductDetailMap);
+ });
+ returns.put("orderDetail",orderProductDetail);
+
+
+
+
+
+
+
+ return returns;
+
+
+
+ }
+
+ public boolean updateOrderPrintNumber(String orderId) {
+ return orderMapper.updateOrderPrintNumber(orderId);
}
}
--
Gitblit v1.8.0