From 2f640b1038fa331954f78ed1f4317212cf5bb34d Mon Sep 17 00:00:00 2001
From: chenlu <1320612696@qq.com>
Date: 星期五, 07 六月 2024 16:56:06 +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 |  347 ++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 files changed, 316 insertions(+), 31 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..64baf4d 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,80 @@
 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 com.sun.org.apache.regexp.internal.RE;
 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 void insertOrder(Order order,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) {
         Integer maxOrderId = orderMapper.selectMaxOrderId();
         //鏌ヨ璁㈠崟id锛屽苟涓旇嚜澧�
         String formattedNumber = String.format("%02d", maxOrderId+1);
@@ -58,19 +85,277 @@
         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);
+            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) {
+        Order order = orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",id));
+        if(order.getProcessReview()!=2){
+            throw  new ServiceException(Constants.Code_600,"璇ヨ鍗曡繕鏈鏍�");
+        }
+        return orderMapper.reviewOrderById(id,status);
+    }
+    //宸ヨ壓瀹℃牳鐣岄潰瀹℃牳鏇存柊鏁版嵁
+    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);
     }
 }

--
Gitblit v1.8.0