package com.example.northglasserpclient.service.sd.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.TypeReference;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.example.northglasserpclient.domain.dto.sd.OrderDTO;
|
import com.example.northglasserpclient.domain.dto.sd.OrderDetailDTO;
|
import com.example.northglasserpclient.domain.po.sd.Order;
|
import com.example.northglasserpclient.domain.po.sd.OrderDetail;
|
import com.example.northglasserpclient.domain.po.sd.OrderGlassDetail;
|
import com.example.northglasserpclient.domain.po.sd.OrderProcessDetail;
|
import com.example.northglasserpclient.mapper.sd.OrderMapper;
|
import com.example.northglasserpclient.mapper.sd.OrderProcessDetailMapper;
|
import com.example.northglasserpclient.service.sd.IOrderDetailService;
|
import com.example.northglasserpclient.service.sd.IOrderGlassDetailService;
|
import com.example.northglasserpclient.service.sd.IOrderProcessDetailService;
|
import com.example.northglasserpclient.service.sd.IOrderService;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
|
import java.time.LocalDate;
|
import java.util.*;
|
|
/**
|
* <p>
|
* 服务实现类
|
* </p>
|
*
|
* @author guo
|
* @since 2025-09-18
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {
|
|
private final IOrderDetailService orderDetailService;
|
private final IOrderProcessDetailService orderProcessDetailService;
|
private final IOrderGlassDetailService orderGlassDetailService;
|
private final OrderProcessDetailMapper orderProcessDetailMapper;
|
@Override
|
public List<OrderDTO> getUnfinishedOrder(String customId) {
|
List<Order> orders = list(
|
new LambdaQueryWrapper<Order>()
|
.eq(Order::getCustomerId, customId)
|
.eq(Order::getCreateOrder, 2)
|
.ne(Order::getDelivery, 2)
|
.orderByDesc(Order::getId)
|
);
|
|
List<OrderDTO> ordersDTO = JSON.parseObject(
|
JSON.toJSONString(orders),
|
new TypeReference<List<OrderDTO>>(){}
|
);
|
|
//循环所有订单，获取订单按照产品分类进行订单明细 汇总查询
|
ordersDTO.forEach(order -> {
|
List<OrderDetail> details = orderDetailService.list(
|
new QueryWrapper<OrderDetail>()
|
.select("order_id,order_number,product_id,product_name," +
|
"sum(quantity) as quantity," +
|
"sum(warehouse_num+delivery_num) as warehouse_num,"+
|
"sum(delivery_num) as delivery_num"
|
)
|
.eq("order_id", order.getOrderId())
|
.groupBy("product_id")
|
);
|
//list转换成DTO,返回前端显示
|
List<OrderDetailDTO> detailsDTO = JSON.parseObject(
|
JSON.toJSONString(details),
|
new TypeReference<List<OrderDetailDTO>>(){}
|
);
|
//循环获取每个产品的完成数
|
detailsDTO.forEach(detail -> {
|
|
|
|
|
|
//获取产品生产订单号例："NG25082706A"做条件,查询生产订单明细表，获取生产总数量
|
OrderGlassDetail glassDetail = orderGlassDetailService
|
.getOne(new LambdaQueryWrapper<OrderGlassDetail>()
|
.eq(OrderGlassDetail::getOrderId, detail.getOrderId())
|
.eq(OrderGlassDetail::getOrderNumber, detail.getOrderNumber())
|
.orderByAsc(OrderGlassDetail::getId)
|
.last("limit 1")
|
);
|
//给产品信息添加生产数量
|
if(glassDetail != null){
|
Integer getReportingWorkNum = orderProcessDetailMapper
|
.getProductionQuantity(detail.getOrderId(),
|
glassDetail.getProductionId()
|
);
|
|
detail.setQuantityByProduced(getReportingWorkNum);
|
}else{
|
detail.setQuantityByProduced(0);
|
}
|
});
|
Integer deliveryNum = detailsDTO.stream().map(OrderDetail::getDeliveryNum).reduce(Integer::sum).get();
|
order.setPercent(deliveryNum/Math.toIntExact(order.getQuantity())*100);
|
order.setOrderDetails(detailsDTO);
|
});
|
return ordersDTO;
|
}
|
|
@Override
|
public List<OrderDetailDTO> getOrderProgress(String orderId, String productId) {
|
//获取此订单 产品所有订单明细
|
List<OrderDetail> detailList = orderDetailService.list(
|
new LambdaQueryWrapper<OrderDetail>()
|
.eq(OrderDetail::getOrderId, orderId)
|
.eq(OrderDetail::getProductId, productId)
|
);
|
List<OrderDetailDTO> detailListDTO = JSON.parseObject(
|
JSON.toJSONString(detailList),
|
new TypeReference<List<OrderDetailDTO>>(){}
|
);
|
//获取订单生产明细
|
detailListDTO.forEach(detail1 -> {
|
List<OrderProcessDetail> processDetailsGroupByProcessId = orderProcessDetailService.list(
|
new LambdaQueryWrapper<OrderProcessDetail>()
|
.eq(OrderProcessDetail::getOrderId, detail1.getOrderId())
|
.eq(OrderProcessDetail::getOrderNumber, detail1.getOrderNumber())
|
.groupBy(OrderProcessDetail::getProcessId)
|
.groupBy(OrderProcessDetail::getTechnologyNumber)
|
.orderByAsc(OrderProcessDetail::getOrderNumber)
|
.orderByAsc(OrderProcessDetail::getTechnologyNumber)
|
|
);
|
//定义一个map，key为生产工序号+工艺号，value为生产明细
|
Map<String,List<OrderProcessDetail>> orderProcessDetailCount = new HashMap<>();
|
processDetailsGroupByProcessId.forEach(detail2 -> {
|
List<OrderProcessDetail> processDetails = orderProcessDetailService.list(
|
new LambdaQueryWrapper<OrderProcessDetail>()
|
.eq(OrderProcessDetail::getOrderId, detail2.getOrderId())
|
.eq(OrderProcessDetail::getOrderNumber, detail2.getOrderNumber())
|
.eq(OrderProcessDetail::getProcessId, detail2.getProcessId())
|
.eq(OrderProcessDetail::getTechnologyNumber, detail2.getTechnologyNumber())
|
);
|
orderProcessDetailCount.put(detail2.getProcessId()+"/"+detail2.getTechnologyNumber(),
|
processDetails);
|
|
});
|
//给订单明细添加生产明细
|
detail1.setOrderProcessDetails(orderProcessDetailCount);
|
|
|
});
|
return detailListDTO;
|
}
|
|
@Override
|
public Map<String,Object> getFinishedOrder(Map<String,Object> object) {
|
|
List<String> dates = (List<String>) object.get("searchDate");
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(180).toString();
|
if(dates !=null && dates.size()==2){
|
if(!dates.get(0).isEmpty()){
|
startDate = dates.get(0);
|
}
|
if(!dates.get(1).isEmpty()){
|
endDate = dates.get(1);
|
}
|
}
|
|
//获取此客户所有完成的订单
|
List<Order> orders = list(
|
new LambdaQueryWrapper<Order>()
|
.eq(Order::getCustomerId, object.get("customerId"))
|
.eq(Order::getCreateOrder, 2)
|
.eq(Order::getDelivery, 2)
|
.between(Order::getCreateTime, startDate, endDate)
|
.orderByDesc(Order::getId)
|
);
|
List<OrderDTO> ordersDTO = JSON.parseObject(
|
JSON.toJSONString(orders),
|
new TypeReference<List<OrderDTO>>(){}
|
);
|
Map<String,Object> result = new HashMap<>();
|
result.put("orders",ordersDTO);
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
result.put("searchDate",list);
|
|
return result;
|
}
|
|
@Override
|
public List<OrderDetail> getOrderDetail(String orderId) {
|
return orderDetailService.list(new LambdaQueryWrapper<OrderDetail>().eq(OrderDetail::getOrderId,orderId));
|
}
|
}
|
