wms / wms_tianjinggelinmei · Files

package com.huaheng.api.general.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.huaheng.common.utils.Wrappers;

import com.huaheng.api.general.domain.Receipt;

import com.huaheng.api.general.domain.ReceiptDomain;

import com.huaheng.common.constant.QuantityConstant;

import com.huaheng.common.exception.service.ServiceException;

import com.huaheng.common.utils.DataUtils;

import com.huaheng.common.utils.StringUtils;

import com.huaheng.common.utils.security.ShiroUtils;

import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.pc.config.FilterConfigDetail.domain.FilterConfigDetail;
import com.huaheng.pc.config.FilterConfigDetail.service.FilterConfigDetailService;
import com.huaheng.pc.config.company.domain.Company;
import com.huaheng.pc.config.company.service.CompanyService;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.receiptType.domain.ReceiptType;
import com.huaheng.pc.config.receiptType.service.ReceiptTypeService;
import com.huaheng.pc.config.statusFlow.domain.StatusFlowHeader;
import com.huaheng.pc.config.statusFlow.service.StatusFlowHeaderService;
import com.huaheng.pc.config.supplier.domain.Supplier;
import com.huaheng.pc.config.supplier.service.SupplierService;
import com.huaheng.pc.config.warehouse.domain.Warehouse;
import com.huaheng.pc.config.warehouse.service.WarehouseService;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;

import com.huaheng.pc.receipt.receiptDetailHistory.domain.ReceiptDetailHistory;
import com.huaheng.pc.receipt.receiptDetailHistory.service.ReceiptDetailHistoryService;

import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;

import com.huaheng.pc.receipt.receiptHeaderHistory.domain.ReceiptHeaderHistory;
import com.huaheng.pc.receipt.receiptHeaderHistory.service.ReceiptHeaderHistoryService;

import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;

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

import javax.annotation.Resource;
import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.List;

import java.util.stream.Collectors;

@Component
@Transactional
public class ReceiptApiService {

    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptTypeService receiptTypeService;
    @Resource
    private WarehouseService warehouseService;
    @Resource
    private CompanyService companyService;
    @Resource
    private MaterialService materialService;
    @Resource
    private SupplierService supplierService;
    @Resource
    private FilterConfigDetailService filterConfigDetailService;
    @Resource
    private StatusFlowHeaderService statusFlowHeaderService;

    @Resource
    private ReceiptHeaderHistoryService receiptHeaderHistoryService;
    @Resource
    private ReceiptDetailHistoryService receiptDetailHistoryService;

    /**
     * 入库单下发

     *

     * @param receipt 入库单
     * @return 是否下发成功
     */
    @Transactional(rollbackFor = Exception.class)

