提交后端报工转移程序

guoyujie

2025-03-25 97147c3155ef75e344cfbfc9752d08228cbabc64

提交后端报工转移程序

 north-glass-erp/src/main/java/com/example/erp/config/AppConfig.java

New file
@@ -0,0 +1,13 @@
package com.example.erp.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

 north-glass-erp/src/main/java/com/example/erp/controller/pp/ReportingWorkController.java

@@ -157,4 +157,10 @@
        return  Result.seccess(reportingWorkService.SaveReportingWorkSv(reportingWork));
    }

    @ApiOperation("报工转移")
    @PostMapping  ("/reportingWorkTransfer")
    public Result reportingWorkTransfer(@RequestBody Map<String,String> reportingWork)  {
        return  Result.seccess(reportingWorkService.reportingWorkTransferSv(reportingWork));
    }

}

 north-glass-erp/src/main/java/com/example/erp/controller/sd/OrderController.java

@@ -255,8 +255,15 @@
    @ApiOperation("手机扫码玻璃信息")
    @PostMapping("/scannerGlassInfo/{projectNo}")
    public Result scannerGlassInfo(@PathVariable String projectNo)  {
        System.out.println("123123");
        return  Result.seccess(orderService.scannerGlassInfo(projectNo));
    }

    @PostMapping("/test")
    public Result scannerGlassInfo()  {
        System.out.println("123123");
        return  Result.seccess(null);
    }


}

 north-glass-erp/src/main/java/com/example/erp/dto/pp/OrderNumberTransferDTO.java

New file
@@ -0,0 +1,45 @@
package com.example.erp.dto.pp;

import lombok.Data;

/**
 * 订单序号报工转换变更传输类
 */

@Data
public class OrderNumberTransferDTO {
    /**
     * 旧流程卡号
     */
    private String oldProcessId;

    /**
     * 旧序号
     */
    private String oldOrderNumber;

    /**
     * 旧层号
     */
    private Integer oldTechnologyNumber;

    /**
     * 信流程卡号
     */
    private String newProcessId;

    /**
     * 新序号
     */
    private String newOrderNumber;

    /**
     * 新层号
     */
    private Integer newTechnologyNumber;

    /**
     * 变更数量
     */
    private Integer changeNumber;
}

 north-glass-erp/src/main/java/com/example/erp/entity/pp/FlowCard.java

@@ -62,6 +62,10 @@
    private Integer sort;
    //架号
    private String rack;
    //订单转移导入数量
    private Integer importNumber;
    //订单转移导出数量
    private Integer exportNumber;
    //建立时间
    private LocalDate createTime;
    //修改时间

 north-glass-erp/src/main/java/com/example/erp/entity/pp/ReportingWorkTransfer.java

New file
@@ -0,0 +1,28 @@
package com.example.erp.entity.pp;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

import java.time.LocalDate;

@Data
public class ReportingWorkTransfer {
    @TableId(type = IdType.AUTO)
    private Long  id;
    //被转移订单号
    private String  oldOrder;
    //被转移序号
    private Integer  oldOrderNumber;
    //被转移内容（sd报工流程表）
    private String  oldReportContent;

    //新订单
    private String  newOrder;
    //新订单序号
    private Integer  newOrderNumber;
    //新转移内容
    private String  newReportContent;
    //建立时间
    private LocalDate createTime;
}

 north-glass-erp/src/main/java/com/example/erp/entity/sd/OrderDetail.java

@@ -4,6 +4,7 @@
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.example.erp.entity.mm.FinishedGoodsInventory;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -13,6 +14,7 @@
import java.util.List;

@Data
@TableName("sd.`order_detail`")
public class OrderDetail {
    @TableId(type = IdType.AUTO)
    private Long id;

 north-glass-erp/src/main/java/com/example/erp/mapper/pp/ReportingWorkTransferMapper.java

New file
@@ -0,0 +1,9 @@
package com.example.erp.mapper.pp;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.erp.entity.pp.ReportingWorkTransfer;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface ReportingWorkTransferMapper extends BaseMapper<ReportingWorkTransfer> {
}

