package com.example.erp.service.sd;
|
|
import cn.dev33.satoken.stp.StpUtil;
|
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.dto.sd.OrderDTO;
|
import com.example.erp.dto.sd.OrderDetailProductDTO;
|
import com.example.erp.dto.sd.OrderSearchDTO;
|
import com.example.erp.entity.sd.*;
|
import com.example.erp.entity.userInfo.Log;
|
import com.example.erp.entity.userInfo.SysError;
|
import com.example.erp.exception.ServiceException;
|
import com.example.erp.mapper.pp.FlowCardMapper;
|
import com.example.erp.mapper.pp.WorkOrderMapper;
|
import com.example.erp.mapper.sd.*;
|
import com.example.erp.service.userInfo.LogService;
|
import com.example.erp.service.userInfo.SysErrorService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.sql.SQLOutput;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static org.apache.coyote.http11.Constants.a;
|
|
@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 OrderOtherMoneyMapper orderOtherMoneyMapper;
|
private final ProductMapper productMapper;
|
private final LogService logService;
|
private final WorkOrderMapper workOrderMapper;
|
private final FlowCardMapper flowCardMapper;
|
|
private final OrderProcessDetailMapper orderProcessDetailMapper;
|
public OrderService(OrderMapper orderMapper, OrderDetailMapper orderDetailMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, SysErrorService sysErrorService, OrderOtherMoneyMapper orderOtherMoneyMapper, ProductMapper productMapper, LogService logService, WorkOrderMapper workOrderMapper, FlowCardMapper flowCardMapper) {
|
this.orderMapper = orderMapper;
|
this.orderDetailMapper = orderDetailMapper;
|
this.orderGlassDetailMapper = orderGlassDetailMapper;
|
this.orderProcessDetailMapper = orderProcessDetailMapper;
|
this.sysErrorService = sysErrorService;
|
this.orderOtherMoneyMapper = orderOtherMoneyMapper;
|
this.productMapper = productMapper;
|
this.logService = logService;
|
this.workOrderMapper = workOrderMapper;
|
this.flowCardMapper = flowCardMapper;
|
}
|
|
public boolean saveOrder(Map<String,Object> orderMap) throws Exception {
|
JSONObject orderJson = new JSONObject(orderMap);
|
String orderIdType = orderJson.getString("orderIdType");
|
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);
|
if(orderOtherMoneyList != null ){
|
orderOtherMoneyList = orderOtherMoneyList.stream().filter(o -> o.getColumn().indexOf("M")==0).collect(Collectors.toList());
|
}
|
|
boolean saveState = true;
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
//判断传入id参数是否为空，未传入id为空插入订单表，传入更新表
|
try{
|
Log log = new Log();
|
log.setOperator(orderJson.getString("creator"));
|
log.setOperatorId(orderJson.getString("creatorId"));
|
log.setContent(orderMap.toString());
|
|
if(order.getOrderId() == null || order.getOrderId().isEmpty()){
|
insertOrder(order,OrderDetails,orderOtherMoneyList,orderIdType);
|
log.setFunction("saveOrder创建:"+order.getOrderId());
|
}else {
|
updateOrder(order,OrderDetails,orderOtherMoneyList);
|
log.setFunction("saveOrder修改:"+order.getOrderId());
|
}
|
|
logService.saveLog(log);
|
}catch (Exception e){
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e.toString()+Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("saveOrder");
|
sysErrorService.insert(sysError);
|
saveState = false;
|
|
//throw new Exception();
|
}
|
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{
|
Log log = new Log();
|
log.setOperator(order.getCreator());
|
log.setOperatorId(order.getCreatorId());
|
log.setContent(orderMap.toString());
|
log.setFunction("saveOrderTitle保存表头:"+order.getOrderId());
|
|
Order order1 = orderMapper.selectOrderId(order.getOrderId());
|
//使用订单原本的状态和计算方式
|
order.setCalculateType(order1.getCalculateType());
|
order.setCreateOrder(order1.getCreateOrder());
|
order.setProcessReview(order1.getProcessReview());
|
order.setOrderReview(order1.getOrderReview());
|
order.setProductionOrder(order1.getProductionOrder());
|
order.setProcessingCard(order1.getProcessingCard());
|
order.setWarehousing(order1.getWarehousing());
|
order.setDelivery(order1.getDelivery());
|
|
LambdaUpdateWrapper<Order> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.eq(Order::getOrderId, order.getOrderId());
|
order.setCreateTime(null);
|
orderMapper.update(order,updateWrapper);
|
//修改订单主表面积与周长以及重量
|
orderMapper.updateOrderParameter(order.getOrderId());
|
logService.saveLog(log);
|
|
}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, String orderIdType) {
|
//根据传入的当前月份或者当天生成订单id
|
String orderId = getOrderId(orderIdType);
|
//往主表插数据
|
order.setOrderId(orderId);
|
order.setCreateOrder(2);
|
orderMapper.insert(order);
|
|
insertOtherDetail(orderId,OrderDetails,orderOtherMoneyList);
|
}
|
|
private String getOrderId(String dateType){
|
String orderId = null;
|
if(dateType==null || 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;
|
|
}else if(dateType.equals("year")){
|
Integer maxOrderId = orderMapper.selectMaxOrderIdByYear();
|
String formattedNumber = String.format("%06d", maxOrderId+1);
|
Date currentDate = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yy");
|
String formattedDate = dateFormat.format(currentDate);
|
orderId = "NG"+formattedDate+formattedNumber;
|
}
|
|
return orderId;
|
}
|
|
|
//修改订单数据，并且重新生成多个副表数据
|
public void updateOrder(Order order,List<OrderDetail> OrderDetails,List<OrderOtherMoney> orderOtherMoneyList) throws Exception {
|
Order oldOrder = orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderId,order.getOrderId()));
|
if(oldOrder.getProcessReview()==2){
|
throw new ServiceException(Constants.Code_600,"该订单已经审核，无法修改");
|
}
|
if(!Objects.equals(oldOrder.getVersion(), order.getVersion())){
|
throw new ServiceException(Constants.Code_600,"该订单已经修改，请刷新页面");
|
}
|
order.setCreateTime(null);
|
order.setVersion(order.getVersion()+1);
|
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
|
if(orderOtherMoneyList!=null){
|
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(Double.valueOf(String.format("%.3f",(OrderDetails.get(i).getWidth()+OrderDetails.get(i).getHeight())*2/1000*OrderDetails.get(i).getQuantity())));
|
OrderDetails.get(i).setMonolithicPerimeter(Double.valueOf(String.format("%.3f",(OrderDetails.get(i).getWidth()+OrderDetails.get(i).getHeight())*2/1000)));
|
Product product = productMapper.selectById(OrderDetails.get(i).getProductId());
|
|
OrderDetails.get(i).setWeight(Double.valueOf(String.format("%.2f",product.getThickness()*OrderDetails.get(i).getWidth()*OrderDetails.get(i).getHeight()/1000000*2.5)));
|
if(OrderDetails.get(i).getBendRadius()!=null && OrderDetails.get(i).getBendRadius()!=0){
|
//获取弯钢弧度
|
Double bendRadius = OrderDetails.get(i).getBendRadius();
|
//获取宽
|
Double width = OrderDetails.get(i).getWidth();
|
//获取拱高
|
String archRiseS = String.format("%.1f",bendRadius-(bendRadius*Math.cos(width/2/bendRadius)));
|
Double archRise = Double.parseDouble(archRiseS);
|
OrderDetails.get(i).setArchRise(archRise);
|
}
|
|
Map<String,Object> otherColumns = JSON.parseObject(OrderDetails.get(i).getOtherColumns(), new TypeReference<Map<String, Object>>(){});
|
int finalI = i;
|
if(otherColumns!=null){
|
otherColumns.values().removeIf(value -> value == null || value.equals(""));
|
OrderDetails.get(i).setOtherColumns(JSON.toJSONString(otherColumns));
|
|
otherColumns.forEach((key, value) ->{
|
|
if(value!=null && !value.equals("") && key.contains("M")) {
|
orderOtherMoneyList.forEach(orderOtherMoney -> {
|
if (orderOtherMoney.getColumn().equals(key)) {
|
orderOtherMoney.setQuantity(
|
orderOtherMoney.getQuantity()+(Double.parseDouble((String) value) * OrderDetails.get(finalI).getQuantity()));
|
}
|
});
|
}
|
|
});
|
}else{
|
OrderDetails.get(i).setOtherColumns("{}");
|
}
|
|
}
|
|
|
|
|
//往明细表插数据
|
orderDetailMapper.insertBatch(OrderDetails);
|
//往小片表传入产品数据
|
orderGlassDetailMapper.insertOrderGlassDetail(orderId);
|
if(orderOtherMoneyList!=null){
|
orderOtherMoneyList.forEach(orderOtherMoney ->{
|
orderOtherMoney.setId(null);
|
orderOtherMoney.setOrderId(orderId);
|
if(orderOtherMoney.getQuantity()!=null && orderOtherMoney.getPrice()!=null){
|
BigDecimal getQuantity= BigDecimal.valueOf(orderOtherMoney.getQuantity());
|
BigDecimal getPrice= BigDecimal.valueOf(orderOtherMoney.getPrice());
|
orderOtherMoney.setMoney(getQuantity.multiply(getPrice).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
}else {
|
orderOtherMoney.setMoney(0.0);
|
}
|
orderOtherMoneyMapper.insert(orderOtherMoney);
|
});
|
}
|
|
//修改订单主表面积与周长以及重量
|
orderMapper.updateOrderParameter(orderId);
|
|
|
}
|
|
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, Map<String,Object> config,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);
|
}
|
}
|
JSONObject orderJson = new JSONObject(config);
|
OrderSearchDTO order = JSONObject.parseObject(JSONObject.toJSONString(orderJson.get("filter")), OrderSearchDTO.class);
|
Map<String,String> sortDate = (Map<String, String>) config.get("sort");
|
String field = sortDate.get("field").replaceAll("(?<!^)([A-Z])", "_$1").toLowerCase();
|
String orderBy = sortDate.get("order");
|
|
Map<String,Object> map = new HashMap<>();
|
map.put("data",orderMapper.getOrderList(offset, pageSize, startDate, endDate, order,orderType, field, orderBy));
|
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, String userId, String userName) {
|
Log log = new Log();
|
log.setOperator(userName);
|
log.setOperatorId(userId);
|
log.setContent(status.toString());
|
log.setFunction("reviewOrderById:"+id);
|
logService.saveLog(log);
|
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);
|
}
|
|
}
|
//工艺审核界面审核更新数据
|
public boolean reviewProcessById(String id, Integer status,List<OrderGlassDetail> orderGlassDetails) {
|
Log log = new Log();
|
log.setContent(orderGlassDetails.toString());
|
log.setFunction("reviewProcessById:"+id);
|
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);
|
}
|
logService.saveLog(log);
|
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);
|
List<OrderOtherMoney> orderOtherMoneyList = JSONArray.parseArray(JSONObject.toJSONString(jsonObject.get("otherMoney")), OrderOtherMoney.class);
|
|
if(orderOtherMoneyList != null ){
|
orderOtherMoneyList = orderOtherMoneyList.stream().filter(o -> o.getColumn().indexOf("M")==0).collect(Collectors.toList());
|
}
|
if(orderOtherMoneyList!=null){
|
orderOtherMoneyList.forEach(orderOtherMoney -> {
|
orderOtherMoney.setQuantity(0.0);
|
});
|
}
|
|
Log log = new Log();
|
log.setOperator(order.getCreator());
|
log.setOperatorId(order.getCreatorId());
|
log.setContent(jsonObject.toString());
|
log.setFunction("updateOrderMoney金额重置:"+order.getOrderId());
|
|
//删除其他金额明细表
|
orderOtherMoneyMapper.delete(new LambdaQueryWrapper<OrderOtherMoney>().eq(OrderOtherMoney::getOrderId, order.getOrderId()));
|
List<OrderOtherMoney> orderOtherMoneyLists=orderOtherMoneyList;
|
|
double money = 0;
|
for (OrderDetail orderDetail : OrderDetails) {
|
orderDetail = updateOrderMoneyComputed(orderDetail,order.getCalculateType());
|
BigDecimal getGrossAmount= BigDecimal.valueOf(orderDetail.getGrossAmount());
|
money+=getGrossAmount.doubleValue();
|
|
Map<String,Object> otherColumns = JSON.parseObject(orderDetail.getOtherColumns(), new TypeReference<Map<String, Object>>(){});
|
if(otherColumns!=null){
|
otherColumns.values().removeIf(value -> value == null || value.equals(""));
|
orderDetail.setOtherColumns(JSON.toJSONString(otherColumns));
|
|
OrderDetail finalOrderDetail = orderDetail;
|
otherColumns.forEach((key, value) ->{
|
|
if(value!=null && !value.equals("") && key.contains("M")) {
|
orderOtherMoneyLists.forEach(orderOtherMoney -> {
|
if (orderOtherMoney.getColumn().equals(key)) {
|
orderOtherMoney.setQuantity(
|
orderOtherMoney.getQuantity()+(Double.parseDouble((String) value) * finalOrderDetail.getQuantity()));
|
}
|
});
|
}
|
|
});
|
}else{
|
orderDetail.setOtherColumns("{}");
|
}
|
|
}
|
|
if(orderOtherMoneyLists!=null){
|
orderOtherMoneyLists.forEach(orderOtherMoney ->{
|
orderOtherMoney.setId(null);
|
orderOtherMoney.setOrderId(order.getOrderId());
|
if(orderOtherMoney.getQuantity()!=null && orderOtherMoney.getPrice()!=null){
|
orderOtherMoney.setMoney((orderOtherMoney.getQuantity()*orderOtherMoney.getPrice()));
|
}else {
|
orderOtherMoney.setMoney(0.0);
|
}
|
orderOtherMoneyMapper.insert(orderOtherMoney);
|
});
|
}
|
|
order.setMoney(money+orderOtherMoneyMapper.selectGrossAmount(order.getOrderId()));
|
order.setOtherMoney(orderOtherMoneyMapper.selectGrossAmount(order.getOrderId()));
|
orderMapper.updateMoney(order);
|
orderDetailMapper.updateOrderMoney(OrderDetails);
|
logService.saveLog(log);
|
return false;
|
}
|
|
private OrderDetail updateOrderMoneyComputed(OrderDetail orderDetail, Integer calculateType) {
|
BigDecimal getPrice= BigDecimal.valueOf(orderDetail.getPrice());
|
BigDecimal getQuantity= BigDecimal.valueOf(orderDetail.getQuantity());
|
BigDecimal getComputeGrossArea= BigDecimal.valueOf(orderDetail.getComputeGrossArea());
|
BigDecimal getComputeArea= BigDecimal.valueOf(orderDetail.getComputeArea());
|
BigDecimal getWidth= BigDecimal.valueOf(orderDetail.getWidth());
|
BigDecimal getHeight= BigDecimal.valueOf(orderDetail.getHeight());
|
if (calculateType == 3) {
|
orderDetail.setGrossAmount(getPrice.multiply(getQuantity).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
}else if (calculateType == 4) {
|
if(Objects.equals(orderDetail.getArea(), orderDetail.getComputeArea())&&Objects.equals(orderDetail.getGrossArea(), orderDetail.getComputeGrossArea())){
|
orderDetail.setGrossAmount(getWidth.multiply(getHeight).multiply(getQuantity).multiply(getPrice).
|
divide(BigDecimal.valueOf(1000000), 2, RoundingMode.HALF_UP).doubleValue());
|
}else{
|
orderDetail.setGrossAmount(getPrice.multiply(getComputeGrossArea).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
}
|
}else if (calculateType == 1){
|
orderDetail.setGrossAmount(getPrice.multiply(getComputeArea).multiply(getQuantity).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
}else{
|
orderDetail.setGrossAmount(getPrice.multiply(getComputeGrossArea).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
}
|
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> getOrderSummaryReport(Integer pageNum, Integer pageSize, List<String> selectDate, Order order) {
|
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.getOrderSummaryReport(offset, pageSize, startDate, endDate, order));
|
map.put("total",orderDetailMapper.getOrderSummaryReportTotal(offset, pageSize, startDate, endDate, order,"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<Order> exportOrderSummary(List<LocalDate> dates) {
|
return orderDetailMapper.exportOrderSummary(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);
|
}
|
|
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->{
|
|
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);
|
});
|
|
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->{
|
|
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);
|
});
|
|
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 printOrderProductGlassDetailMonolithic(String orderId,List<String> productId) {
|
List<Map<String,Object>> orderProductDistinct;
|
if (productId.size()>0){
|
orderProductDistinct = orderDetailMapper.getOrderProductDistinctByIds(orderId,productId);
|
}else{
|
orderProductDistinct = orderDetailMapper.getOrderProductDistinctById(orderId);
|
}
|
|
Map<String,Object> returns = new HashMap<>();
|
returns.put("order",orderMapper.selectOne(new QueryWrapper<Order>().eq("order_id",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<Map<String,Object>> orderDetails = orderDetailMapper.getOrderProductByProductIds(map.get("productId"),orderId);
|
List<Map<String,Object>> orderProductDetail1 = new ArrayList<>();
|
|
for(Map<String,Object> objectMap:orderDetails){
|
Map<String,Object> orderProductDetailMap1 = new HashMap<>();
|
orderProductDetailMap1.put("detail",objectMap.get("detail").toString());
|
List<Map<String,Object>> orderGlassDetails =orderGlassDetailMapper.getOrderGlassDetailByProductId(objectMap.get("order_id").toString(),
|
objectMap.get("detail").toString(), Long.valueOf(objectMap.get("product_id").toString()));
|
orderProductDetailMap1.put("orderGlassDetails",orderGlassDetails);
|
orderProductDetail1.add(orderProductDetailMap1);
|
}
|
|
/*orderDetails.forEach(orderDetail->{
|
List<OrderGlassDetail> glassChildList=orderGlassDetailMapper.getOrderGlassDetailByProductIdGlassChild(orderDetail.getOrderId(),orderDetail.getOrderNumber());
|
|
for (OrderGlassDetail glassChildLists:glassChildList){
|
orderProductDetailMap1.put("glassChild",glassChildLists.getGlassChild());
|
List<OrderGlassDetail> orderGlassDetails =orderGlassDetailMapper.getOrderGlassDetailByProductId(orderDetail.getOrderId(),orderDetail.getOrderNumber(),glassChildLists.getGlassChild());
|
Integer differentSize = orderGlassDetailMapper.getDifferentSizeNumber(orderId,orderDetail.getOrderNumber());
|
orderDetail.setDifferentSize(differentSize);
|
orderDetail.setOrderGlassDetails(orderGlassDetails);
|
orderProductDetailMap1.put("orderGlassDetail",orderGlassDetails);
|
}
|
orderProductDetail1.add(orderProductDetailMap1);
|
|
});*/
|
orderProductDetailMap.put("productDetail",orderProductDetail1);
|
orderProductDetail.add(orderProductDetailMap);
|
});
|
returns.put("orderDetail",orderProductDetail);
|
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()))*/
|
orderDetail.getComputeGrossArea()
|
);
|
|
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;
|
|
|
|
}
|
|
public boolean updateOrderPrintNumber(String orderId) {
|
return orderMapper.updateOrderPrintNumber(orderId);
|
}
|
|
public String updateOrderId(Map<String, Object> map) {
|
String saveState = "true";
|
JSONObject orderJson = new JSONObject(map);
|
String oldOrderId = orderJson.getString("oldOrderId");
|
String newOrderId = orderJson.getString("newOrderId");
|
String orderIdType = orderJson.getString("orderIdType");
|
|
Log log = new Log();
|
log.setContent(map.toString());
|
log.setFunction("updateOrderId修改订单号");
|
log.setOperator(orderJson.getString("creator"));
|
|
|
if(!Objects.equals(newOrderId, oldOrderId)){
|
if(newOrderId.length()!=10){
|
return "false4";
|
}
|
if(!newOrderId.substring(2, 10).matches("\\d+")){
|
return "false5";
|
}
|
if(Objects.equals(orderIdType, "day")){
|
if(orderMapper.selectOrderIdDay(oldOrderId)==1){
|
return "false6";
|
}
|
}else if(Objects.equals(orderIdType, "month")){
|
if(orderMapper.selectOrderIdMonth(oldOrderId)==1){
|
return "false6";
|
}
|
}else if(Objects.equals(orderIdType, "year")){
|
if(orderMapper.selectOrderIdYear(oldOrderId)==1){
|
return "false6";
|
}
|
}
|
String substring = newOrderId.substring(1, 3);
|
Integer substringInt = Integer.parseInt(newOrderId.substring(2, 10));
|
if(!substring.equals("NG")){
|
substring="NG";
|
}
|
//大于输入订单号的数量
|
Integer count1 = orderMapper.selectOrderIdMin(substringInt);
|
//输入订单号存在的数量
|
Integer count2 = orderMapper.selectOrderIdIs(substringInt);
|
if(count1>0 && count2==0){
|
orderMapper.updateOrderId(oldOrderId,newOrderId);
|
saveState= "true";
|
logService.saveLog(log);
|
}else if(count1==0){
|
saveState= "false1";
|
;
|
}else if(count2>0){
|
saveState= "false2";
|
}
|
}else{
|
saveState= "false3";
|
}
|
return saveState;
|
}
|
|
public Boolean selectDifferentSize(String orderId) {
|
return !orderMapper.selectDifferentSize(orderId).isEmpty();
|
}
|
|
public Object processBack(String orderId,Integer status) {
|
//判断是否转优化
|
if(flowCardMapper.flowCardToOptimizeCount(orderId)>0){
|
return "false1";
|
}
|
//判断是否有报工
|
if(flowCardMapper.reportingWorkCountByOrderId(orderId)>0){
|
return "false2";
|
}
|
//判断是否有库存
|
if(orderMapper.searchOrderWarehousing(orderId)>0){
|
return "false3";
|
}
|
//退回到生产加工单
|
if(status<5){
|
//更新小片明细表分架状态
|
flowCardMapper.updateDeleteState(orderId,"all");
|
//删除此订单小片流程报工明细
|
flowCardMapper.deleteReportingWorkByOrderId(orderId);
|
//删除流程卡
|
flowCardMapper.deleteFlowCardMp(orderId,"all");
|
//删除流程卡排序
|
flowCardMapper.deleteflowCardSortByOrderId(orderId);
|
flowCardMapper.updateProcessingCard(orderId, 0);
|
}
|
//退回到订单审核后
|
if(status<4){
|
workOrderMapper.deleteOrderWorkMp(orderId, null);
|
workOrderMapper.updateWorkType(orderId, 0);
|
}
|
//退回到工艺审核后
|
if(status<3){
|
orderMapper.backReviewOrderById(orderId);
|
}
|
//退回到下单后
|
if(status<2){
|
orderMapper.reviewProcessById(orderId,0);
|
}
|
//日志传入
|
Log log = new Log();
|
log.setOperator((String) StpUtil.getLoginId());
|
log.setOperatorId((String) StpUtil.getLoginId());
|
log.setContent(String.valueOf(status));
|
log.setFunction("updateOrderMoney金额重置:"+orderId);
|
return true;
|
}
|
|
public Object scannerGlassInfo(String projectNo) {
|
try{
|
String projectId = "P" + projectNo.substring(0,8);
|
//炉号
|
Integer heatNo = Integer.valueOf(projectNo.substring(8,11));
|
//炉内序号
|
Integer sortNo = Integer.valueOf(projectNo.substring(11,14));
|
String processId = orderMapper.getProcessIdByOptimizeHeatDetail(projectId,heatNo,sortNo);
|
String orderId = flowCardMapper.getOrderIdByProcessId(processId);
|
return orderMapper.scannerGlassInfo(projectId,heatNo,sortNo,orderId);
|
}catch (Exception e){
|
return null;
|
}
|
|
}
|
}
|
