~admin/ERP_override.git

			@@ -3,31 +3,73 @@
			import com.alibaba.fastjson.JSONArray;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.dynamic.datasource.annotation.DS;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
			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.entity.userInfo.SysError;
			import com.example.erp.mapper.sd.OrderDetailMapper;
			import com.example.erp.mapper.sd.OrderGlassDetailMapper;
			import com.example.erp.mapper.sd.OrderMapper;
			import org.springframework.beans.factory.annotation.Autowired;
			import com.example.erp.mapper.sd.OrderProcessDetailMapper;
			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(rollbackFor = Exception.class)
			public class OrderService {
			@Autowired
			private OrderMapper orderMapper;
			@Transactional
			public boolean saveOrder(Map<String,Object> orderMap) {
			private final OrderMapper orderMapper;
			private final OrderDetailMapper orderDetailMapper;
			private final OrderGlassDetailMapper orderGlassDetailMapper;
			private final SysErrorService sysErrorService;

			private final OrderProcessDetailMapper orderProcessDetailMapper;
			public OrderService(OrderMapper orderMapper, OrderDetailMapper orderDetailMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, SysErrorService sysErrorService) {
			this.orderMapper = orderMapper;
			this.orderDetailMapper = orderDetailMapper;
			this.orderGlassDetailMapper = orderGlassDetailMapper;
			this.orderProcessDetailMapper = orderProcessDetailMapper;
			this.sysErrorService = sysErrorService;
			}

			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);
			boolean saveState = true;
			//设置回滚点
			Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
			//判断传入id参数是否为空，未传入id为空插入订单表，传入更新表
			try{
			if(order.getOrderId() == null \|\| order.getOrderId().isEmpty()){
			insertOrder(order,OrderDetails);
			}else {
			updateOrder(order,OrderDetails);
			}
			}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 void insertOrder(Order order,List<OrderDetail> OrderDetails) {
			Integer maxOrderId = orderMapper.selectMaxOrderId();
			//查询订单id，并且自增
			String formattedNumber = String.format("%02d", maxOrderId+1);
			@@ -35,11 +77,82 @@
			Date currentDate = new Date();
			SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
			String formattedDate = dateFormat.format(currentDate);
			order.setOrderId("NG"+formattedDate + formattedNumber);

			//System.out.println(order);
			String orderId = "NG"+formattedDate+formattedNumber;
			//往主表插数据
			order.setOrderId(orderId);
			orderMapper.insert(order);
			insertOtherDetail(orderId,OrderDetails);

			return false;
			}
			//修改订单数据，并且重新生成多个副表数据
			public void updateOrder(Order order,List<OrderDetail> OrderDetails) {
			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);
			}


			//插入其他副表数据，被其他方法引用
			public void insertOtherDetail(String orderId,List<OrderDetail> OrderDetails) {
			//循环给订单明细表字段添加序号和周长
			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);
			}
			//往明细表插数据
			orderDetailMapper.insertBatch(OrderDetails);
			//修改订单主表面积与周长以及重量
			orderMapper.updateOrderParameter(orderId);
			//往小片表传入产品数据
			orderGlassDetailMapper.insertOrderGlassDetail(orderId);
			//查询订单小片表获取工艺传入小片工艺表
			List<OrderGlassDetail> orderGlassDetails = orderGlassDetailMapper.selectOrderGlassDetail(orderId);
			List<OrderProcessDetail> orderProcessDetailList = getOrderProcessDetails(orderGlassDetails);
			//赋值订单工艺表
			orderProcessDetailMapper.insertOrderProcessDetail(orderProcessDetailList);
			}

			private 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<LocalDate> selectDate, Order order,Integer orderType) {
			Integer offset = (pageNum-1)*pageSize;
			LocalDate endDate = LocalDate.now();
			LocalDate startDate = endDate.minusDays(15);

			if(selectDate == null && selectDate.size()==2){
			startDate = selectDate.get(0);
			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));
			map.put("startDate",startDate);
			map.put("endDate",endDate);
			return map;
			}
			}