 north-glass-erp/src/main/java/com/example/erp/service/pp/ReportingWorkService.java

@@ -4,19 +4,22 @@
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
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.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.example.erp.common.Constants;
import com.example.erp.entity.pp.DamageDetails;
import com.example.erp.entity.pp.FlowCard;
import com.example.erp.entity.pp.ReportingWork;
import com.example.erp.entity.pp.ReportingWorkDetail;
import com.example.erp.dto.pp.OrderNumberTransferDTO;
import com.example.erp.entity.pp.*;
import com.example.erp.entity.sd.Order;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.sd.OrderProcessDetail;
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.mm.FinishedOperateLogMapper;
import com.example.erp.mapper.pp.*;
import com.baomidou.dynamic.datasource.annotation.DS;
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;
@@ -25,9 +28,15 @@
import com.example.erp.service.userInfo.LogService;
import com.example.erp.service.userInfo.SysErrorService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.client.RestTemplate;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
@@ -36,36 +45,31 @@

@Service
@DS("pp")
@RequiredArgsConstructor
public class ReportingWorkService {
    final
    ReportingWorkMapper reportingWorkMapper;
    final
    BasicDateProduceMapper basicDateProduceMapper;
    final
    DamageDetailsMapper damageDetailsMapper;
    final
    OrderProcessDetailMapper orderProcessDetailMapper;
    final
    ReportingWorkDetailMapper
            reportingWorkDetailMapper;
    final OrderMapper
            orderMapper;
    private final ReportingWorkTransferMapper reportingWorkTransferMapper;
    private final ReportingWorkMapper reportingWorkMapper;
    private final BasicDateProduceMapper basicDateProduceMapper;
    private final DamageDetailsMapper damageDetailsMapper;
    private final OrderProcessDetailMapper orderProcessDetailMapper;
    private final ReportingWorkDetailMapper reportingWorkDetailMapper;
    private final OrderMapper  orderMapper;
    private final OrderDetailMapper orderDetailMapper;

    final
    FlowCardMapper flowCardMapper;
    private final FlowCardMapper flowCardMapper;

    final
    OrderProcessDetailService orderProcessDetailService;
    private final OrderProcessDetailService orderProcessDetailService;

    final
    LogService logService;
    private final LogService logService;

    final LogMapper logMapper;
    private final LogMapper logMapper;
    private final OrderGlassDetailMapper orderGlassDetailMapper;
    private final SysErrorService sysErrorService;
    private final FinishedOperateLogMapper finishedOperateLogMapper;
    private final RestTemplate restTemplate;


    public ReportingWorkService(ReportingWorkMapper reportingWorkMapper, BasicDateProduceMapper basicDateProduceMapper, DamageDetailsMapper damageDetailsMapper, ReportingWorkDetailMapper reportingWorkDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, OrderProcessDetailService orderProcessDetailService, OrderMapper orderMapper, FlowCardMapper flowCardMapper, LogService logService, LogMapper logMapper, OrderGlassDetailMapper orderGlassDetailMapper, SysErrorService sysErrorService) {
    /*public ReportingWorkService(ReportingWorkMapper reportingWorkMapper, BasicDateProduceMapper basicDateProduceMapper, DamageDetailsMapper damageDetailsMapper, ReportingWorkDetailMapper reportingWorkDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, OrderProcessDetailService orderProcessDetailService, OrderMapper orderMapper, FlowCardMapper flowCardMapper, LogService logService, LogMapper logMapper, OrderGlassDetailMapper orderGlassDetailMapper, SysErrorService sysErrorService, OrderDetailMapper orderDetailMapper, FinishedOperateLogMapper finishedOperateLogMapper, ReportingWorkTransferMapper reportingWorkTransferMapper) {
        this.reportingWorkMapper = reportingWorkMapper;
        this.basicDateProduceMapper = basicDateProduceMapper;
        this.damageDetailsMapper = damageDetailsMapper;
@@ -78,7 +82,10 @@
        this.logMapper = logMapper;
        this.orderGlassDetailMapper = orderGlassDetailMapper;
        this.sysErrorService = sysErrorService;
    }
        this.orderDetailMapper = orderDetailMapper;
        this.finishedOperateLogMapper = finishedOperateLogMapper;
        this.reportingWorkTransferMapper = reportingWorkTransferMapper;
    }*/

    public Map<String, Object> AddSelectLastWorkSv(String processIdStr, String technologyStr, String process, String reportType) {
        Map<String, Object> map = new HashMap<>();
@@ -819,4 +826,188 @@

        }
    }

