Merge remote-tracking branch 'origin/bfasrs6' into bfasrs6

bfwms

2025-06-27 541343ce5f5a3c438875f26418957360f779c004

Merge remote-tracking branch 'origin/bfasrs6' into bfasrs6

 src/main/java/com/zy/asrs/controller/OpenController.java

@@ -4,11 +4,10 @@
import com.core.annotations.AppAuth;
import com.core.common.*;
import com.core.exception.CoolException;
import com.zy.asrs.entity.param.OpenOrderCompleteParam;
import com.zy.asrs.entity.param.OpenOrderPakinParam;
import com.zy.asrs.entity.param.OpenOrderPakoutParam;
import com.zy.asrs.entity.param.PackParam;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.service.OpenService;
import com.zy.asrs.service.WrkMastService;
import com.zy.common.model.DetlDto;
import com.zy.common.web.BaseController;
import lombok.extern.slf4j.Slf4j;
@@ -35,6 +34,8 @@

    @Autowired
    private OpenService openService;
    @Autowired
    private WrkMastService wrkMastService;



@@ -58,29 +59,7 @@



    /**
     * 添加入库单
     */
    @PostMapping("/order/pakin/new/default/v1")
    public synchronized R pakinOrderCreate(@RequestHeader(required = false) String appkey,
                                           @RequestBody OpenOrderPakinParam param,
                                           HttpServletRequest request) {
        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
        }
        if (Cools.isEmpty(param.getOrderNo())) {
            return R.error("单据编号[orderNo]不能为空");
        }
        if (Cools.isEmpty(param.getOrderType())) {
            return R.error("单据类型[orderType]不能为空");
        }
        if (Cools.isEmpty(param.getOrderDetails())) {
            return R.error("单据明细[orderDetails]不能为空");
        }
        openService.pakinOrderCreate(param);
        return R.ok();
    }


    /**
     * 入库单回写
@@ -93,36 +72,7 @@
        return R.ok().add(openService.pakinOrderComplete(param));
    }

    /**
     * 添加出库单
     */
    @PostMapping("/order/pakout/new/default/v1")
    @AppAuth(memo = "添加订单出库")
    public synchronized R pakoutOrderCreate(@RequestHeader(required = false) String appkey,
                                            @RequestBody OpenOrderPakoutParam param,
                                            HttpServletRequest request) {
        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
        }
        //if (Cools.isEmpty(param.getLgort())) {
        //    return R.error("单据编号[lgort]不能为空");
        //}
        //if (!param.getLgort().equals("5006")) {
        //    return R.ok();
        //}
        if (Cools.isEmpty(param.getOrderNo())) {
            return R.error("单据编号[orderNo]不能为空");
        }
        if (Cools.isEmpty(param.getOrderType())) {
            return R.error("单据类型[orderType]不能为空");
        }
        if (Cools.isEmpty(param.getOrderDetails())) {
            return R.error("单据明细[orderDetails]不能为空");
        }
        openService.pakoutOrderCreate(param);
        return R.ok();
    }


    /**
     * 出库单回写
@@ -161,6 +111,106 @@
        }
    }





    @PostMapping("/order/matSync/default/v2")
//    @AppAuth(memo = "商品信息同步接口")
    public synchronized R syncMatInfoV2(@RequestHeader(required = false) String appkey,
                                        @RequestBody(required = false) MatSyncParam.MatParam param,
                                        HttpServletRequest request){

        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
        }
        MatSyncParam matSyncParam = new MatSyncParam();
        List<MatSyncParam.MatParam> objects = new ArrayList<>();
        objects.add(param);
        matSyncParam.matDetails = objects;
        openService.syncMat(matSyncParam);
        return R.ok();
    }

    /**
     * 添加入库单
     */
    @PostMapping("/order/pakin/new/default/v1")
    public synchronized R pakinOrderCreate(@RequestHeader(required = false) String appkey,
                                           @RequestBody OpenOrderPakinParam param,
                                           HttpServletRequest request) {
        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
        }
        if (Cools.isEmpty(param.getOrderNo())) {
            return R.error("单据编号[orderNo]不能为空");
        }
        if (Cools.isEmpty(param.getOrderType())) {
            return R.error("单据类型[orderType]不能为空");
        }
        if (Cools.isEmpty(param.getOrderDetails())) {
            return R.error("单据明细[orderDetails]不能为空");
        }
        openService.pakinOrderCreate(param);
        return R.ok();
    }

    /**
     * 添加出库单
     */
    @PostMapping("/order/pakout/new/default/v1")
    @AppAuth(memo = "添加订单出库")
    public synchronized R pakoutOrderCreate(@RequestHeader(required = false) String appkey,
                                            @RequestBody OpenOrderPakoutParam param,
                                            HttpServletRequest request) {
        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
        }
        if (Cools.isEmpty(param.getOrderNo())) {
            return R.error("单据编号[orderNo]不能为空");
        }
        if (Cools.isEmpty(param.getOrderType())) {
            return R.error("单据类型[orderType]不能为空");
        }
        if (Cools.isEmpty(param.getOrderDetails())) {
            return R.error("单据明细[orderDetails]不能为空");
        }
        openService.pakoutOrderCreate(param);
        return R.ok();
    }


    /**
     * 捡料转全板
     */
    @PostMapping("/pickToFill/barcode")
    @AppAuth(memo = "捡料转全板")
    public synchronized R againOut(@RequestHeader(required = false) String appkey,
                                            @RequestBody PackParam param,
                                            HttpServletRequest request) {
        auth(appkey, param, request);
        if (Cools.isEmpty(param)||Cools.isEmpty(param.getBarcode())) {
            return R.error("托盘码为空,请检查");
        }
        WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarcode());
        if (Cools.isEmpty(wrkMast)) {
            return R.error("无法通过托盘码找到该工作档,请检查托盘码是否正确");
        }
        if (wrkMast.getIoType() != 103) {
            return R.error("仅有捡料出库可以使用该功能");
        }
        if (wrkMast.getWrkSts() != 17) {
            return R.error("捡料出库未完成,请等待设备运行完成");
        }
        openService.pickToFill(wrkMast);
        return R.ok();
    }



    public static void main(String[] args) {
        // 1
        System.out.println("======================================");

 src/main/java/com/zy/asrs/entity/OrderDetl.java

@@ -77,9 +77,9 @@
    private String maktx;

    /**
     * 序列码
     * 批号
     */
    @ApiModelProperty(value= "序列码")
    @ApiModelProperty(value= "批号")
    private String batch;

    /**
@@ -89,28 +89,59 @@
    private String specs;

    /**
     * 型号
     * 组织编码
     */
    @ApiModelProperty(value= "型号")
    @ApiModelProperty(value= "组织编码")
    private String manu;

    /**
     * 项次
     */
    @ApiModelProperty(value= "项次")
    private String model;

    /**
     * 颜色
     * 任务仓库
     */
    @ApiModelProperty(value= "颜色")
    @ApiModelProperty(value= "任务仓库")
    private String color;

    /**
     * 品牌
     * 任务储位
     */
    @ApiModelProperty(value= "品牌")
    @ApiModelProperty(value= "任务储位")
    private String brand;

    /**
     * 单位
     * 单位编码
     */
    @ApiModelProperty(value= "单位")
    @ApiModelProperty(value= "单位编码")
    private String unit;

    /**
     * 单位名称
     */
    @ApiModelProperty(value= "单位名称")
    private String sku;

    /**
     * 供应商编码
     */
    @ApiModelProperty(value= "供应商编码")
    @TableField("item_num")
    private String itemNum;

    /**
     * 托盘码
     */
    @ApiModelProperty(value= "托盘码")
    private String barcode;

    /**
     * 供应商名称
     */
    @ApiModelProperty(value= "供应商名称")
    private String origin;

    /**
     * 单价
@@ -119,34 +150,11 @@
    private Double price;

    /**
     * sku
     */
    @ApiModelProperty(value= "sku")
    private String sku;

    /**
     * 单位量
     */
    @ApiModelProperty(value= "单位量")
    private Double units;

    /**
     * 条码
     */
    @ApiModelProperty(value= "条码")
    private String barcode;

    /**
     * 产地
     */
    @ApiModelProperty(value= "产地")
    private String origin;

    /**
     * 厂家
     */
    @ApiModelProperty(value= "厂家")
    private String manu;

    /**
     * 生产日期
@@ -154,13 +162,6 @@
    @ApiModelProperty(value= "生产日期")
    @TableField("manu_date")
    private String manuDate;

    /**
     * 品项数
     */
    @ApiModelProperty(value= "品项数")
    @TableField("item_num")
    private String itemNum;

    /**
     * 安全库存量

 src/main/java/com/zy/asrs/entity/param/MatSyncParam.java

New file
@@ -0,0 +1,210 @@
package com.zy.asrs.entity.param;

import com.baomidou.mybatisplus.annotations.TableField;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.List;

/**
 * 商品同步接口，参数
 * Created on 2022/6/22
 */
@Data
public class MatSyncParam {

    /**
     *  创建时间
     */
    public String createTime;

    public List<MatParam> matDetails;

    @Data
    public static class MatParam{
        /**
         * 商品编号
         */
        private String matnr;

        /**
         * 商品名称
         */
        private String maktx;

        /**
         * 商品分类
         */
        private String groupCode;

        /**
         * 分类名称
         */
        private String groupName;

        /**
         * 别名
         */
        private String name;

        /**
         * 规格
         */
        private String specs;

        /**
         * 型号
         */
        private String model;

        /**
         * 颜色
         */
        private  String color;

        /**
         * 品牌
         */
        private String brand;

        /**
         * 单位
         */
        private String unit;

        /**
         * 单价
         */
        private Double price;

        /**
         * sku
         */
        private String sku;

        /**
         * 单位量
         */
        private Double units;

        /**
         * 条码
         */
        private String barcode;

        /**
         * 产地
         */
        private String origin;

        /**
         * 厂家
         */
        private String manu;

        /**
         * 生产日期
         */
        private String manuDate;

        /**
         * 品项数
         */
        private String itemNum;

        /**
         * 安全库存量
         */
        private Double safeQty;

        /**
         * 重量
         */
        private Double weight;

        /**
         * 长度
         */
        private Double length;

        /**
         * 体积
         */
        private Double volume;

        /**
         * 三方编码
         */
        private String threeCode;

        /**
         * 供应商
         */
        private String supp;

        /**
         * 供应商编码
         */
        private String suppCode;

        /**
         * 是否批次 1: 是  0: 否
         */
        private Integer beBatch;

        /**
         * 保质期
         */
        private String deadTime;

        /**
         * 预警天数
         */
        private Integer deadWarn;

        /**
         * 来源 1: 制造  2: 采购  3: 外协
         */
        private Integer source;

        /**
         * 要求检验 1: 是  0: 否
         */
        private Integer inspect;

        /**
         * 危险品 1: 是  0: 否
         */
        private Integer danger;

        /**
         * 状态 1: 正常  0: 禁用
         */
        private Integer status;
        /**
         * 高频入出库物料
         */
        private Boolean inoutEveryday;

        /**
         * 上架区域{1:单品区,2:高频混放区,3:低频混放区}
         */
        private Integer matType;

        /**
         * 添加人员
         */
        private String createBy;

        /**
         * 添加时间
         */
        private String createTime;

        /**
         * 备注
         */
        private String memo;
    }

}

 src/main/java/com/zy/asrs/entity/result/OrderResult.java

New file
@@ -0,0 +1,51 @@
package com.zy.asrs.entity.result;

import lombok.Data;

@Data
public class OrderResult {
    //组织编码
    private String orgNo;

    //单据类别
    private String docType;

    //订单编号
    private String docNo;

    //项次（行号）
    private String docSeqNo;

    //任务仓库
    private String docWarehouseNo;

    //任务储位
    private String docCellNo;

    //任务批次
    private String docLotNo;

    //物料编码
    private String itemNo;

    //品名
    private String itemName;

    //规格
    private String itemSpec;

    //入库数量
    private double applyQty;

    //单位编码
    private String unitNo;

    //单位名称
    private String unitName;

    //供应商编码
    private String supplierNo;

    //供应商名称
    private String supplierName;
}

 src/main/java/com/zy/asrs/service/OpenService.java

@@ -1,9 +1,7 @@
package com.zy.asrs.service;

import com.zy.asrs.entity.param.OpenOrderCompleteParam;
import com.zy.asrs.entity.param.OpenOrderPakinParam;
import com.zy.asrs.entity.param.OpenOrderPakoutParam;
import com.zy.asrs.entity.param.PackParam;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
import com.zy.asrs.entity.result.StockVo;

@@ -41,4 +39,8 @@
    // 打包上线
    void packageUp(PackParam param);

    void pickToFill(WrkMast wrkMast);


    void syncMat(MatSyncParam param);
}

 src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java

