From c46cb6a71c35f38c7f23a2d01ad686f46a3d0e0b Mon Sep 17 00:00:00 2001
From: 廖井涛 <2265517004@qq.com>
Date: 星期三, 26 六月 2024 15:14:44 +0800
Subject: [PATCH] Merge branch 'master' of http://bore.pub:10439/r/ERP_override
---
north-glass-erp/src/main/java/com/example/erp/service/sd/OrderService.java | 481 ++++++++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 451 insertions(+), 30 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 475abf2..69fe059 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,53 +1,122 @@
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.example.erp.entity.sd.Order;
-import com.example.erp.entity.sd.OrderDetail;
-import com.example.erp.mapper.sd.OrderDetailMapper;
-import com.example.erp.mapper.sd.OrderMapper;
-import org.springframework.beans.factory.annotation.Autowired;
+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.dto.sd.OrderDTO;
+import com.example.erp.entity.sd.*;
+import com.example.erp.entity.userInfo.SysError;
+import com.example.erp.exception.ServiceException;
+import com.example.erp.mapper.sd.*;
+import com.example.erp.service.userInfo.SysErrorService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
@Service
@DS("sd")
-@Transactional
+@Transactional(rollbackFor = Exception.class)
public class OrderService {
- @Autowired
- private OrderMapper orderMapper;
- @Autowired
- private OrderDetailMapper orderDetailMapper;
+ private final OrderMapper orderMapper;
+ private final OrderDetailMapper orderDetailMapper;
+ private final OrderGlassDetailMapper orderGlassDetailMapper;
+ private final SysErrorService sysErrorService;
+ private final OrderOtherMoneyMapper orderOtherMoneyMapper;
- public boolean saveOrder(Map<String,Object> orderMap) {
+ private final OrderProcessDetailMapper orderProcessDetailMapper;
+ public OrderService(OrderMapper orderMapper, OrderDetailMapper orderDetailMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, SysErrorService sysErrorService, OrderOtherMoneyMapper orderOtherMoneyMapper) {
+ this.orderMapper = orderMapper;
+ this.orderDetailMapper = orderDetailMapper;
+ this.orderGlassDetailMapper = orderGlassDetailMapper;
+ this.orderProcessDetailMapper = orderProcessDetailMapper;
+ this.sysErrorService = sysErrorService;
+ this.orderOtherMoneyMapper = orderOtherMoneyMapper;
+ }
+
+ public boolean saveOrder(Map<String,Object> orderMap) throws Exception {
JSONObject orderJson = new JSONObject(orderMap);
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);
+
boolean saveState = true;
+ //璁剧疆鍥炴粴鐐�
+ Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
//鍒ゆ柇浼犲叆id鍙傛暟鏄惁涓虹┖锛屾湭浼犲叆id涓虹┖鎻掑叆璁㈠崟琛紝浼犲叆鏇存柊琛�
- // System.out.println(order);
- if(order.getOrderId() == null || order.getOrderId().isEmpty()){
- insertOrder(order,OrderDetails);
- }else {
- saveState = updateOrder(order,OrderDetails);
+ try{
+ if(order.getOrderId() == null || order.getOrderId().isEmpty()){
+ insertOrder(order,OrderDetails,orderOtherMoneyList);
+ }else {
+ updateOrder(order,OrderDetails,orderOtherMoneyList);
+ }
+ }catch (Exception e){
+ TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
+ //灏嗗紓甯镐紶鍏ユ暟鎹簱
+ SysError sysError = new SysError();
+ sysError.setError(e.toString());
+ sysError.setFunc("saveOrder");
+ sysErrorService.insert(sysError);
+ saveState = false;
+
+ //throw new Exception();
}
-
-
-
-
- return true;
+ return saveState;
}
- public void insertOrder(Order order,List<OrderDetail> OrderDetails) {
+ 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());
+ orderMapper.update(order,updateWrapper);
+ //淇敼璁㈠崟涓昏〃闈㈢Н涓庡懆闀夸互鍙婇噸閲�
+ orderMapper.updateOrderParameter(order.getOrderId());
+
+ }catch (Exception e){
+ TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
+ //灏嗗紓甯镐紶鍏ユ暟鎹簱
+ SysError sysError = new SysError();
+ sysError.setError(e.toString());
+ sysError.setFunc("saveOrder");
+ sysErrorService.insert(sysError);
+ saveState = false;
+
+ //throw new Exception();
+ }
+ 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,List<OrderOtherMoney> orderOtherMoneyList) {
Integer maxOrderId = orderMapper.selectMaxOrderId();
//鏌ヨ璁㈠崟id锛屽苟涓旇嚜澧�
String formattedNumber = String.format("%02d", maxOrderId+1);
@@ -58,19 +127,371 @@
String orderId = "NG"+formattedDate+formattedNumber;
//寰�涓昏〃鎻掓暟鎹�
order.setOrderId(orderId);
+ order.setCreateOrder(2);
orderMapper.insert(order);
+
+ insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList);
+
+
+ }
+ //淇敼璁㈠崟鏁版嵁锛屽苟涓旈噸鏂扮敓鎴愬涓壇琛ㄦ暟鎹�
+ public void updateOrder(Order order,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
+ 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()));
+ //鍒犻櫎鍏朵粬閲戦鏄庣粏琛�
+ 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,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);
+ OrderDetails.get(i).setPerimeter((OrderDetails.get(i).getWidth()+OrderDetails.get(i).getHeight())*2/1000);
OrderDetails.get(i).setWeight(1.0);
+ 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.forEach((key, value) ->{
+ if(value!=null && key.contains("M")) {
+ orderOtherMoneyList.forEach(orderOtherMoney -> {
+ if (orderOtherMoney.getColumn().equals(key)) {
+ orderOtherMoney.setQuantity(orderOtherMoney.getQuantity()+(Double.parseDouble((String) value) * OrderDetails.get(finalI).getQuantity()));
+ }
+ });
+ }
+
+ });
+ }
}
+
+
+
+
//寰�鏄庣粏琛ㄦ彃鏁版嵁
orderDetailMapper.insertBatch(OrderDetails);
+ //寰�灏忕墖琛ㄤ紶鍏ヤ骇鍝佹暟鎹�
+ orderGlassDetailMapper.insertOrderGlassDetail(orderId);
+ //寰�璁㈠崟鍏朵粬閲戦鍓〃浼犲叆鏁版嵁
+ 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);
+
+ //鏌ヨ璁㈠崟灏忕墖琛ㄨ幏鍙栧伐鑹轰紶鍏ュ皬鐗囧伐鑹鸿〃
+ //List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper.selectOrderGlassDetail(orderId);
+ /*List<OrderProcessDetail> orderProcessDetailList = getOrderProcessDetails(orderGlassDetails);
+ //璧嬪�艰鍗曞伐鑹鸿〃
+ orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);*/
}
- public boolean updateOrder(Order order,List<OrderDetail> OrderDetails) {
- return false;
+ public static List<OrderProcessDetail> getOrderProcessDetails(List<OrderGlassDetail> orderGlassDetails) {
+ List<OrderProcessDetail> orderProcessDetailList = new ArrayList<>();
+ for (OrderGlassDetail orderGlassDetail : orderGlassDetails) {
+ String[] processList = orderGlassDetail.getProcess().split("->");
+ for (String process : processList) {
+ OrderProcessDetail orderProcessDetail = new OrderProcessDetail();
+ orderProcessDetail.setOrderId(orderGlassDetail.getOrderId());
+ orderProcessDetail.setOrderNumber(orderGlassDetail.getOrderNumber());
+ orderProcessDetail.setTechnologyNumber(orderGlassDetail.getTechnologyNumber());
+ orderProcessDetail.setProcess(process);
+ orderProcessDetailList.add(orderProcessDetail);
+ }
+ }
+ return orderProcessDetailList;
+ }
+
+ //鏌ヨ鑾峰彇鍒楄〃
+ public Map<String,Object> getOrderList(Integer pageNum, Integer pageSize, List<String> selectDate, Order order,Integer orderType) {
+ 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",orderMapper.getOrderList(offset, pageSize, startDate, endDate, order,orderType));
+ map.put("total",orderMapper.getPageTotal(offset, pageSize, startDate, endDate, order,orderType));
+ List<String> list = new ArrayList<>();
+ list.add(startDate);
+ list.add(endDate);
+ map.put("selectDate",list);
+ return map;
+ }
+ //鍒犻櫎璁㈠崟
+ public Integer deleteOrder(String id) {
+ return orderMapper.delete(
+ new QueryWrapper<Order>().eq("order_id",id)
+ );
+ }
+
+
+ //鏌ヨ璁㈠崟涓昏〃涓庡壇琛ㄤ俊鎭�
+ 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, 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);
+ }
+
+ }
+ //宸ヨ壓瀹℃牳鐣岄潰瀹℃牳鏇存柊鏁版嵁
+ public boolean reviewProcessById(String id, Integer status,List<OrderGlassDetail> orderGlassDetails) {
+ if(!orderGlassDetails.isEmpty() && status==2){
+ orderGlassDetails.forEach(orderGlassDetail ->{
+ double area = Math.round((orderGlassDetail.getChildWidth()*orderGlassDetail.getChildHeight()/1000000) * 100) * 0.01d;
+ orderGlassDetail.setArea(area);
+ });
+
+ orderGlassDetailMapper.updateSizeAndProcess(orderGlassDetails);
+ orderProcessDetailMapper.delete(new QueryWrapper<OrderProcessDetail>().eq("order_id",id));
+ //鏌ヨ璁㈠崟灏忕墖琛ㄨ幏鍙栧伐鑹轰紶鍏ュ皬鐗囧伐鑹鸿〃
+ //List<OrderGlassDetail> orderGlassDetailList = orderGlassDetailMapper.selectOrderGlassDetail(id);
+// List<OrderProcessDetail> orderProcessDetailList = getOrderProcessDetails(orderGlassDetailList);
+// //璧嬪�艰鍗曞伐鑹鸿〃
+// orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);
+ }
+
+ return orderMapper.reviewProcessById(id,status);
+ }
+ //宸ヨ壓瀹℃牳鐣岄潰鏁版嵁鏌ヨ
+ public Map<String,Object> getOrderCraftById(String id) {
+ Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
+ List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper.selectOrderGlassDetailByOrderId(id);
+ Map<String,Object> map = new HashMap<>();
+ map.put("order",order);
+ map.put("orderGlassDetails",orderGlassDetails);
+ return map;
+ }
+
+ public boolean updateOrderMoney(Map<String, Object> map) {
+ 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);
+ double money = 0;
+ for (OrderDetail orderDetail : OrderDetails) {
+ orderDetail = updateOrderMoneyComputed(orderDetail,order.getCalculateType());
+ money+= orderDetail.getGrossAmount();
+ }
+ order.setMoney(money);
+ orderMapper.updateMoney(order);
+ orderDetailMapper.updateOrderMoney(OrderDetails);
+ return false;
+ }
+
+ private OrderDetail updateOrderMoneyComputed(OrderDetail orderDetail, Integer calculateType) {
+ if (calculateType == 3) {
+ orderDetail.setGrossAmount(orderDetail.getPrice() * orderDetail.getQuantity());
+ } else {
+ orderDetail.setGrossAmount(orderDetail.getComputeGrossArea() * orderDetail.getPrice());
+ }
+ return orderDetail;
+ }
+
+
+ public Integer cancelOrder(String id) {
+ return orderMapper.cancelOrder(id);
+ }
+
+
+ public Map<String,Object> getOrderReport(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.getOrderReport(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);
+ map.put("selectDate",list);
+// map.put("total",orderMapper.getPageTotal(offset, pageSize, startDate, endDate, orderDetail));
+ return map;
+ }
+
+ public List<OrderDTO> exportOrderReport(List<LocalDate> dates) {
+ return orderDetailMapper.exportOrderReport(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);
+ orderDetails.forEach(orderDetail->{
+
+ orderDetail.setGrossArea(
+ Double.parseDouble(String.format("%.3f",Double.parseDouble(
+ String.format("%.3f",
+ orderDetail.getWidth()*orderDetail.getHeight()/1000000)
+ ) * orderDetail.getQuantity()))
+ );
+ });
+
+ 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 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()))
+ );
+
+ 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;
+
+
+
}
}
--
Gitblit v1.8.0