package com.example.erp.service.sd;
|
|
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.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.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.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.util.*;
|
|
@Service
|
@DS("sd")
|
@Transactional(rollbackFor = Exception.class)
|
public class OrderService {
|
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);
|
//格式化当前日期
|
Date currentDate = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
|
String formattedDate = dateFormat.format(currentDate);
|
String orderId = "NG"+formattedDate+formattedNumber;
|
//往主表插数据
|
order.setOrderId(orderId);
|
order.setCreateOrder(2);
|
orderMapper.insert(order);
|
insertOtherDetail(orderId,OrderDetails);
|
|
}
|
//修改订单数据，并且重新生成多个副表数据
|
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<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));
|
Map<String,Object> map = new HashMap<>();
|
map.put("order",order);
|
map.put("orderDetails",orderDetails);
|
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;
|
}
|
|
|
}
|