@@ -3,13 +3,11 @@
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.R;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.OpenOrderCompleteParam;
import com.zy.asrs.entity.param.OpenOrderPakinParam;
import com.zy.asrs.entity.param.OpenOrderPakoutParam;
import com.zy.asrs.entity.param.PackParam;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.mapper.TagMapper;
@@ -17,6 +15,7 @@
import com.zy.asrs.utils.MatUtils;
import com.zy.common.model.DetlDto;
import com.zy.common.utils.NodeUtils;
import com.zy.common.utils.Synchro;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -51,6 +50,14 @@
    private TagService tagService;
    @Autowired
    private TagMapper tagMapper;

    @Autowired
    private WrkMastService wrkMastService;

    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private LocMastService locMastService;

    @Override
    @Transactional
@@ -273,6 +280,34 @@
    }

    @Override
    @Transactional
    public void pickToFill(WrkMast wrkMast) {
        Date now = new Date();
        wrkMast.setIoType(101);
        wrkMast.setMemo("捡料转全板工作档");
        wrkMastService.update(wrkMast, new EntityWrapper<WrkMast>()
                .eq("wrk_no", wrkMast.getWrkNo()));
        wrkDetlService.deleteByWrkNo(wrkMast.getWrkNo());
        List<LocDetl> locDetls = locDetlService.selectByLocNo(wrkMast.getSourceLocNo());
        for (LocDetl locDetl : locDetls) {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(locDetl);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setIoTime(wrkMast.getIoTime());
            wrkDetl.setZpallet(wrkDetl.getBarcode());
            wrkDetl.setBarcode(wrkMast.getBarcode());
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiTime(now);
            wrkDetl.setAppeUser(1L);
            wrkDetl.setModiUser(1L);
            wrkDetl.setMatType(locDetl.getMatType());
            wrkDetlService.insert(wrkDetl);
        }
        locMastService.updateLocSts(wrkMast.getSourceLocNo(), "R");
    }


    @Override
    public List<OpenOrderCompeteResult> pakoutOrderComplete(OpenOrderCompleteParam param) {
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
@@ -438,4 +473,113 @@
        }
    }

    @Override
    @Transactional
    public void syncMat(MatSyncParam param) {
        if (Cools.isEmpty(param.getMatDetails()) || param.getMatDetails().size() <= 0) {
            throw new CoolException("商品数据为空");
        }
        for (MatSyncParam.MatParam matParam : param.getMatDetails()) {
            if (Cools.isEmpty(matParam.getMatnr())) {
                throw new CoolException("商品编码不能为空");
            }
            if (Cools.isEmpty(matParam.getInoutEveryday())) {
                throw new CoolException("是否为高频入出库物料标识不能为空");
            }
            if (Cools.isEmpty(matParam.getMatType())) {
                throw new CoolException("上架区域不能为空");
            }
            Date now = new Date();
            Mat mat = matService.selectByMatnr(matParam.getMatnr());
            if (mat == null) {
                mat = new Mat();
                // 分类
                Long tagId;
                // 一级分类
                if (!Cools.isEmpty(matParam.getGroupCode()) && !Cools.isEmpty(matParam.getGroupName())) {
                    Tag priTag = tagService.selectOne(new EntityWrapper<Tag>().eq("name", matParam.getGroupCode()));
                    if (priTag == null) {
                        Tag top = tagService.getTop();
                        NodeUtils nodeUtils = new NodeUtils();
                        nodeUtils.executePath(top.getId());
                        priTag = new Tag(
                                null,    // 编号
                                matParam.getGroupCode(),    // 名称
                                top.getId(),    // 父级
                                top.getName(),    // 父级名称
                                nodeUtils.path.toString(),    // 关联路径
                                nodeUtils.pathName.toString(),    // 关联路径名
                                0,    // 类型
                                null,    // 负责人
                                null,    // 图片
                                null,    // 简要描述
                                null,    // 数量
                                2,    // 等级
                                null,    // 排序
                                1,    // 状态
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                null    // 备注
                        );
                        if (tagMapper.insert(priTag) == 0) {
                            throw new CoolException("服务器内部错误，请联系管理员");
                        }
                    }
                    // 二级分类
                    Tag secTag = tagService.selectByName(matParam.getGroupName(), 3);
                    if (secTag == null) {
                        NodeUtils nodeUtils = new NodeUtils();
                        nodeUtils.executePath(priTag.getId());
                        secTag = new Tag(
                                null,    // 编号
                                matParam.getGroupName(),    // 名称
                                priTag.getId(),    // 父级
                                priTag.getName(),    // 父级名称
                                nodeUtils.path.toString(),    // 关联路径
                                nodeUtils.pathName.toString(),    // 关联路径名
                                0,    // 类型
                                null,    // 负责人
                                null,    // 图片
                                null,    // 简要描述
                                null,    // 数量
                                3,    // 等级
                                null,    // 排序
                                1,    // 状态
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                null    // 备注
                        );
                        if (tagMapper.insert(secTag) == 0) {
                            throw new CoolException("服务器内部错误，请联系管理员");
                        }
                    }
                    tagId = secTag.getId();
                } else {
                    tagId = tagService.getTop().getId();
                }
                Synchro.Copy(matParam,mat);


                mat.setTagId(tagId);
                mat.setStatus(1);
                mat.setCreateTime(now);
                mat.setUpdateTime(now);
                if (!matService.insert(mat)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                } else {
                    log.info("同步新物料[商品编号：{}]", mat.getMatnr());
                }
            } else {
                Synchro.Copy(matParam,mat);
                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr", matParam.getMatnr()))) {
                    throw new CoolException("更新已存在商品信息失败，请联系管理员");
                }
            }
        }

    }
}

 src/main/java/com/zy/asrs/task/CollectOrdersScheduler.java

