wms / hhwms · Files

package com.huaheng.pc.srm.service;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.api.srm.domain.*;

import com.huaheng.common.constant.QuantityConstant;

import com.huaheng.common.exception.RunFailException;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.Wrappers;
import com.huaheng.common.utils.http.HttpUtils;

import com.huaheng.common.utils.http.OkHttpUtils;

import com.huaheng.framework.aspectj.ApiLogAspect;

import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.address.domain.Address;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.company.domain.CompanyU8;
import com.huaheng.pc.config.company.service.CompanyU8Service;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.supplier.service.SupplierService;

import com.huaheng.pc.config.warehouse.domain.WarehouseU8;

import com.huaheng.pc.monitor.apilog.domain.ApiLog;

import com.huaheng.pc.srm.domain.*;
import com.huaheng.pc.srm.mapper.ICSASNDetailMapper;
import com.huaheng.pc.srm.mapper.ICSASNMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.http.HttpHeaders;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;

import java.util.stream.Collectors;

@Service
public class ICSASNService extends ServiceImpl<ICSASNMapper, ICSASN> {

    private static final Logger logger = LoggerFactory.getLogger(ICSASNService.class);

    @Resource
    private ICSASNService icsasnService;
    @Resource
    private ICSASNDetailService icsasnDetailService;
    @Resource
    RunFailException runFailException;
    @Resource
    SupplierService supplierService;
    @Resource
    private MaterialService materialService;
    @Resource
    private SrmHeaderService srmHeaderService;
    @Resource
    private SrmDetailService srmDetailService;
    @Resource
    private ICSITEMLotService icsitemLotService;
    @Resource
    private AddressService addressService;
    @Resource
    private CompanyU8Service companyU8Service;


    public List<ICSASN> selectListEntity(ICSASN icsasn) {
        LambdaQueryWrapper<ICSASN> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(StringUtils.isNotEmpty(icsasn.getSTNO()),ICSASN::getSTNO,icsasn.getSTNO());

        queryWrapper.eq(StringUtils.isNotEmpty(icsasn.getWarehouseCode()),ICSASN::getWarehouseCode,icsasn.getWarehouseCode());

        return this.list(queryWrapper);
    }

    public List<ICSASN> selectBySTNO(List<String> STNOS) {
        if(STNOS!=null&&STNOS.size()>0){
            String[] split=STNOS.toArray(new String[0]);
            LambdaQueryWrapper<ICSASN> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.in(ICSASN::getSTNO,split);
            return this.list(queryWrapper);
        }
        return null;
    }

    public boolean update(ICSASN icsasn) {
        return this.update(icsasn);
    }

