~admin/ERP_override.git

			@@ -1,23 +1,21 @@
			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.entity.sd.*;
			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.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;
			@@ -34,29 +32,33 @@
			private final OrderDetailMapper orderDetailMapper;
			private final OrderGlassDetailMapper orderGlassDetailMapper;
			private final SysErrorService sysErrorService;
			private final OrderOtherMoneyMapper orderOtherMoneyMapper;

			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) {
			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为空插入订单表，传入更新表
			try{
			if(order.getOrderId() == null \|\| order.getOrderId().isEmpty()){
			insertOrder(order,OrderDetails);
			insertOrder(order,OrderDetails,orderOtherMoneyList);
			}else {
			updateOrder(order,OrderDetails);
			updateOrder(order,OrderDetails,orderOtherMoneyList);
			}
			}catch (Exception e){
			TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
			@@ -72,7 +74,7 @@
			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);
			@@ -85,11 +87,11 @@
			order.setOrderId(orderId);
			order.setCreateOrder(2);
			orderMapper.insert(order);
			insertOtherDetail(orderId,OrderDetails);
			insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList);

			}
			//修改订单数据，并且重新生成多个副表数据
			public void updateOrder(Order order,List<OrderDetail> OrderDetails) {
			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);
			@@ -97,27 +99,66 @@
			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);
			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);
			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);
			//修改订单主表面积与周长以及重量
			orderMapper.updateOrderParameter(orderId);
			//往小片表传入产品数据
			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);
			@@ -176,9 +217,11 @@
			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;
			}
			//订单审核
			@@ -263,7 +306,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 +315,47 @@
			return map;
			}

			public List<Order> exportOrderReport() {
			return orderDetailMapper.exportOrderReport();
			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);
			}
			}