New file
@@ -0,0 +1,193 @@
package com.zy.asrs.task;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.result.OrderResult;
import com.zy.asrs.service.*;
import com.zy.asrs.service.impl.DocTypeServiceImpl;
import com.zy.common.utils.HttpHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.HashMap;

@Service
@Slf4j
public class CollectOrdersScheduler extends AbstractHandler<String> {
    @Value("${erp.address.URL}")
    private String URL;
    @Value("${erp.address.inaddress}")
    private String inaddress;

    @Autowired
    private OrderService orderService;
    @Autowired
    private DocTypeService docTypeService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private MatService matService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private ApiLogService apiLogService;

    /**
     * 轮询获取入库订单
     */
    @Scheduled(cron = "0/10 * * * * ? ")
    private void execute() {
        // 获取当前日期时间
        LocalDateTime now = LocalDateTime.now();

        // 减去一个月
        LocalDateTime oneMonthAgo = now.minusMonths(1);

        // 定义日期时间格式（HH表示24小时制）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 格式化日期时间
        String formattedDateTime = oneMonthAgo.format(formatter);

        HashMap<String, Object> map = new HashMap<>();
        map.put("orgNo", 0);//组织编号
//        map.put("docNo",0);
        map.put("startTime", formattedDateTime);//开始时间

        String format = now.format(formatter);
        map.put("endTime", format);//结束时间

        //查询订单
        String response = "";
        boolean success = false;
        try {
            response = new HttpHandler.Builder()
                    .setUri(URL)
                    .setPath(inaddress)
                    .setJson(JSON.toJSONString(map))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);
            if (jsonObject.getInteger("status") == 200) {
                JSONArray response1 = JSON.parseArray(jsonObject.get("response").toString());
                for (int j = 0; j < response1.size(); j++) {
                    OrderResult orderResult = response1.getObject(0, OrderResult.class);
                    Order order = orderService.selectByNo(orderResult.getDocNo());//单据编号
                    if (Cools.isEmpty(order)) {
                        Date now1 = new Date();
                        DocType docType = docTypeService.selectOne(new EntityWrapper<DocType>().eq("memo",orderResult.getDocType()));//单据编号
                        // 单据主档
                        order = new Order(
                                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                                orderResult.getDocNo(),    // 订单编号
                                DateUtils.convert(now1),    // 单据日期
                                docType.getDocId(),    // 单据类型
                                null,    // 项目编号
                                null,    //
                                null,    // 调拨项目编号
                                null,    // 初始票据号
                                null,    // 票据号
                                null,    // 客户编号
                                null,    // 客户
                                null,    // 联系方式
                                null,    // 操作人员
                                null,    // 合计金额
                                null,    // 优惠率
                                null,    // 优惠金额
                                null,    // 销售或采购费用合计
                                null,    // 实付金额
                                null,    // 付款类型
                                null,    // 业务员
                                null,    // 结算天数
                                null,    // 邮费支付类型
                                null,    // 邮费
                                null,    // 付款时间
                                null,    // 发货时间
                                null,    // 物流名称
                                null,    // 物流单号
                                1L,    // 订单状态
                                1,    // 状态
                                9527L,    // 添加人员
                                now1,    // 添加时间
                                9527L,    // 修改人员
                                now1,    // 修改时间
                                null    // 备注
                        );
                    }
                    //物料编码
                    Mat mat = matService.selectByMatnr(orderResult.getItemNo());
                    if (Cools.isEmpty(mat)) {
                        throw new CoolException(orderResult.getItemNo() + "编号商品检索失败，请先添加商品");
                    }
                    OrderDetl orderDetl1 = orderDetlService.selectOne(new EntityWrapper<OrderDetl>()
                            .eq("order_no", orderResult.getDocNo())
                            .eq("matnr", orderResult.getItemNo())
                            .eq("batch", orderResult.getDocLotNo()));//批号
                    if (!Cools.isEmpty(orderDetl1)) {
                        continue;
                    }
                    DocType docType = docTypeService.selectById(orderResult.getDocType());
                    OrderDetl orderDetl = new OrderDetl();
                    orderDetl.sync(mat);
                    orderDetl.setBatch(orderResult.getDocLotNo());
                    orderDetl.setAnfme(orderResult.getApplyQty());
                    orderDetl.setOrderId(order.getId());
                    orderDetl.setOrderNo(order.getOrderNo());
                    orderDetl.setCreateBy(9527L);
                    orderDetl.setCreateTime(new Date());
                    orderDetl.setUpdateBy(9527L);
                    orderDetl.setUpdateTime(new Date());
                    orderDetl.setStatus(1);
                    orderDetl.setQty(0.0D);

                    //保存erp传过来的字段
                    orderDetl.setManu((orderResult.getOrgNo()));//组织编码
                    orderDetl.setModel(orderResult.getDocSeqNo());//项次--行号
                    orderDetl.setColor(orderResult.getDocWarehouseNo());//任务仓库
                    orderDetl.setBrand(orderResult.getDocCellNo());//任务储位
                    orderDetl.setUnit(orderResult.getUnitNo());//单位编号
                    orderDetl.setSku(orderResult.getUnitName());//单位名称
                    orderDetl.setItemNum(orderResult.getSupplierNo());//供应商编码
                    orderDetl.setOrigin(orderResult.getSupplierName());//供应商名称

                    if (!orderDetlService.insert(orderDetl)) {
                        throw new CoolException("生成单据明细失败，请联系管理员");
                    }
                }
            } else {
            }
        } catch (Exception e) {
            log.error("fail", e);
        } finally {
            try {
                // 保存接口日志
                apiLogService.save(
                        "轮询数据",
                        URL + inaddress,
                        null,
                        "127.0.0.1",
                        map.toString(),
                        response,
                        success
                );
            } catch (Exception e) {
                log.error("", e);
            }
        }
    }

}

 src/main/java/com/zy/asrs/task/ERPReportScheduler.java