    /**
     *  接收送货单信息
     *
     * @param icsOrder
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public SRMResult saveASNAndDetail(ICSOrder icsOrder) {
        SRMResult srmResult = new SRMResult();
        ICSASN icsasn = icsOrder.getIcsasn();

        //1、判断货主(账套号)

        if(StringUtils.isEmpty((icsasn.getCompanyCode()))){
            return srmResult.error("账套号为空");
        }

        if(StringUtils.isEmpty((icsasn.getWarehouseCode()))){
            return srmResult.error("仓库code为空");
        }

        CompanyU8 companyWu = companyU8Service.getOne(new LambdaQueryWrapper<CompanyU8>()
                .eq(CompanyU8::getWarehouseCode,icsasn.getWarehouseCode())
                .like(CompanyU8::getUCompanyCode,icsasn.getCompanyCode())
                .last("order by id asc limit 1")
        );

        if(companyWu == null){
            return srmResult.error(icsasn.getCompanyCode() +"账套号不存在");
        }

        //2、判断供应商是否存在
        String supplierName = supplierService.getSuppierNameByCode(icsasn.getVENDORCODE(),icsasn.getWarehouseCode());

        if(supplierName == null){
            runFailException.sendException("头表ID为：" + icsasn.getID()+"的送货单供应商在wms不存在");
            return srmResult.error("头表ID为：" + icsasn.getID()+"的送货单供应商在wms不存在");
        }

        //3、操作头表icsasn和srmHeader

        Integer headerId = null;
        ICSASN queryHeaderEntry = new ICSASN();
        queryHeaderEntry.setSTNO(icsasn.getSTNO());

        queryHeaderEntry.setWarehouseCode(icsasn.getWarehouseCode());

        if (this.selectListEntity(queryHeaderEntry).size() > 0) {

            //①判断送货单头表是否存在，已存在，则更新

            if (!this.updateById(icsasn)) {

                runFailException.sendException("更新送货单头表失败，头表ID为：" + icsasn.getID());
                return srmResult.error("更新送货单头表失败，头表ID为：" + icsasn.getID());
            }
            SrmHeader srmHeader = new SrmHeader();
            srmHeader.setCode(icsasn.getSTNO());

            srmHeader.setWarehouseCode(icsasn.getWarehouseCode());

            srmHeader = srmHeaderService.selectFirstModel(srmHeader);
            SrmHeader model = this.getSrmHeader(icsasn);
            model.setId(srmHeader.getId());
            srmHeaderService.updateById(model);
            headerId = srmHeader.getId();
        } else {

            //②判断送货单头表是否存在，不存在，则插入

            if (!this.save(icsasn)) {

                runFailException.sendException("插入送货单头表失败，头表ID为：" + icsasn.getID());
                return srmResult.error("插入送货单头表失败，头表ID为：" + icsasn.getID());
            }
            SrmHeader model = this.getSrmHeader(icsasn);
            srmHeaderService.save(model);
            SrmHeader srmHeader = new SrmHeader();
            srmHeader.setCode(model.getCode());
            srmHeader = srmHeaderService.selectFirstModel(srmHeader);
            headerId = srmHeader.getId();
        }

        //3、操作明细表icsasndetail和srmDetail

        if (icsOrder.getIcsasnDetailList().size() > 0) {

            //①icsasnDetail添加物料信息

            for (ICSASNDetail icsasnDetail : icsOrder.getIcsasnDetailList()) {

                //查询SRM有没有推送物料条码

                ICSITEMLot queryIcsitemLot = new ICSITEMLot();
                queryIcsitemLot.setLotNO(icsasnDetail.getLOTNO());

                queryIcsitemLot.setWarehouseCode(icsasn.getWarehouseCode());

                ICSITEMLot icsitemLot = icsitemLotService.selectFirstModel(queryIcsitemLot);
                if(icsitemLot == null){
                    runFailException.sendException("ID为："+icsasnDetail.getID()+"的物料条码没有同步到wms");
                    return srmResult.error("ID为："+icsasnDetail.getID()+"的物料条码没有同步到wms");
                }

                Material material = materialService.getMaterialByCode(icsitemLot.getItemCode(),icsasn.getWarehouseCode());

                if(material == null){
                    runFailException.sendException("ID为："+icsasnDetail.getID()+"的物料条码在wms不存在");
                    return srmResult.error("ID为："+icsasnDetail.getID()+"的物料条码在wms不存在");
                }
                icsasnDetail.setMaterialCode(material.getCode());
                icsasnDetail.setMaterialName(material.getName());
                icsasnDetail.setSpec(material.getSpec() );

                icsasnDetail.setWarehouseCode(material.getWarehouseCode());

            }

            //②查询送货单号STNO是否存在明细

            ICSASNDetail queryDetailEntry = new ICSASNDetail();
            queryDetailEntry.setSTNO(icsasn.getSTNO());

            queryDetailEntry.setWarehouseCode(icsasn.getWarehouseCode());

            List<ICSASNDetail> icsasnDetailList = icsasnDetailService.selectListEntity(queryDetailEntry);
            if (icsasnDetailList.size() > 0) {

                //③送货单号STNO已存在的明细进行更新

                for (ICSASNDetail icsasnDetail : icsOrder.getIcsasnDetailList()) {
                    queryDetailEntry.setID(icsasnDetail.getID());

                    queryDetailEntry.setWarehouseCode(icsasnDetail.getWarehouseCode());

                    if (icsasnDetailService.selectListEntity(queryDetailEntry).size() > 0) {

                        if (!icsasnDetailService.updateById(icsasnDetail)) {

                            runFailException.sendException("更新送货单明细失败，头表ID为：" + icsasnDetail.getID());
                            return srmResult.error("更新送货单明细失败，头表ID为：" + icsasnDetail.getID());
                        }
                        SrmDetail srmDetail = new SrmDetail();
                        srmDetail.setMark(icsasnDetail.getID());

                        srmDetail.setWarehouseCode(icsasnDetail.getWarehouseCode());

                        srmDetail = srmDetailService.selectFirstModel(srmDetail);
                        SrmDetail model = this.getSrmDetail(icsasnDetail,srmDetail.getHeaderId(),companyWu);
                        model.setId(srmDetail.getId());
                        srmDetailService.updateById(model);
                    } else {

                        if (!icsasnDetailService.save(icsasnDetail) ) {

                            runFailException.sendException("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                            return srmResult.error("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                        }
                        SrmDetail srmDetail = this.getSrmDetail(icsasnDetail,headerId,companyWu);
                        srmDetailService.save(srmDetail);
                    }
                }
            } else {

                //④送货单号STNO不存在的明细进行新增

                for (ICSASNDetail icsasnDetail : icsOrder.getIcsasnDetailList()) {
                    if(icsasnDetail.getSTNO().equals(icsasn.getSTNO())) {

                        if (!icsasnDetailService.save(icsasnDetail) ) {

                            runFailException.sendException("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                            return srmResult.error("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                        }
                        SrmDetail srmDetail = this.getSrmDetail(icsasnDetail, headerId,companyWu);
                        srmDetailService.save(srmDetail);
                    }
                }
            }
        }

        return srmResult.success("送货单列表推送成功");
    }


    public SrmHeader getSrmHeader(ICSASN icsasn){
        SrmHeader srmHeader = new SrmHeader();
        srmHeader.setCode(icsasn.getSTNO());
        srmHeader.setMark(icsasn.getID());
        srmHeader.setSupplierCode(icsasn.getVENDORCODE());
        srmHeader.setOperator(icsasn.getMUSERName());
        srmHeader.setOperatorTime(icsasn.getMTIME());
        srmHeader.setCreated(new Date());

        srmHeader.setWarehouseCode(icsasn.getWarehouseCode());

        return srmHeader;

    }

    public SrmDetail getSrmDetail(ICSASNDetail icsasnDetail,Integer headerId,CompanyU8 companyWu) {
        SrmDetail srmDetail = new SrmDetail();
        srmDetail.setHeaderId(headerId);
        srmDetail.setCode(icsasnDetail.getSTNO());
        srmDetail.setCompanyCode(companyWu.getUCompanyCode());
        srmDetail.setMark(icsasnDetail.getID());
        srmDetail.setLineCode(icsasnDetail.getLOTNO());
        srmDetail.setMaterialCode(icsasnDetail.getMaterialCode());
        srmDetail.setMaterialName(icsasnDetail.getMaterialName());
        srmDetail.setSpecification(icsasnDetail.getSpec());
        srmDetail.setQty(icsasnDetail.getPLANQTY());
        srmDetail.setConfirmQty(icsasnDetail.getRECEIVEQTY());
        srmDetail.setOperator(icsasnDetail.getMUSERName());
        srmDetail.setOperatorTime(icsasnDetail.getMTIME());
        srmDetail.setCreated(new Date());

        srmDetail.setWarehouseCode(icsasnDetail.getWarehouseCode());

        srmDetail.setProductionBatch(icsasnDetail.getCdefine22());
        srmDetail.setBatchNumberContent(icsasnDetail.getCdefine23());

        return srmDetail;
    }



    public Address getSRMAddress(){
        Address address = new Address();
        address.setParam("SRM");
        address.setWarehouseCode("KS0001");
        address=addressService.selectEntity(address);
        return address;
    }


    @Transactional

    public SRMResult sendReturn(String url,String json,String warehouseCode){

        if(StringUtils.isEmpty(warehouseCode)){
            warehouseCode="CS0001";
        }

        SRMResult ajaxResult = new SRMResult().error("");
        String msg = "";
        ApiLog log = null;
        HttpHeaders headers = new HttpHeaders();
        try{
            log = ApiLogAspect.initApiLog("post", url,
                    json, headers, warehouseCode);

            String result = OkHttpUtils.bodypost(url, json,warehouseCode);

            if(StringUtils.isEmpty(result)){
                throw new ServiceException("接口地址错误或服务器连接不到或返回为空");
            }
            ajaxResult = JSON.parseObject(result, SRMResult.class);
        }catch (Exception e){
            e.printStackTrace();
            ApiLogAspect.setApiLogException(log, e);
        }finally {
            ApiLogAspect.finishApiLog(log, headers, msg);

        }

        return ajaxResult;

    }


    //采购到货单返回

    public AjaxResult returnICSPOArrive(List<ICSPOArrive> icspoArrives,String warehouseCode) {

        String json = JSON.toJSONString(icspoArrives);
        logger.info("WMS送货单确认回传：{}",json);
       Address address = this.getSRMAddress();
       if(address == null){
           return AjaxResult.error("未配置SRM API地址");
       }
       String url = address.getUrl() +"POArrive";
       String JsonParam = JSON.toJSONString(icspoArrives);

        SRMResult srmResult = this.sendReturn(url,JsonParam,warehouseCode);
        logger.info("SRM送货单返回信息：{}",srmResult);
        if(!srmResult.hasError()){

            return AjaxResult.success(srmResult.getData());
        }else {
            logger.info("SRM采购到货单回传：{}",srmResult.getMessage());
            return AjaxResult.error(srmResult.getMessage());
        }
    }

    //质检返回

    public AjaxResult returnICSinspection(List<ICSinspection> icSinspections,String warehouseCode) {

        String json = JSON.toJSONString(icSinspections);
        logger.info("WMS质检信息回传：{}",json);
        Address address = this.getSRMAddress();
        if(address == null){
            return AjaxResult.error("未配置SRM API地址");
        }

        String url = address.getUrl() +"POTest";

        String JsonParam = JSON.toJSONString(icSinspections);

        SRMResult srmResult = this.sendReturn(url,JsonParam,warehouseCode);
        if(!srmResult.hasError()){

            return AjaxResult.success("成功");
        }else {
            logger.info("SRM质检返回信息：{}",srmResult.getMessage());
            return AjaxResult.error(srmResult.getMessage());
        }
    }


    //入库返回

    public AjaxResult returnICSRuternASN(List<ICSRuternASN> icsRuternASNs,String warehouseCode) {

        String json = JSON.toJSONString(icsRuternASNs);
        logger.info("WMS入库回传：{}",json);
        Address address = this.getSRMAddress();
        if(address == null){
            return AjaxResult.error("未配置SRM API地址");
        }

        String url = address.getUrl() +"WareHouseLotInfo";
        String JsonParam = JSON.toJSONString(icsRuternASNs);

        SRMResult srmResult = this.sendReturn(url,JsonParam,warehouseCode);
        if(!srmResult.hasError()){

            return AjaxResult.success("成功");
        }else {
            logger.info("SRM入库返回信息：{}",srmResult.getMessage());
            return AjaxResult.error(srmResult.getMessage());
        }
    }

    @Transactional
    public AjaxResult delASNAndDetail(List<ICSASN> list) {
        SRMResult srmResult = new SRMResult();
        if (list.isEmpty()){
            return AjaxResult.error("请勿提交空数据！");
        }

        List<String> STNOS = list.stream().map(ICSASN::getSTNO).collect(Collectors.toList());
        if (STNOS.size() == 0){
            return AjaxResult.error("送货单号不能为空值！");
        }

        List<String> warehouseCodes = list.stream().map(ICSASN::getWarehouseCode).collect(Collectors.toList());
        if (warehouseCodes.size() == 0){
            return AjaxResult.error("仓库code不能为空值！");
        }

        // 查询送货单头表
        List<ICSASN> icsasnList = selectBySTNO(STNOS);
        // 差未到送货单头表
        List<SrmHeader> srmHeaderList = srmHeaderService.selectBySTNO(STNOS);
        if (srmHeaderList.size() == 0 || icsasnList.size() == 0){
            return AjaxResult.success("未查询到送货单信息，请检查送货单号是否正确！");
        }
        for (SrmHeader header : srmHeaderList){
            // 不是未到货单不允许删除
            if (!QuantityConstant.NO_THE_ARRIVAL.equals(header.getEnable())){
                return AjaxResult.error("送货单号:"+ header.getCode()+ "单据已执行不允许删除！");
            }
        }
        // 查询送货单详情表
        List<ICSASNDetail> icsasnDetailList = icsasnDetailService.selectBySTNO(STNOS);
        List<SrmDetail> srmDetailList = srmDetailService.selectBySTNO(STNOS);
        if (icsasnList.size() == srmHeaderList.size() && icsasnDetailList.size() == srmDetailList.size()){
            try {
                this.removeByIds(icsasnList.stream().map(ICSASN::getID).collect(Collectors.toList()));
                icsasnDetailService.removeByIds(icsasnDetailList.stream().map(ICSASNDetail::getID).collect(Collectors.toList()));
                srmHeaderService.removeByIds(srmHeaderList.stream().map(SrmHeader::getId).collect(Collectors.toList()));
                srmDetailService.removeByIds(srmDetailList.stream().map(SrmDetail::getId).collect(Collectors.toList()));
            }catch (Exception e){
                // 删除失败事务回滚
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return AjaxResult.error("系统异常:"+e.getMessage());
            }

        }else {
            return AjaxResult.error("送货单数据条目不匹配，请检查数据是否正常！");
        }

        return AjaxResult.success("送货单删除成功！");
    }

}