Merge branch 'master' of http://bore.pub:10439/r/ERP_override

廖井涛

2024-07-05 615d0a9e2011510b589ccc3b4bc58894a39e8295

 north-glass-erp/src/main/java/com/example/erp/service/sd/OrderService.java

@@ -15,7 +15,6 @@
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;
@@ -23,6 +22,7 @@
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

@Service
@DS("sd")
@@ -49,7 +49,7 @@
        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);

        orderOtherMoneyList = orderOtherMoneyList.stream().filter(o -> o.getColumn().indexOf("M")==0).collect(Collectors.toList());
        boolean saveState = true;
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
@@ -73,39 +73,102 @@
        }
        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());
            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);
        //格式化当前日期
        Date currentDate = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
        String formattedDate = dateFormat.format(currentDate);
        String orderId =  "NG"+formattedDate+formattedNumber;

        String orderId =  getOrderId("day");
        //往主表插数据
        order.setOrderId(orderId);
        order.setCreateOrder(2);
        orderMapper.insert(order);
        insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList);

        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;

        }

        return orderId;
    }


    //修改订单数据，并且重新生成多个副表数据
    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()));
            //删除订单明细表
            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);
            //删除订单工艺表
            // orderProcessDetailMapper.delete(new LambdaQueryWrapper<OrderProcessDetail>().eq(OrderProcessDetail::getOrderId, order.getOrderId()));
            insertOtherDetail(order.getOrderId(),OrderDetails,orderOtherMoneyList);
    }


@@ -121,7 +184,7 @@
        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).setPerimeter(Double.valueOf(String.format("%.3f",(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){
                //获取弯钢弧度
@@ -158,7 +221,6 @@
        orderDetailMapper.insertBatch(OrderDetails);
        //往小片表传入产品数据
        orderGlassDetailMapper.insertOrderGlassDetail(orderId);
        //往订单其他金额副表传入数据
        orderOtherMoneyList.forEach(orderOtherMoney ->{
            orderOtherMoney.setId(null);
            orderOtherMoney.setOrderId(orderId);
@@ -170,11 +232,7 @@
        //修改订单主表面积与周长以及重量
        orderMapper.updateOrderParameter(orderId);

        //查询订单小片表获取工艺传入小片工艺表
        //List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper.selectOrderGlassDetail(orderId);
        /*List<OrderProcessDetail> orderProcessDetailList = getOrderProcessDetails(orderGlassDetails);
        //赋值订单工艺表
        orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);*/
        
    }

    public static List<OrderProcessDetail> getOrderProcessDetails(List<OrderGlassDetail> orderGlassDetails) {
@@ -229,6 +287,8 @@
        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);
@@ -236,12 +296,16 @@
        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) {
@@ -276,12 +340,21 @@
        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();
        }
        order.setMoney(money);
        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()));
        orderMapper.updateMoney(order);
        orderDetailMapper.updateOrderMoney(OrderDetails);
        return false;
@@ -369,4 +442,116 @@
    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 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);
            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;



    }
}