    @Transactional(rollbackFor = Exception.class)
    public Object reportingWorkTransferSv(Map<String, String> reportingWork) {
        Order oldOrder = orderMapper.selectOrderId(reportingWork.get("oldOrderId"));
        OrderDetail oldOrderDetail = orderDetailMapper.selectOne(
                new QueryWrapper<OrderDetail>()
                        .eq("order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
        );

        Order newOrder = orderMapper.selectOrderId(reportingWork.get("newOrderId"));
        OrderDetail newOrderDetail = orderDetailMapper.selectOne(
                new QueryWrapper<OrderDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
        );
        if(!Objects.equals(oldOrder.getCustomerId(), newOrder.getCustomerId())){
            return "新旧订单客户不一致";
        }
        if(!Objects.equals(oldOrderDetail.getProductId(), newOrderDetail.getProductId())){
            return "新旧订单产品不一致";
        }
        if (!Objects.equals(oldOrderDetail.getWidth(), newOrderDetail.getWidth())
                || !Objects.equals(oldOrderDetail.getHeight(), newOrderDetail.getHeight())){
            return "新旧订单尺寸不一致";
        }


        //获取旧订单是否流程卡是否存在
        List<OrderProcessDetail> oldOrderProcessDetailList = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                );
        if(oldOrderProcessDetailList.isEmpty()){
            return "旧订单未分流程卡";
        }
        //获取新订单是否流程卡是否存在
        List<OrderProcessDetail> newOrderProcessDetailList = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
                );
        if(newOrderProcessDetailList.isEmpty()){
            return "新订单未分流程卡";
        }
        //新订单是否存在已经排版序号
        List<FlowCard> newFlowCardLayoutStatus = flowCardMapper.selectList(new QueryWrapper<FlowCard>()
                .eq("order_id", reportingWork.get("newOrderId"))
                .eq("order_number", reportingWork.get("newOrderNumber"))
                .gt("layout_status",0)
        );
        if(!newFlowCardLayoutStatus.isEmpty()){
            return "新订单此序号存在排版";
        }
        //获取旧订单报工数据汇总
        List<OrderProcessDetail> oldOrderProcessDetailForReport = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq( "order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                        .gt("reporting_work_num",0)
        );

        Map<String,Object> log = new HashMap<>();
        log.put("oldOrderBeforeChange",oldOrderProcessDetailForReport);

        Map<String,Object> newOrderLog = new HashMap<>();
        newOrderLog.put("newOrderBeforeChange",newOrderProcessDetailList);

        //传给mes流程卡数量集合
        List<OrderNumberTransferDTO> orderNumberTransferList = new ArrayList<>();

        oldOrderProcessDetailForReport.forEach(oldOrderProcessDetail -> {
            int maxNum = 0;
            for(OrderProcessDetail newOrderProcessDetail : newOrderProcessDetailList){
                if(oldOrderProcessDetail.getReportingWorkNum() == 0){
                    break;
                }
                //判断小片是否一致，工序是否一致
                if(newOrderProcessDetail.getProcess().equals(oldOrderProcessDetail.getProcess()) &&
                        Objects.equals(newOrderProcessDetail.getTechnologyNumber(), oldOrderProcessDetail.getTechnologyNumber())){
                    //判断是否为第一道工序，给可转移最大值赋值
                    if(oldOrderProcessDetail.getProcess().equals("切割")){
                        FlowCard  thisFlowCard = flowCardMapper.selectOne(new QueryWrapper<FlowCard>()
                                .eq("process_id", newOrderProcessDetail.getProcessId())
                                .eq("order_number", newOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
                        );
                        maxNum = thisFlowCard.getQuantity();
                    }else{
                        //当不是第一道工序则，拿上一道工序作为最大值
                        maxNum = orderProcessDetailMapper.selectById(newOrderProcessDetail.getId()-1).getReportingWorkNum();
                    }
                    //判断被转移的数量是否大于可转移的数量最大值
                    int transferNum = 0;
                    if(oldOrderProcessDetail.getReportingWorkNum() > maxNum){
                        transferNum = maxNum;
                        oldOrderProcessDetail.setReportingWorkNum(oldOrderProcessDetail.getReportingWorkNum()-maxNum);
                        oldOrderProcessDetail.setReportingWorkNumCount(oldOrderProcessDetail.getReportingWorkNumCount()-maxNum);
                    }else{
                        transferNum = oldOrderProcessDetail.getReportingWorkNum();
                        oldOrderProcessDetail.setReportingWorkNum(0);
                        oldOrderProcessDetail.setReportingWorkNumCount(0);
                    }
                    //更新旧订单小片流程表的报工数量
                    orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
                            .set("reporting_work_num",oldOrderProcessDetail.getReportingWorkNum())
                            .set("reporting_work_num_count",oldOrderProcessDetail.getReportingWorkNumCount())
                            .eq("id",oldOrderProcessDetail.getId())
                    );
                    //更新新订单小片流程表的报工数量
                    orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
                            .set("reporting_work_num",transferNum)
                            .set("reporting_work_num_count",transferNum)
                            .eq("id",newOrderProcessDetail.getId())
                    );
                    if(oldOrderProcessDetail.getProcess().equals("切割")){
                        //更新旧订单流程卡转出数量
                        flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
                                .setSql("export_number = export_number + "+transferNum)
                                .eq("process_id", oldOrderProcessDetail.getProcessId())
                                .eq("order_number", oldOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",oldOrderProcessDetail.getTechnologyNumber())
                        );
                        //更新新订单流程卡转出数量
                        flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
                                .setSql("import_number = import_number + "+transferNum)
                                .eq("process_id", newOrderProcessDetail.getProcessId())
                                .eq("order_number", newOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
                        );

                        //传给mes数据赋值
                        OrderNumberTransferDTO orderNumberTransfer = new OrderNumberTransferDTO();
                        orderNumberTransfer.setChangeNumber(transferNum);
                        orderNumberTransfer.setOldProcessId(oldOrderProcessDetail.getProcessId());
                        orderNumberTransfer.setNewProcessId(newOrderProcessDetail.getProcessId());
                        orderNumberTransfer.setOldOrderNumber(oldOrderProcessDetail.getOrderNumber());
                        orderNumberTransfer.setNewOrderNumber(newOrderProcessDetail.getOrderNumber());
                        orderNumberTransfer.setOldTechnologyNumber(oldOrderProcessDetail.getTechnologyNumber());
                        orderNumberTransfer.setNewTechnologyNumber(newOrderProcessDetail.getTechnologyNumber());
                        orderNumberTransferList.add(orderNumberTransfer);

                    }

                }
            }
        });