New file
@@ -0,0 +1,138 @@
package com.zy.asrs.task;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.result.OrderResult;
import com.zy.asrs.service.*;
import com.zy.common.utils.HttpHandler;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
@Slf4j
public class ERPReportScheduler extends AbstractHandler<String> {

    @Value("${erp.address.URL}")
    private String URL;
    @Value("${erp.address.outaddress}")
    private String outAddress;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private OrderService orderService;
    @Autowired
    private DocTypeService docTypeService;


    /**
     * 单个任务上报erp
     */
    @Scheduled(cron = "0/10 * * * * ? ")
    private void execute() {
        //查找所有任务档任务状态为40ERP上报中的任务
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", 40));

        //是否需要上报ERP
        Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "newErpReport"));
        if(!Cools.isEmpty(config)&&config.getValue().equals("Y")&&!Cools.isEmpty(wrkMasts)){

            for(WrkMast wrkMast:wrkMasts){
                List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
                if(wrkDetls!=null&&wrkDetls.size()>0){
                    List<LinkedHashMap<String,Object>> datas=new ArrayList<>();
                    for(WrkDetl wrkDetl:wrkDetls){
                        OrderDetl orderDetl= orderDetlService.selectItem(wrkDetl.getOrderNo(),wrkDetl.getMatnr(),wrkDetl.getBatch());
                        if(orderDetl==null){
                            log.error("orderNo={}，matnr={}，batch={}，没有查询到订单明细",wrkDetl.getOrderNo(),wrkDetl.getMatnr(),wrkDetl.getBatch());
                            continue;
                        }
                        Order order= orderService.selectByNo(wrkDetl.getOrderNo());
                        if(order==null){
                            log.error("orderNo={}，matnr={}，batch={}，没有查询到订单",wrkDetl.getOrderNo(),wrkDetl.getMatnr(),wrkDetl.getBatch());
                            continue;
                        }
                        DocType docType = docTypeService.selectById(order.getDocType());//单据编号
                        LinkedHashMap<String,Object> map=new LinkedHashMap<>();
                        map.put("orgNo",orderDetl.getManu());//组织编码
                        map.put("docNo",orderDetl.getOrderNo());
                        map.put("docType",docType.getMemo());
                        map.put("docSeqNo",orderDetl.getModel());
                        map.put("itemNo",orderDetl.getMatnr());
                        map.put("qty",wrkDetl.getAnfme());
                        map.put("unitNo",orderDetl.getUnit());
                        map.put("warehouseNo",orderDetl.getColor());
                        map.put("cellNo",orderDetl.getBrand());
                        map.put("combinationLotNo",String.valueOf(orderDetl.getBatch()));
                        map.put("barcode",wrkDetl.getZpallet());
                        datas.add(map);
                    }

                    HashMap<String,Object> map=new HashMap<>();
                    map.put("data",datas);
                    //上报ERP
                    String response = "";
                    boolean success = false;
                    try {
                        response = new HttpHandler.Builder()
                                .setUri(URL)
                                .setPath(outAddress)
                                .setJson(JSON.toJSONString(map))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("status") == 200) {
                            if(wrkMast.getIoType()<100){
                                wrkMast.setWrkSts(10L);//入库转历史档
                            }else{
                                wrkMast.setWrkSts(18L);//出库转历史档
                            }
                        } else {
                            log.error("任务号={}，上报失败",wrkMast.getWrkNo());
                        }
                    } catch (Exception e) {
                        log.error("fail", e);
                    } finally {
                        try {
                            // 保存接口日志
                            apiLogService.save(
                                    "上报任务结果给ERP",
                                    URL + outAddress,
                                    null,
                                    "127.0.0.1",
                                    map.toString(),
                                    response,
                                    success
                            );
                        } catch (Exception e) {
                            log.error("", e);
                        }
                    }
                }else {
                    log.error("任务号：{}，没有任务明细",wrkMast.getWrkNo());
                }
            }
        }

    }
}

 src/main/java/com/zy/asrs/task/handler/OrderSyncHandler.java