    public AjaxResult receipt(ReceiptDomain receipt) {

        /* 0.step 获取入库头表，获取入库明细*/
        ReceiptHeader receiptHeader = receipt.getReceiptHeader();
        List<ReceiptDetail> receiptDetails = receipt.getReceiptDetails();
        /* 1.step 校验入库单是否为空*/

        if (receiptHeader == null || receiptDetails == null) {
            return AjaxResult.error("入库主单或入库子单为空");
        }
        if(receiptDetails.isEmpty()) {
            return AjaxResult.error("入库子单为空");

        }

        /* 4.step 计算入库明细总行数、总数量*/
        BigDecimal totalQty = new BigDecimal(0);

        for (ReceiptDetail receiptDetail : receiptDetails) {

//            totalQty = totalQty.add(receiptDetail.getTotalQty());

            totalQty = totalQty.add(receiptDetail.getUnitId1Qty());

        }
        receiptHeader.setTotalLines(receiptDetails.size());
        receiptHeader.setTotalQty(totalQty);

        List<ReceiptHeader> list = receiptHeaderService.list(new LambdaQueryWrapper<ReceiptHeader>().eq(ReceiptHeader::getReferCode,receiptHeader.getReferCode()));

        //如果有重复getReferCode的单据的话

        if(list.size()>0){
            try {
                for (ReceiptHeader header : list) {

                    if (header.getFirstStatus()<=QuantityConstant.RECEIPT_HEADER_RECEIVING) {

                        header.setReferCode(receiptHeader.getReferCode());
                        header.setReferId(receiptHeader.getReferId());
                        header.setReceiptType(receiptHeader.getReceiptType());
                        header.setSupplierCode(receiptHeader.getSupplierCode());
                        receiptHeaderService.updateById(header);
                        LambdaQueryWrapper<ReceiptDetail> ReceiptDetailLQM = new LambdaQueryWrapper<ReceiptDetail>().eq(ReceiptDetail::getReceiptId, header.getId());
                        receiptDetailService.remove(ReceiptDetailLQM);
                        receiptHeader = receiptHeaderService.getById(header);
                    }else {
                        return AjaxResult.error("入库单已被使用，不能覆盖了");

                    }
                }
            } catch (Exception e) {
                return AjaxResult.error(e.getMessage());
            }
        }else{

            //没有就创建入库单

            try {
                String receiptCode = receiptHeaderService.createCode(receiptHeader.getReceiptType());
                receiptHeader.setCode(receiptCode);
                receiptHeader.setCreatedBy(QuantityConstant.PLATFORM_ERP);
                if(receiptHeader.getCreatedBy()!=null){
                    receiptHeader.setCreatedBy(receiptHeader.getCreatedBy());
                }
                receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING);
                receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING);
                /* 2.step 检查入库头表合法性*/
                AjaxResult checkReceiptHeaderResult = checkReceiptHeader(receiptHeader);
                if (checkReceiptHeaderResult.hasErr()) {
                    return AjaxResult.error(checkReceiptHeaderResult.getMsg());
                }
                /* 3.step 检查入库明细合法性*/
                AjaxResult checkReceiptDetailResult = checkReceiptDetail(receiptDetails);
                if (checkReceiptDetailResult.hasErr()) {
                    return AjaxResult.error(checkReceiptDetailResult.getMsg());
                }
                receiptHeaderService.save(receiptHeader);
            } catch (Exception e) {
                return AjaxResult.error(e.getMessage());
            }
        }

        /* 6.step 保存入库明细*/

        receiptHeader = receiptHeaderService.getOne(new LambdaQueryWrapper<ReceiptHeader>()
                .eq(ReceiptHeader::getWarehouseCode, receiptHeader.getWarehouseCode())
                .eq(ReceiptHeader::getCode, receiptHeader.getCode()));

        Supplier supplier=null;

        if ("CGRKD".equals(receiptHeader.getReceiptType())){

            List<Supplier> list1 = supplierService.list(new LambdaQueryWrapper<Supplier>().eq(Supplier::getCode, receiptHeader.getSupplierCode()));

            if (list1.size()<1) {
                return AjaxResult.error("WMS没有此供应商"+receiptHeader.getSupplierCode()+"，请找ERP同步供应商信息");

            }
            supplier = list1.get(0);

        }

        List<ReceiptDetail> receiptDetailList = new ArrayList<>();

        for (ReceiptDetail receiptDetail : receiptDetails) {
            receiptDetail.setReceiptId(receiptHeader.getId());
            receiptDetail.setReceiptCode(receiptHeader.getCode());
            receiptDetail.setWarehouseCode(receiptHeader.getWarehouseCode());

            receiptDetail.setCompanyCode(receiptHeader.getCompanyCode());

            receiptDetail.setSupplierCode(receiptHeader.getSupplierCode());

            Material material = materialService.findAllByCode(receiptDetail.getMaterialCode(), receiptHeader.getWarehouseCode());

            if(material==null){

                return AjaxResult.error("找不到物料编码："+receiptDetail.getMaterialCode());

            }

            //添加 电池类型判断
//            if("1".equals(material.getIsBattery())){
                String spec = material.getSpec();
                if(spec.contains("三元")){
                    receiptDetail.setBatteryModel("三元");
                }else if(spec.contains("磷酸铁锂")){
                    receiptDetail.setBatteryModel("磷酸铁锂");
                }else if(spec.contains("锰酸锂")){
                    receiptDetail.setBatteryModel("锰酸锂");
                }else if(spec.contains("镍氢")){
                    receiptDetail.setBatteryModel("镍氢");
                }else if(spec.contains("钴酸锂")){
                    receiptDetail.setBatteryModel("钴酸锂");
                }else if(spec.contains("超级电容器")){
                    receiptDetail.setBatteryModel("超级电容器");
                }else{
                    receiptDetail.setBatteryModel("其他");
                }
//            }

            receiptDetail.setInventorySts("good");

            receiptDetail.setOrderNo(receiptDetail.getOrderNo());
            receiptDetail.setTotalQty(receiptDetail.getUnitId1Qty());

            receiptDetail.setUnitId1Qty(receiptDetail.getUnitId1Qty());
            receiptDetail.setUnitId2Qty(receiptDetail.getUnitId2Qty());
            receiptDetail.setMultiple(receiptDetail.getMultiple());
            receiptDetail.setUnitId1(receiptDetail.getUnitId1());
            receiptDetail.setUnitId2(receiptDetail.getUnitId2());

            receiptDetail.setMaterialName(material.getName());
            receiptDetail.setMaterialSpec(material.getSpec());
            receiptDetail.setMaterialUnit(material.getUnit());

            receiptDetail.setMaterialIsBattery(material.getIsBattery());

            if (supplier!=null) {
                receiptDetail.setAllCreditCode(supplier.getAllCreditCode());

                receiptDetail.setOldBatterySource(supplier.getName());

            }

            //电池类才生成电池包二维码
            String batteryPackTwoCode=receiptDetailService.findBatteryPackTwoCode(receiptDetail);
            receiptDetail.setBatteryPackTwoCode(batteryPackTwoCode);
            //过磅号
            String poundCode=receiptDetailService.findPoundCode(receiptDetail);

            receiptDetail.setPoundCode(poundCode);

            if (!receiptDetailService.save(receiptDetail)) {

                throw new ServiceException("保存入库明细失败");
            }

            receiptDetailList.add(receiptDetail);

        }

        /* 7.step回传入库单和入库明细单 */

        ReceiptDomain receiptDomain = new ReceiptDomain();

        receiptDomain.setReceiptHeader(receiptHeader);

        receiptDomain.setReceiptDetails(receiptDetailList);

        return AjaxResult.success(receiptDomain);

    }

    /**
     * 检查入库头表合法性

     *

     * @param receiptHeader 入库头表
     * @return 检查结果
     */

    private AjaxResult checkReceiptHeader(ReceiptHeader receiptHeader) {

        /* 0.step 必填项是否为空*/
        if (StringUtils.isEmpty(receiptHeader.getCode()) || StringUtils.isEmpty(receiptHeader.getCompanyCode()) ||

                StringUtils.isEmpty(receiptHeader.getWarehouseCode()) || StringUtils.isEmpty(receiptHeader.getReceiptType())) {

            return AjaxResult.error("入库主单字段有误");
        }

        /* 1.step 查询该单据编码是否已存在*/
        LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambda = Wrappers.lambdaQuery(receiptHeader);

        if (receiptHeaderService.getOne(receiptHeaderLambda) != null) {
            return AjaxResult.error("该单据已存在：" + receiptHeader.getCode());

        }


        /* 3.step 判断仓库是否存在*/
        LambdaQueryWrapper<Warehouse> warehouseLambda = Wrappers.lambdaQuery();
        warehouseLambda.eq(Warehouse::getCode, receiptHeader.getWarehouseCode());

        if (warehouseService.getOne(warehouseLambda) == null) {

            return AjaxResult.error("该仓库不存在");
        }

        /* 4.step 判断货主是否存在*/
        LambdaQueryWrapper<Company> companyLambda = Wrappers.lambdaQuery();
        companyLambda.eq(Company::getCode, receiptHeader.getCompanyCode());

        if (companyService.getOne(companyLambda) == null) {

            return AjaxResult.error("该货主不存在");
        }

        /* 2.step 判断入库类型是否匹配*/
        LambdaQueryWrapper<ReceiptType> receiptTypeLambda = Wrappers.lambdaQuery();
        receiptTypeLambda.eq(ReceiptType::getCode, receiptHeader.getReceiptType())
                .eq(ReceiptType::getWarehouseCode, receiptHeader.getWarehouseCode())
                .eq(ReceiptType::getCompanyCode, receiptHeader.getCompanyCode());
        if (receiptTypeService.getOne(receiptTypeLambda) == null) {
            return AjaxResult.error("没有对应的入库单类型");
        }

        return AjaxResult.success("");
    }

    /**
     * 检查入库明细合法性

     *

     * @param receiptDetails 入库明细
     * @return 检查结果
     */

    private AjaxResult checkReceiptDetail(List<ReceiptDetail> receiptDetails) {

        for (ReceiptDetail receiptDetail : receiptDetails) {

            /* 0.step 判断必填字段是否为空且总数量不能为0*/

            if (receiptDetail.getMaterialCode() == null) {

                return AjaxResult.error("入库明细字段有误");
            }

//            if (new BigDecimal(0).compareTo(receiptDetail.getTotalWeight() != null ?
//                    receiptDetail.getTotalWeight() : new BigDecimal(0)) == 0 && new BigDecimal(0).compareTo(receiptDetail.getUnitId2Qty() != null ?
//                    receiptDetail.getUnitId2Qty() : new BigDecimal(0)) == 0) {
//                return AjaxResult.error("重量或数量为空");
//            }

            /* 1.step 判断供应商是否存在*/

            if (receiptDetail.getSupplierCode() != null) {

                LambdaQueryWrapper<Supplier> supplierLambda = Wrappers.lambdaQuery();
                supplierLambda.eq(Supplier::getCode, receiptDetail.getSupplierCode());
                if (supplierService.getOne(supplierLambda) == null) {
                    return AjaxResult.error("供应商不存在");
                }
            }

            /* 2.step 判断定位规则是否存在*/

            if (receiptDetail.getLocatingRule() != null) {

                LambdaQueryWrapper<FilterConfigDetail> filterConfigDetailLambda = Wrappers.lambdaQuery();
                filterConfigDetailLambda.eq(FilterConfigDetail::getCode, receiptDetail.getLocatingRule())
                        .eq(FilterConfigDetail::getModuleType, "receipt")
                        .eq(FilterConfigDetail::getRecordType, "locationRule");
                FilterConfigDetail filterConfigDetail = filterConfigDetailService.getOne(filterConfigDetailLambda);

                if (filterConfigDetail == null) {
                    return AjaxResult.error(receiptDetail.getLocatingRule() + "定位规则不存在");

                }
            }

            /* 3.step 判断流程编码是否存在*/

            if (receiptDetail.getStatusFlowCode() != null) {

                LambdaQueryWrapper<StatusFlowHeader> statusFlowHeaderLambda = Wrappers.lambdaQuery();
                statusFlowHeaderLambda.eq(StatusFlowHeader::getCode, receiptDetail.getStatusFlowCode())
                        .eq(StatusFlowHeader::getModuleType, "receipt")
                        .eq(StatusFlowHeader::getRecordType, "receivingFlow");
                StatusFlowHeader statusFlowHeader = statusFlowHeaderService.getOne(statusFlowHeaderLambda);

                if (statusFlowHeader == null) {
                    return AjaxResult.error(receiptDetail.getLocatingRule() + "该流程不存在");

                }
            }

        }

        return AjaxResult.success("");
    }

    @Transactional

    public AjaxResult remove(List<String> receiptCodeList) {
        LambdaQueryWrapper<ReceiptHeader> headerQueryWrapper;
        for (String receiptCode : receiptCodeList) {
            headerQueryWrapper = Wrappers.lambdaQuery();
            headerQueryWrapper.eq(ReceiptHeader::getCode,receiptCode);
            ReceiptHeader receiptHeader = receiptHeaderService.getOne(headerQueryWrapper);
            if (receiptHeader == null) {

                return AjaxResult.success("");
            }

            if ((receiptHeader.getFirstStatus() >= QuantityConstant.RECEIPT_HEADER_POSTING && receiptHeader.getLastStatus() >= QuantityConstant.RECEIPT_HEADER_POSTING) ||
                    (receiptHeader.getFirstStatus() < QuantityConstant.RECEIPT_HEADER_POOL & receiptHeader.getLastStatus() < QuantityConstant.RECEIPT_HEADER_POOL)) {

                ReceiptHeaderHistory receiptHeaderHistory = new ReceiptHeaderHistory();
                List<ReceiptDetailHistory> receiptDetailHistoryList = new ArrayList<>();
                //查询入库单明细
                LambdaQueryWrapper<ReceiptDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();

                lambdaQueryWrapper.eq(ReceiptDetail::getReceiptCode, receiptCode);

                List<ReceiptDetail> list = receiptDetailService.list(lambdaQueryWrapper);

                //复制到入库历史实体
                com.huaheng.common.utils.bean.BeanUtils.copyBeanProp(receiptHeaderHistory, receiptHeader);
                for (ReceiptDetail receiptDetail : list) {
                    ReceiptDetailHistory receiptDetailHistory = new ReceiptDetailHistory();
                    com.huaheng.common.utils.bean.BeanUtils.copyBeanProp(receiptDetailHistory, receiptDetail);
                    receiptDetailHistoryList.add(receiptDetailHistory);

                }

                receiptHeaderHistory.setLastUpdatedBy(ShiroUtils.getLoginName());

                if (!receiptHeaderService.removeById(receiptHeader.getId())) {

                    throw new ServiceException("删除头表失败");
                }

                if (!receiptHeaderHistoryService.save(receiptHeaderHistory)) {

                    throw new ServiceException("新增历史入库单失败");
                }
                // 当存在明细时删除

                if (list.size() != 0) {

                    //删除入库明细
                    List<Integer> receiptDetailIds = new ArrayList<>();

                    for (int i = 0; i < receiptDetailHistoryList.size(); i++) {

                        receiptDetailHistoryList.get(i).setLastUpdatedBy(ShiroUtils.getLoginName());
                        receiptDetailHistoryList.get(i).setReceiptId(receiptHeaderHistory.getId());
                        receiptDetailIds.add(receiptDetailHistoryList.get(i).getId());
                    }
                    if (!receiptDetailService.removeByIds(receiptDetailIds)) {
                        throw new ServiceException("删除明细表失败");
                    }

                    if (!receiptDetailHistoryService.saveBatch(receiptDetailHistoryList)) {

                        throw new ServiceException("新增明细失败");

                    }
                }
            } else {

                return AjaxResult.success("入库单没有完成，无法删除");
            }
        }
        return AjaxResult.success("删除成功");
    }

    public AjaxResult search(String receiptCode, String companyCode, String warehouseCode) {
        if (companyCode == null) {
            return AjaxResult.error("货主编码不能为空");
        }
        if (warehouseCode == null) {
            return AjaxResult.error("仓库编码不能为空");
        }
        ReceiptDomain receiptDomain = new ReceiptDomain();
        LambdaQueryWrapper<ReceiptHeader> headerLambdaQuery = Wrappers.lambdaQuery();
        LambdaQueryWrapper<ReceiptDetail> detailLambdaQuery = Wrappers.lambdaQuery();
        headerLambdaQuery.eq(ReceiptHeader::getWarehouseCode, warehouseCode)
                .eq(ReceiptHeader::getCompanyCode, companyCode)
                .eq(ReceiptHeader::getCode, receiptCode);
        detailLambdaQuery.eq(ReceiptDetail::getWarehouseCode, warehouseCode)
                .eq(ReceiptDetail::getCompanyCode, companyCode)
                .eq(ReceiptDetail::getReceiptCode, receiptCode);
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(headerLambdaQuery);
        List<ReceiptDetail> receiptDetailList = receiptDetailService.list(detailLambdaQuery);
        receiptDomain.setReceiptHeader(receiptHeader);
        receiptDomain.setReceiptDetails(receiptDetailList);
        return AjaxResult.success("查询成功", receiptDomain);
    }

}