        //把旧订单数据和新订单数据传到日志表当中
        log.put("oldOrderChange",JSON.toJSONString(oldOrderProcessDetailForReport));

        newOrderLog.put("newOrderChange",orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
                ));
        //旧订单信息传入日志
        ReportingWorkTransfer reportingWorkTransfer = new ReportingWorkTransfer();
        reportingWorkTransfer.setOldOrder(reportingWork.get("oldOrderId"));
        reportingWorkTransfer.setOldOrderNumber(Integer.valueOf(reportingWork.get("oldOrderNumber")));
        reportingWorkTransfer.setOldReportContent(JSON.toJSONString(log));

        //新订单信息传入日志
        reportingWorkTransfer.setNewOrder(reportingWork.get("newOrderId"));
        reportingWorkTransfer.setNewOrderNumber(Integer.valueOf(reportingWork.get("newOrderNumber")));
        reportingWorkTransfer.setNewReportContent(JSON.toJSONString(newOrderLog));
        reportingWorkTransferMapper.insert(reportingWorkTransfer);
        //restTemplate.postForObject("http://localhost:8086/order/test",orderNumberTransferList,String.class);

        //向mes发送http请求
        ResponseEntity<String> response =restTemplate.exchange(
                "http://localhost:88/api/loadGlass/order/order/orderChange",
                HttpMethod.POST,
                new HttpEntity<>(orderNumberTransferList),
                String.class);

        if(response.getStatusCode() == HttpStatus.OK){
            return true;
        }else{
            return "mes响应超时";
        }
    }
}

 north-glass-erp/src/main/resources/mapper/pp/ReportingWork.xml

@@ -137,8 +137,8 @@
            ogd.child_width,
            ogd.child_height,
            if(od.shape=1,'普形',if(od.shape=2,'异形','')) as shape,
            fc.quantity + ifnull(patch.patch_num,0) -odpd.reporting_work_num -odpd.broken_num   as quantity,
            fc.quantity + ifnull(patch.patch_num,0) -odpd.reporting_work_num -odpd.broken_num   as completedQuantity,
            fc.quantity -fc.export_number + ifnull(patch.patch_num,0) -odpd.reporting_work_num -odpd.broken_num   as quantity,
            fc.quantity -fc.export_number + ifnull(patch.patch_num,0) -odpd.reporting_work_num -odpd.broken_num   as completedQuantity,
            odpd.reporting_work_num as completed,
            odpd.broken_num as onceBroken,
            if(fc.quantity -odpd.reporting_work_num = 0 ,true,false) as saveFlag, -- 判断是否已经完成，已经完成不序号和同序号数量相同才能提交