对接ERP基础接口

skyouc

15 小时以前 ccb810bdcabb3a10b7463acbdb0aa66c44d9c0bc

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReceiveMsgServiceImpl.java

@@ -1,23 +1,20 @@
package com.vincent.rsf.server.api.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.vincent.rsf.common.domain.CommonReponse;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.config.RemotesInfoProperties;
import com.vincent.rsf.server.api.entity.dto.PoItemsDto;
import com.vincent.rsf.server.api.entity.enums.OrderType;
import com.vincent.rsf.server.api.entity.params.ErpInspectItem;
import com.vincent.rsf.server.api.entity.params.ErpInspectParams;
import com.vincent.rsf.server.manager.entity.AsnOrder;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.PurchaseItem;
import com.vincent.rsf.server.manager.service.AsnOrderItemService;
import com.vincent.rsf.server.manager.service.AsnOrderService;
import com.vincent.rsf.server.manager.service.PurchaseItemService;
import com.vincent.rsf.server.manager.service.PurchaseService;
import com.vincent.rsf.server.api.controller.params.BaseMatParms;
import com.vincent.rsf.server.api.controller.params.QueryOrderParam;
import com.vincent.rsf.server.api.controller.params.WkOrderDto;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.OrderType;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.service.impl.MatnrServiceImpl;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.api.controller.params.OrderParams;
import com.vincent.rsf.server.system.entity.Fields;
@@ -25,22 +22,13 @@
import com.vincent.rsf.server.system.service.FieldsService;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import com.vincent.rsf.server.api.service.ReceiveMsgService;
import com.vincent.rsf.server.manager.entity.Purchase;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Ryan
@@ -58,20 +46,32 @@
    @Autowired
    private PurchaseItemService purchaseItemService;
    @Autowired
    private FieldsService fieldsService;
    @Autowired
    private FieldsItemService fieldsItemService;
    @Autowired
    private MatnrGroupService matnrGroupService;
    @Autowired
    private MatnrServiceImpl matnrService;
    @Autowired
    private AsnOrderService asnOrderService;
    @Autowired
    private AsnOrderItemService asnOrderItemService;
    @Autowired
    private RestTemplate restTemplate;
    private DeliveryService deliveryService;
    @Autowired
    private RemotesInfoProperties remotesInfoProperties;
    private DeliveryItemService deliveryItemService;
    @Autowired
    private RemotesInfoProperties.ApiInfo apiInfo;
    private LocService locService;
    @Autowired
    private FieldsService fieldsService;
    @Autowired
    private FieldsItemService fieldsItemService;
    private LocItemService locItemService;

    /**
     * @author Ryan
     * @date 2025/8/15
     * @description: 保存PO/DO单据
     * @version 1.0
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean syncPurchasee(List<OrderParams> orders) {
@@ -79,35 +79,69 @@
            throw new CoolException("单据内容不能为空！！");
        }
        orders.forEach(ors -> {
            Purchase purchase = new Purchase();
            BeanUtils.copyProperties(ors, purchase);
            String wkVal = SerialRuleUtils.generateRuleCode(SerialRuleCode.PURCHASE_CODE, purchase);
            purchase.setCode(wkVal)
                    .setType(OrderType.ORDER_PURCHASE_IN.type);
            if (!purchaseService.save(purchase)) {
                throw new CoolException("采购单据保存失败");
            }
            if (ors.getType().equals("po")) {
                Purchase purchase = new Purchase();
                BeanUtils.copyProperties(ors, purchase);
                String wkVal = SerialRuleUtils.generateRuleCode(SerialRuleCode.PURCHASE_CODE, purchase);
                purchase.setCode(wkVal)
                        .setType(OrderType.ORDER_IN.type);
                if (!purchaseService.save(purchase)) {
                    throw new CoolException("采购单据保存失败");
                }

            //查询扩展字段是否存在
            List<Fields> fields = fieldsService.list(new LambdaQueryWrapper<Fields>().eq(Fields::getStatus, 1).eq(Fields::getFlagEnable, 1));
                //查询扩展字段是否存在
                List<Fields> fields = fieldsService.list(new LambdaQueryWrapper<Fields>().eq(Fields::getStatus, 1).eq(Fields::getFlagEnable, 1));

            //判断子列表不为空
            if (!ors.getChildren().isEmpty()) {
                ArrayList<PurchaseItem> list = new ArrayList<>();
                ors.getChildren().forEach(orderItem -> {
                    PurchaseItem item = new PurchaseItem();
                    BeanUtils.copyProperties(orderItem, item);
                //判断子列表不为空
                if (!ors.getChildren().isEmpty()) {
                    ArrayList<PurchaseItem> list = new ArrayList<>();
                    ors.getChildren().forEach(orderItem -> {
                        PurchaseItem item = new PurchaseItem();
                        BeanUtils.copyProperties(orderItem, item);
//                    if (!fields.isEmpty()) {
//                        List<String> fieldValue = fields.stream().map(Fields::getFields).collect(Collectors.toList());
//                        fieldValue.forEach(value -> {
//
//                        });
//                    }
                    item.setPurchaseId(purchase.getId());
                    list.add(item);
                });
                if (!purchaseItemService.saveBatch(list)) {
                    throw new CoolException("采购单明细保存失败！！");
                        item.setPurchaseId(purchase.getId());
                        list.add(item);
                    });
                    if (!purchaseItemService.saveBatch(list)) {
                        throw new CoolException("采购单明细保存失败！！");
                    }
                }
            } else {
                Delivery delivery = new Delivery();
                BeanUtils.copyProperties(ors, delivery);
                String wkVal = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_DELIVERY_RULE_CODE, delivery);
                delivery.setCode(wkVal)
                        .setType(OrderType.ORDER_OUT.type);
                if (!deliveryService.save(delivery)) {
                    throw new CoolException("采购单据保存失败");
                }

                //查询扩展字段是否存在
                List<Fields> fields = fieldsService.list(new LambdaQueryWrapper<Fields>().eq(Fields::getStatus, 1).eq(Fields::getFlagEnable, 1));

                //判断子列表不为空
                if (!ors.getChildren().isEmpty()) {
                    ArrayList<DeliveryItem> list = new ArrayList<>();
                    ors.getChildren().forEach(orderItem -> {
                        DeliveryItem item = new DeliveryItem();
                        BeanUtils.copyProperties(orderItem, item);
//                    if (!fields.isEmpty()) {
//                        List<String> fieldValue = fields.stream().map(Fields::getFields).collect(Collectors.toList());
//                        fieldValue.forEach(value -> {
//
//                        });
//                    }
                        item.setDeliveryId(delivery.getId());
                        list.add(item);
                    });
                    if (!deliveryItemService.saveBatch(list)) {
                        throw new CoolException("采购单明细保存失败！！");
                    }
                }
            }
        });
@@ -116,105 +150,72 @@
    }

    /**
     * @author Ryan
     * @description 上报质检列表
     * @params [items 列表]
     * @return boolean
     * @time 2025/3/7 09:12
     * 物料信息同步
     *
     * @param matnrs
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean reportInspectNotify(List<PoItemsDto> items) {
        if (items.isEmpty()) {
            throw new CoolException("上报内容为空！！");
        }
        List<ErpInspectParams> inspectParams =  new ArrayList<>();
        Map<String, List<PoItemsDto>> listMap = items.stream().collect(Collectors.groupingBy(PoItemsDto::getPurchaseId));
        listMap.keySet().forEach(key -> {
            Purchase purchase = purchaseService.getOne(new LambdaQueryWrapper<Purchase>().eq(Purchase::getId, Long.valueOf(key)));
            if (Objects.isNull(purchase)) {
                throw new CoolException("采购单信息有误！！");
            }
            ErpInspectParams params = new ErpInspectParams();
            List<ErpInspectItem> inspectItems = new ArrayList<>();
            //赋值erp主单编码,编号
            params.setPoId(purchase.getPlatId())
                    .setPoCode(purchase.getPlatCode());
            List<PoItemsDto> dtos = listMap.get(key);
            if (dtos.isEmpty()) {
                throw new CoolException("单据信息错误！！");
            }
            dtos.forEach(dto -> {
                ErpInspectItem inspect= new ErpInspectItem();
                BeanUtils.copyProperties(dto, inspect);
                //赋值erp明细编码
                inspect.setPoItemId(dto.getPlatItemId());
                inspectItems.add(inspect);
            });
            params.setChildren(inspectItems);
            inspectParams.add(params);

        });

        MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
        //获取上报质检接口
        String url = remotesInfoProperties.getBaseUrl() + apiInfo.getNotifyInspect();
        // 设置请求参数
        params.add("params", JSONObject.toJSONString(inspectParams));
        log.info("请求地址：{}，请求参数：{}", url, JSONObject.toJSONString(inspectParams));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
        HttpEntity httpEntity = new HttpEntity<>(params, headers);
        // 请求
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
        log.info("下发任务 返回结果：{}", exchange);
        if (Objects.isNull(exchange.getBody()) || exchange.getBody() == null) {
            throw new CoolException("下发任务失败！！");
        } else {
            CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());
            if (reponse.getCode() == 0) {
                //修改asn上报状态
                Set<String> itemSets = items.stream().map(PoItemsDto::getId).collect(Collectors.toSet());
                Set<Long> longSet = new HashSet<>();
                itemSets.forEach(set -> {
                    longSet.add(Long.parseLong(set));
                });

                List<AsnOrderItem> asnOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getPoDetlId, longSet));
                if (asnOrderItems.isEmpty()) {
                    throw new CoolException("ASN单据不存在！！");
    public void syncMatnrs(List<BaseMatParms> matnrs) {
        List<Matnr> syncMatnrs = new ArrayList<>();
        if (!matnrs.isEmpty()) {
            matnrs.forEach(matnr -> {
                Matnr mat = new Matnr();
                if (Objects.isNull(matnr.getMatnr())) {
                    throw new RuntimeException("物料编码不能为空！！");
                }
                List<Long> list = asnOrderItems.stream().map(AsnOrderItem::getId).collect(Collectors.toList());

                /**************************     修改ASN明细单状态         ******************************/


                if (!asnOrderItemService.update(new LambdaUpdateWrapper<AsnOrderItem>().in(AsnOrderItem::getId, list).set(AsnOrderItem::getStatus, 1))) {
                    throw new CoolException("ASN明细单据状态修改失败！！");
                }

                /**************************     修改ASN主单数据         ******************************/
                //获取ASN明细订单标识
                List<Long> ids = asnOrderItems.stream().map(AsnOrderItem::getAsnId).collect(Collectors.toList());
                //ASN明细单据分组
                Map<Long, List<AsnOrderItem>> asnIds = asnOrderItems.stream().collect(Collectors.groupingBy(AsnOrderItem::getAsnId));
                ids.forEach(id -> {
                    int count = asnOrderService.count(new LambdaQueryWrapper<AsnOrder>().in(AsnOrder::getId, id));
                    if (count == asnIds.get(id).size()) {
                        if (!asnOrderService.update(new LambdaUpdateWrapper<AsnOrder>().eq(AsnOrder::getId, id).set(AsnOrder::getStatus, 1))) {
                            throw new CoolException("ASN主单状态修改失败！！");
                        }
                    } else {
                        if (!asnOrderService.update(new LambdaUpdateWrapper<AsnOrder>().eq(AsnOrder::getId, id).set(AsnOrder::getStatus, 2))) {
                            throw new CoolException("ASN主单状态修改失败！！");
                        }
                BeanUtils.copyProperties(matnr, mat);
                mat.setCode(matnr.getMatnr()).setName(matnr.getMaktx());
                if (!Objects.isNull(matnr.getGroupName())) {
                    MatnrGroup matnrGroup = matnrGroupService.getOne(new LambdaQueryWrapper<MatnrGroup>().eq(MatnrGroup::getName, matnr.getGroupName()), false);
                    if (Objects.isNull(matnrGroup)) {
                        mat.setGroupCode(matnrGroup.getCode()).setGroupId(matnrGroup.getId());
                    }
                });
                return true;
            } else {
                throw new CoolException(reponse.getMsg());
                }
                syncMatnrs.add(mat);
            });

            if (!matnrService.saveOrUpdateBatch(syncMatnrs)) {
                throw new CoolException("物料信息保存成功！！");
            }
        }
    }

    /**
     * @author Ryan
     * @date 2025/8/15
     * @description: 订单查询
     * @version 1.0
     */
    @Override
    public R queryOrderStatus(QueryOrderParam queryParams) {
        WkOrder wkOrders = asnOrderService.getOne(new LambdaQueryWrapper<WkOrder>()
                .eq(WkOrder::getCode, queryParams.getOrderNo())
                .eq(WkOrder::getType, queryParams.getType()));
        if (Objects.isNull(wkOrders)) {
            throw new CoolException("单据不存在！！");
        }
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, wkOrders.getId()));

        WkOrderDto wkorderDto = new WkOrderDto();
        wkorderDto.setOrder(wkOrders).setOrderItems(orderItems);

        return R.ok().add(wkorderDto);
    }

    /**
     * @author Ryan
     * @date 2025/8/15
     * @description: 同步库位信息
     * @version 1.0
     */
    @Override
    public R syncLocsDetl(PageParam<Loc, BaseParam> pageParam, QueryWrapper<Loc> wrapper) {
        Page<Object> page = new Page<>();
        page.setCurrent(pageParam.getCurrent()).setSize(pageParam.getSize());


        return null;
    }


}