@@ -89,7 +89,7 @@
                try {
                    // 保存接口日志
                    apiLogService.save(
                            "成品库入库上报",
                            "入库上报",
                            MesConstant.URL + MesConstant.PAKIN_URL,
                            null,
                            "127.0.0.1",
@@ -143,7 +143,7 @@
                try {
                    // 保存接口日志
                    apiLogService.save(
                            "成品库出库上报",
                            "出库上报",
                            MesConstant.URL + MesConstant.PAKOUT_URL,
                            null,
                            "127.0.0.1",

 src/main/java/com/zy/asrs/task/handler/WorkMastHandler.java

@@ -9,6 +9,8 @@
import com.zy.asrs.service.*;
import com.zy.asrs.task.AbstractHandler;
import com.zy.asrs.task.core.ReturnT;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -36,6 +38,8 @@
    private LocDetlService locDetlService;
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private ConfigService configService;

    public ReturnT<String> start(WrkMast wrkMast) {
        // 9.入库完成
@@ -51,6 +55,9 @@
    private ReturnT<String> doIn(WrkMast wrkMast){
        Date now = new Date();
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());

        //判断任务是否有订单号
        Boolean boo=false;
        try {
            if (null == locMast) {
                exceptionHandle("工作档[workNo={0}]库位号错误[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
@@ -84,8 +91,13 @@
                    if (wrkDetls.isEmpty()) {
                        exceptionHandle("全板入库 ===>> 工作明细档不存在；[workNo={0}]", wrkMast.getWrkNo());
                    }
                    //判断是否有订单号
                    if(!Cools.isEmpty(wrkDetls.get(0).getOrderNo())){
                        boo=true;
                    }
                    // 遍历工作明细，更新库存明细和入库通知档
                    for (WrkDetl wrkDetl : wrkDetls) {

                        wrkDetl.setBatch("");
                        LocDetl locDetl = locDetlService.selectItem(locMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
                        if (null != locDetl) {
@@ -143,6 +155,12 @@
                    if (wrkDetls53.isEmpty()) {
                        exceptionHandle("拣料入库 ===>> 工作明细档为空；[workNo={0}]", wrkMast.getWrkNo());
                    }

                    //判断是否有订单号
                    if(!Cools.isEmpty(wrkDetls53.get(0).getOrderNo())){
                        boo=true;
                    }

                    for (WrkDetl wrkDetl : wrkDetls53) {

                        LocDetl locDetl = locDetlService.selectItem(locMast.getLocNo(), wrkDetl.getMatnr(), wrkDetl.getBatch());
@@ -273,8 +291,15 @@
                default:
                    break;
            }
            // 修改工作主档状态
            wrkMast.setWrkSts(10L);

            //是否需要上报ERP
            Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "newErpReport"));
            if(!Cools.isEmpty(config)&&config.getValue().equals("Y")&&boo){
                wrkMast.setWrkSts(40L);//任务状态转ERP上报中
            }else{
                // 修改工作主档状态
                wrkMast.setWrkSts(10L);
            }
            wrkMast.setModiTime(now);
            if (!wrkMastService.updateById(wrkMast)) {
                exceptionHandle("更新入库完成状态失败;[workNo={0}]", wrkMast.getWrkNo());
@@ -289,8 +314,12 @@
    }

    private ReturnT<String> doOut(WrkMast wrkMast){

        Date now = new Date();
        LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());

        //判断任务是否有订单号
        Boolean boo=false;
        try {
            if (null == locMast) {
                exceptionHandle("工作档[workNo={0}]库位号错误[locNo={1}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
@@ -338,6 +367,11 @@
                    if (wrkDetls101.isEmpty()) {
                        exceptionHandle("全板出库 ===>> 工作明细档为空；[workNo={0}]", wrkMast.getWrkNo());
                    }
                    //判断是否有订单号
                    if(!Cools.isEmpty(wrkDetls101.get(0).getOrderNo())){
                        boo=true;
                    }

                    for (WrkDetl wrkDetl : wrkDetls101) {
                        // todo:luxiaotao 3)修改出库通知档 status ==> Y
                    }
@@ -375,8 +409,14 @@
                    break;
            }
            if(wrkMast.getIoType()!=11) {
                // 修改工作主档状态
                wrkMast.setWrkSts(18L);
                //是否需要上报ERP
                Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "newErpReport"));
                if(!Cools.isEmpty(config)&&config.getValue().equals("Y")&&boo){
                    wrkMast.setWrkSts(40L);//任务状态转ERP上报中
                }else{
                    // 修改工作主档状态
                    wrkMast.setWrkSts(18L);
                }
                wrkMast.setModiTime(now);
                if (!wrkMastService.updateById(wrkMast)) {
                    exceptionHandle("更新出库完成状态失败;[workNo={0}]", wrkMast.getWrkNo());

 src/main/java/com/zy/common/service/CommonService.java

@@ -201,10 +201,10 @@
                }
            }

            if (matNos.size() > 1 && matType == 1) {
                //物料为单品类型，且物料种类超过1(实际为高频混放)，则禁止入库
                throw new CoolException("物料类型和实际种类不一致");
            }
//            if (matNos.size() > 1 && matType == 1) {
//                //物料为单品类型，且物料种类超过1(实际为高频混放)，则禁止入库
//                throw new CoolException("物料类型和实际种类不一致");
//            }
        }

        if (!sign && matType != null) {

 src/main/resources/application.yml

@@ -59,3 +59,13 @@
store:
  bufferCount: 2

#erp对接
erp:
  #地址
  address:
    URL: http://192.168.3.102:16001
    #入库单据
    inaddress: K3CLOUD/Kingdee.BOS.WebApi.ServicesStub.DynamicFormService.ExecuteBillQuery.common.kdsvc
    #结果上报（审核）单地址
    outaddress: K3CLOUD/Kingdee.BOS.WebApi.ServicesStub.DynamicFormService.Audit.common.kdsvc